Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessToSnapshotDeniedFault

type AccessToSnapshotDeniedFault struct {
	Message *string
}

    The owner of the specified snapshot has not authorized your account to access the snapshot.

    func (*AccessToSnapshotDeniedFault) Error

    func (*AccessToSnapshotDeniedFault) ErrorCode

    func (e *AccessToSnapshotDeniedFault) ErrorCode() string

    func (*AccessToSnapshotDeniedFault) ErrorFault

    func (*AccessToSnapshotDeniedFault) ErrorMessage

    func (e *AccessToSnapshotDeniedFault) ErrorMessage() string

    type AccountAttribute

    type AccountAttribute struct {
    
    	// The name of the attribute.
    	AttributeName *string
    
    	// A list of attribute values.
    	AttributeValues []AttributeValueTarget
    }

      A name value pair that describes an aspect of an account.

      type AccountWithRestoreAccess

      type AccountWithRestoreAccess struct {
      
      	// The identifier of an AWS support account authorized to restore a snapshot. For
      	// AWS support, the identifier is amazon-redshift-support.
      	AccountAlias *string
      
      	// The identifier of an AWS customer account authorized to restore a snapshot.
      	AccountId *string
      }

        Describes an AWS customer account authorized to restore a snapshot.

        type ActionType

        type ActionType string
        const (
        	ActionTypeRestoreCluster      ActionType = "restore-cluster"
        	ActionTypeRecommendNodeConfig ActionType = "recommend-node-config"
        	ActionTypeResizeCluster       ActionType = "resize-cluster"
        )

          Enum values for ActionType

          func (ActionType) Values

          func (ActionType) Values() []ActionType

            Values returns all known values for ActionType. 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 AttributeValueTarget

            type AttributeValueTarget struct {
            
            	// The value of the attribute.
            	AttributeValue *string
            }

              Describes an attribute value.

              type AuthorizationAlreadyExistsFault

              type AuthorizationAlreadyExistsFault struct {
              	Message *string
              }

                The specified CIDR block or EC2 security group is already authorized for the specified cluster 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 EC2 security group is not authorized for the specified cluster security group.

                  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 authorization quota for the cluster security group 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
                    
                    	//
                    	SupportedPlatforms []SupportedPlatform
                    }

                      Describes an availability zone.

                      type BatchDeleteRequestSizeExceededFault

                      type BatchDeleteRequestSizeExceededFault struct {
                      	Message *string
                      }

                        The maximum number for a batch delete of snapshots has been reached. The limit is 100.

                        func (*BatchDeleteRequestSizeExceededFault) Error

                        func (*BatchDeleteRequestSizeExceededFault) ErrorCode

                        func (*BatchDeleteRequestSizeExceededFault) ErrorFault

                        func (*BatchDeleteRequestSizeExceededFault) ErrorMessage

                        func (e *BatchDeleteRequestSizeExceededFault) ErrorMessage() string

                        type BatchModifyClusterSnapshotsLimitExceededFault

                        type BatchModifyClusterSnapshotsLimitExceededFault struct {
                        	Message *string
                        }

                          The maximum number for snapshot identifiers has been reached. The limit is 100.

                          func (*BatchModifyClusterSnapshotsLimitExceededFault) Error

                          func (*BatchModifyClusterSnapshotsLimitExceededFault) ErrorCode

                          func (*BatchModifyClusterSnapshotsLimitExceededFault) ErrorFault

                          func (*BatchModifyClusterSnapshotsLimitExceededFault) ErrorMessage

                          type BucketNotFoundFault

                          type BucketNotFoundFault struct {
                          	Message *string
                          }

                            Could not find the specified S3 bucket.

                            func (*BucketNotFoundFault) Error

                            func (e *BucketNotFoundFault) Error() string

                            func (*BucketNotFoundFault) ErrorCode

                            func (e *BucketNotFoundFault) ErrorCode() string

                            func (*BucketNotFoundFault) ErrorFault

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

                            func (*BucketNotFoundFault) ErrorMessage

                            func (e *BucketNotFoundFault) ErrorMessage() string

                            type Cluster

                            type Cluster struct {
                            
                            	// A boolean value that, if true, indicates that major version upgrades will be
                            	// applied automatically to the cluster during the maintenance window.
                            	AllowVersionUpgrade bool
                            
                            	// The number of days that automatic cluster snapshots are retained.
                            	AutomatedSnapshotRetentionPeriod int32
                            
                            	// The name of the Availability Zone in which the cluster is located.
                            	AvailabilityZone *string
                            
                            	// Describes the status of the Availability Zone relocation operation.
                            	AvailabilityZoneRelocationStatus *string
                            
                            	// The availability status of the cluster for queries. Possible values are the
                            	// following:
                            	//
                            	// * Available - The cluster is available for queries.
                            	//
                            	// * Unavailable -
                            	// The cluster is not available for queries.
                            	//
                            	// * Maintenance - The cluster is
                            	// intermittently available for queries due to maintenance activities.
                            	//
                            	// * Modifying
                            	// - The cluster is intermittently available for queries due to changes that modify
                            	// the cluster.
                            	//
                            	// * Failed - The cluster failed and is not available for queries.
                            	ClusterAvailabilityStatus *string
                            
                            	// The date and time that the cluster was created.
                            	ClusterCreateTime *time.Time
                            
                            	// The unique identifier of the cluster.
                            	ClusterIdentifier *string
                            
                            	// The namespace Amazon Resource Name (ARN) of the cluster.
                            	ClusterNamespaceArn *string
                            
                            	// The nodes in the cluster.
                            	ClusterNodes []ClusterNode
                            
                            	// The list of cluster parameter groups that are associated with this cluster. Each
                            	// parameter group in the list is returned with its status.
                            	ClusterParameterGroups []ClusterParameterGroupStatus
                            
                            	// The public key for the cluster.
                            	ClusterPublicKey *string
                            
                            	// The specific revision number of the database in the cluster.
                            	ClusterRevisionNumber *string
                            
                            	// A list of cluster security group that are associated with the cluster. Each
                            	// security group is represented by an element that contains
                            	// ClusterSecurityGroup.Name and ClusterSecurityGroup.Status subelements. Cluster
                            	// security groups are used when the cluster is not created in an Amazon Virtual
                            	// Private Cloud (VPC). Clusters that are created in a VPC use VPC security groups,
                            	// which are listed by the VpcSecurityGroups parameter.
                            	ClusterSecurityGroups []ClusterSecurityGroupMembership
                            
                            	// A value that returns the destination region and retention period that are
                            	// configured for cross-region snapshot copy.
                            	ClusterSnapshotCopyStatus *ClusterSnapshotCopyStatus
                            
                            	// The current state of the cluster. Possible values are the following:
                            	//
                            	// *
                            	// available
                            	//
                            	// * available, prep-for-resize
                            	//
                            	// * available, resize-cleanup
                            	//
                            	// *
                            	// cancelling-resize
                            	//
                            	// * creating
                            	//
                            	// * deleting
                            	//
                            	// * final-snapshot
                            	//
                            	// *
                            	// hardware-failure
                            	//
                            	// * incompatible-hsm
                            	//
                            	// * incompatible-network
                            	//
                            	// *
                            	// incompatible-parameters
                            	//
                            	// * incompatible-restore
                            	//
                            	// * modifying
                            	//
                            	// * paused
                            	//
                            	// *
                            	// rebooting
                            	//
                            	// * renaming
                            	//
                            	// * resizing
                            	//
                            	// * rotating-keys
                            	//
                            	// * storage-full
                            	//
                            	// *
                            	// updating-hsm
                            	ClusterStatus *string
                            
                            	// The name of the subnet group that is associated with the cluster. This parameter
                            	// is valid only when the cluster is in a VPC.
                            	ClusterSubnetGroupName *string
                            
                            	// The version ID of the Amazon Redshift engine that is running on the cluster.
                            	ClusterVersion *string
                            
                            	// The name of the initial database that was created when the cluster was created.
                            	// This same name is returned for the life of the cluster. If an initial database
                            	// was not specified, a database named devdev was created by default.
                            	DBName *string
                            
                            	//
                            	DataTransferProgress *DataTransferProgress
                            
                            	// Describes a group of DeferredMaintenanceWindow objects.
                            	DeferredMaintenanceWindows []DeferredMaintenanceWindow
                            
                            	// The status of the elastic IP (EIP) address.
                            	ElasticIpStatus *ElasticIpStatus
                            
                            	// The number of nodes that you can resize the cluster to with the elastic resize
                            	// method.
                            	ElasticResizeNumberOfNodeOptions *string
                            
                            	// A boolean value that, if true, indicates that data in the cluster is encrypted
                            	// at rest.
                            	Encrypted bool
                            
                            	// The connection endpoint.
                            	Endpoint *Endpoint
                            
                            	// An option that specifies whether to create the cluster with enhanced VPC routing
                            	// enabled. To create a cluster that uses enhanced VPC routing, the cluster must be
                            	// in a VPC. For more information, see Enhanced VPC Routing
                            	// (https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html) in
                            	// the Amazon Redshift Cluster Management Guide. If this option is true, enhanced
                            	// VPC routing is enabled. Default: false
                            	EnhancedVpcRouting bool
                            
                            	// The date and time when the next snapshot is expected to be taken for clusters
                            	// with a valid snapshot schedule and backups enabled.
                            	ExpectedNextSnapshotScheduleTime *time.Time
                            
                            	// The status of next expected snapshot for clusters having a valid snapshot
                            	// schedule and backups enabled. Possible values are the following:
                            	//
                            	// * OnTrack -
                            	// The next snapshot is expected to be taken on time.
                            	//
                            	// * Pending - The next
                            	// snapshot is pending to be taken.
                            	ExpectedNextSnapshotScheduleTimeStatus *string
                            
                            	// A value that reports whether the Amazon Redshift cluster has finished applying
                            	// any hardware security module (HSM) settings changes specified in a modify
                            	// cluster command. Values: active, applying
                            	HsmStatus *HsmStatus
                            
                            	// A list of AWS Identity and Access Management (IAM) roles that can be used by the
                            	// cluster to access other AWS services.
                            	IamRoles []ClusterIamRole
                            
                            	// The AWS Key Management Service (AWS KMS) key ID of the encryption key used to
                            	// encrypt data in the cluster.
                            	KmsKeyId *string
                            
                            	// The name of the maintenance track for the cluster.
                            	MaintenanceTrackName *string
                            
                            	// The default number of days to retain a manual snapshot. If the value is -1, the
                            	// snapshot is retained indefinitely. This setting doesn't change the retention
                            	// period of existing snapshots. The value must be either -1 or an integer between
                            	// 1 and 3,653.
                            	ManualSnapshotRetentionPeriod int32
                            
                            	// The master user name for the cluster. This name is used to connect to the
                            	// database that is specified in the DBName parameter.
                            	MasterUsername *string
                            
                            	// The status of a modify operation, if any, initiated for the cluster.
                            	ModifyStatus *string
                            
                            	// The date and time in UTC when system maintenance can begin.
                            	NextMaintenanceWindowStartTime *time.Time
                            
                            	// The node type for the nodes in the cluster.
                            	NodeType *string
                            
                            	// The number of compute nodes in the cluster.
                            	NumberOfNodes int32
                            
                            	// Cluster operations that are waiting to be started.
                            	PendingActions []string
                            
                            	// A value that, if present, indicates that changes to the cluster are pending.
                            	// Specific pending changes are identified by subelements.
                            	PendingModifiedValues *PendingModifiedValues
                            
                            	// The weekly time range, in Universal Coordinated Time (UTC), during which system
                            	// maintenance can occur.
                            	PreferredMaintenanceWindow *string
                            
                            	// A boolean value that, if true, indicates that the cluster can be accessed from a
                            	// public network.
                            	PubliclyAccessible bool
                            
                            	// Returns the following:
                            	//
                            	// * AllowCancelResize: a boolean value indicating if the
                            	// resize operation can be cancelled.
                            	//
                            	// * ResizeType: Returns ClassicResize
                            	ResizeInfo *ResizeInfo
                            
                            	// A value that describes the status of a cluster restore action. This parameter
                            	// returns null if the cluster was not created by restoring a snapshot.
                            	RestoreStatus *RestoreStatus
                            
                            	// A unique identifier for the cluster snapshot schedule.
                            	SnapshotScheduleIdentifier *string
                            
                            	// The current state of the cluster snapshot schedule.
                            	SnapshotScheduleState ScheduleState
                            
                            	// The list of tags for the cluster.
                            	Tags []Tag
                            
                            	// The identifier of the VPC the cluster is in, if the cluster is in a VPC.
                            	VpcId *string
                            
                            	// A list of Amazon Virtual Private Cloud (Amazon VPC) security groups that are
                            	// associated with the cluster. This parameter is returned only if the cluster is
                            	// in a VPC.
                            	VpcSecurityGroups []VpcSecurityGroupMembership
                            }

                              Describes a cluster.

                              type ClusterAlreadyExistsFault

                              type ClusterAlreadyExistsFault struct {
                              	Message *string
                              }

                                The account already has a cluster with the given identifier.

                                func (*ClusterAlreadyExistsFault) Error

                                func (e *ClusterAlreadyExistsFault) Error() string

                                func (*ClusterAlreadyExistsFault) ErrorCode

                                func (e *ClusterAlreadyExistsFault) ErrorCode() string

                                func (*ClusterAlreadyExistsFault) ErrorFault

                                func (*ClusterAlreadyExistsFault) ErrorMessage

                                func (e *ClusterAlreadyExistsFault) ErrorMessage() string

                                type ClusterAssociatedToSchedule

                                type ClusterAssociatedToSchedule struct {
                                
                                	//
                                	ClusterIdentifier *string
                                
                                	//
                                	ScheduleAssociationState ScheduleState
                                }

                                type ClusterDbRevision

                                type ClusterDbRevision struct {
                                
                                	// The unique identifier of the cluster.
                                	ClusterIdentifier *string
                                
                                	// A string representing the current cluster version.
                                	CurrentDatabaseRevision *string
                                
                                	// The date on which the database revision was released.
                                	DatabaseRevisionReleaseDate *time.Time
                                
                                	// A list of RevisionTarget objects, where each object describes the database
                                	// revision that a cluster can be updated to.
                                	RevisionTargets []RevisionTarget
                                }

                                  Describes a ClusterDbRevision.

                                  type ClusterIamRole

                                  type ClusterIamRole struct {
                                  
                                  	// A value that describes the status of the IAM role's association with an Amazon
                                  	// Redshift cluster. The following are possible statuses and descriptions.
                                  	//
                                  	// *
                                  	// in-sync: The role is available for use by the cluster.
                                  	//
                                  	// * adding: The role is in
                                  	// the process of being associated with the cluster.
                                  	//
                                  	// * removing: The role is in
                                  	// the process of being disassociated with the cluster.
                                  	ApplyStatus *string
                                  
                                  	// The Amazon Resource Name (ARN) of the IAM role, for example,
                                  	// arn:aws:iam::123456789012:role/RedshiftCopyUnload.
                                  	IamRoleArn *string
                                  }

                                    An AWS Identity and Access Management (IAM) role that can be used by the associated Amazon Redshift cluster to access other AWS services.

                                    type ClusterNode

                                    type ClusterNode struct {
                                    
                                    	// Whether the node is a leader node or a compute node.
                                    	NodeRole *string
                                    
                                    	// The private IP address of a node within a cluster.
                                    	PrivateIPAddress *string
                                    
                                    	// The public IP address of a node within a cluster.
                                    	PublicIPAddress *string
                                    }

                                      The identifier of a node in a cluster.

                                      type ClusterNotFoundFault

                                      type ClusterNotFoundFault struct {
                                      	Message *string
                                      }

                                        The ClusterIdentifier parameter does not refer to an existing cluster.

                                        func (*ClusterNotFoundFault) Error

                                        func (e *ClusterNotFoundFault) Error() string

                                        func (*ClusterNotFoundFault) ErrorCode

                                        func (e *ClusterNotFoundFault) ErrorCode() string

                                        func (*ClusterNotFoundFault) ErrorFault

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

                                        func (*ClusterNotFoundFault) ErrorMessage

                                        func (e *ClusterNotFoundFault) ErrorMessage() string

                                        type ClusterOnLatestRevisionFault

                                        type ClusterOnLatestRevisionFault struct {
                                        	Message *string
                                        }

                                          Cluster is already on the latest database revision.

                                          func (*ClusterOnLatestRevisionFault) Error

                                          func (*ClusterOnLatestRevisionFault) ErrorCode

                                          func (e *ClusterOnLatestRevisionFault) ErrorCode() string

                                          func (*ClusterOnLatestRevisionFault) ErrorFault

                                          func (*ClusterOnLatestRevisionFault) ErrorMessage

                                          func (e *ClusterOnLatestRevisionFault) ErrorMessage() string

                                          type ClusterParameterGroup

                                          type ClusterParameterGroup struct {
                                          
                                          	// The description of the parameter group.
                                          	Description *string
                                          
                                          	// The name of the cluster parameter group family that this cluster parameter group
                                          	// is compatible with.
                                          	ParameterGroupFamily *string
                                          
                                          	// The name of the cluster parameter group.
                                          	ParameterGroupName *string
                                          
                                          	// The list of tags for the cluster parameter group.
                                          	Tags []Tag
                                          }

                                            Describes a parameter group.

                                            type ClusterParameterGroupAlreadyExistsFault

                                            type ClusterParameterGroupAlreadyExistsFault struct {
                                            	Message *string
                                            }

                                              A cluster parameter group with the same name already exists.

                                              func (*ClusterParameterGroupAlreadyExistsFault) Error

                                              func (*ClusterParameterGroupAlreadyExistsFault) ErrorCode

                                              func (*ClusterParameterGroupAlreadyExistsFault) ErrorFault

                                              func (*ClusterParameterGroupAlreadyExistsFault) ErrorMessage

                                              type ClusterParameterGroupNotFoundFault

                                              type ClusterParameterGroupNotFoundFault struct {
                                              	Message *string
                                              }

                                                The parameter group name does not refer to an existing parameter group.

                                                func (*ClusterParameterGroupNotFoundFault) Error

                                                func (*ClusterParameterGroupNotFoundFault) ErrorCode

                                                func (*ClusterParameterGroupNotFoundFault) ErrorFault

                                                func (*ClusterParameterGroupNotFoundFault) ErrorMessage

                                                func (e *ClusterParameterGroupNotFoundFault) ErrorMessage() string

                                                type ClusterParameterGroupQuotaExceededFault

                                                type ClusterParameterGroupQuotaExceededFault struct {
                                                	Message *string
                                                }

                                                  The request would result in the user exceeding the allowed number of cluster parameter groups. For information about increasing your quota, go to Limits in Amazon Redshift (https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) in the Amazon Redshift Cluster Management Guide.

                                                  func (*ClusterParameterGroupQuotaExceededFault) Error

                                                  func (*ClusterParameterGroupQuotaExceededFault) ErrorCode

                                                  func (*ClusterParameterGroupQuotaExceededFault) ErrorFault

                                                  func (*ClusterParameterGroupQuotaExceededFault) ErrorMessage

                                                  type ClusterParameterGroupStatus

                                                  type ClusterParameterGroupStatus struct {
                                                  
                                                  	// The list of parameter statuses. For more information about parameters and
                                                  	// parameter groups, go to Amazon Redshift Parameter Groups
                                                  	// (https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html)
                                                  	// in the Amazon Redshift Cluster Management Guide.
                                                  	ClusterParameterStatusList []ClusterParameterStatus
                                                  
                                                  	// The status of parameter updates.
                                                  	ParameterApplyStatus *string
                                                  
                                                  	// The name of the cluster parameter group.
                                                  	ParameterGroupName *string
                                                  }

                                                    Describes the status of a parameter group.

                                                    type ClusterParameterStatus

                                                    type ClusterParameterStatus struct {
                                                    
                                                    	// The error that prevented the parameter from being applied to the database.
                                                    	ParameterApplyErrorDescription *string
                                                    
                                                    	// The status of the parameter that indicates whether the parameter is in sync with
                                                    	// the database, waiting for a cluster reboot, or encountered an error when being
                                                    	// applied. The following are possible statuses and descriptions.
                                                    	//
                                                    	// * in-sync: The
                                                    	// parameter value is in sync with the database.
                                                    	//
                                                    	// * pending-reboot: The parameter
                                                    	// value will be applied after the cluster reboots.
                                                    	//
                                                    	// * applying: The parameter
                                                    	// value is being applied to the database.
                                                    	//
                                                    	// * invalid-parameter: Cannot apply the
                                                    	// parameter value because it has an invalid value or syntax.
                                                    	//
                                                    	// * apply-deferred:
                                                    	// The parameter contains static property changes. The changes are deferred until
                                                    	// the cluster reboots.
                                                    	//
                                                    	// * apply-error: Cannot connect to the cluster. The
                                                    	// parameter change will be applied after the cluster reboots.
                                                    	//
                                                    	// * unknown-error:
                                                    	// Cannot apply the parameter change right now. The change will be applied after
                                                    	// the cluster reboots.
                                                    	ParameterApplyStatus *string
                                                    
                                                    	// The name of the parameter.
                                                    	ParameterName *string
                                                    }

                                                      Describes the status of a parameter group.

                                                      type ClusterQuotaExceededFault

                                                      type ClusterQuotaExceededFault struct {
                                                      	Message *string
                                                      }

                                                        The request would exceed the allowed number of cluster instances for this account. For information about increasing your quota, go to Limits in Amazon Redshift (https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) in the Amazon Redshift Cluster Management Guide.

                                                        func (*ClusterQuotaExceededFault) Error

                                                        func (e *ClusterQuotaExceededFault) Error() string

                                                        func (*ClusterQuotaExceededFault) ErrorCode

                                                        func (e *ClusterQuotaExceededFault) ErrorCode() string

                                                        func (*ClusterQuotaExceededFault) ErrorFault

                                                        func (*ClusterQuotaExceededFault) ErrorMessage

                                                        func (e *ClusterQuotaExceededFault) ErrorMessage() string

                                                        type ClusterSecurityGroup

                                                        type ClusterSecurityGroup struct {
                                                        
                                                        	// The name of the cluster security group to which the operation was applied.
                                                        	ClusterSecurityGroupName *string
                                                        
                                                        	// A description of the security group.
                                                        	Description *string
                                                        
                                                        	// A list of EC2 security groups that are permitted to access clusters associated
                                                        	// with this cluster security group.
                                                        	EC2SecurityGroups []EC2SecurityGroup
                                                        
                                                        	// A list of IP ranges (CIDR blocks) that are permitted to access clusters
                                                        	// associated with this cluster security group.
                                                        	IPRanges []IPRange
                                                        
                                                        	// The list of tags for the cluster security group.
                                                        	Tags []Tag
                                                        }

                                                          Describes a security group.

                                                          type ClusterSecurityGroupAlreadyExistsFault

                                                          type ClusterSecurityGroupAlreadyExistsFault struct {
                                                          	Message *string
                                                          }

                                                            A cluster security group with the same name already exists.

                                                            func (*ClusterSecurityGroupAlreadyExistsFault) Error

                                                            func (*ClusterSecurityGroupAlreadyExistsFault) ErrorCode

                                                            func (*ClusterSecurityGroupAlreadyExistsFault) ErrorFault

                                                            func (*ClusterSecurityGroupAlreadyExistsFault) ErrorMessage

                                                            type ClusterSecurityGroupMembership

                                                            type ClusterSecurityGroupMembership struct {
                                                            
                                                            	// The name of the cluster security group.
                                                            	ClusterSecurityGroupName *string
                                                            
                                                            	// The status of the cluster security group.
                                                            	Status *string
                                                            }

                                                              Describes a cluster security group.

                                                              type ClusterSecurityGroupNotFoundFault

                                                              type ClusterSecurityGroupNotFoundFault struct {
                                                              	Message *string
                                                              }

                                                                The cluster security group name does not refer to an existing cluster security group.

                                                                func (*ClusterSecurityGroupNotFoundFault) Error

                                                                func (*ClusterSecurityGroupNotFoundFault) ErrorCode

                                                                func (*ClusterSecurityGroupNotFoundFault) ErrorFault

                                                                func (*ClusterSecurityGroupNotFoundFault) ErrorMessage

                                                                func (e *ClusterSecurityGroupNotFoundFault) ErrorMessage() string

                                                                type ClusterSecurityGroupQuotaExceededFault

                                                                type ClusterSecurityGroupQuotaExceededFault struct {
                                                                	Message *string
                                                                }

                                                                  The request would result in the user exceeding the allowed number of cluster security groups. For information about increasing your quota, go to Limits in Amazon Redshift (https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) in the Amazon Redshift Cluster Management Guide.

                                                                  func (*ClusterSecurityGroupQuotaExceededFault) Error

                                                                  func (*ClusterSecurityGroupQuotaExceededFault) ErrorCode

                                                                  func (*ClusterSecurityGroupQuotaExceededFault) ErrorFault

                                                                  func (*ClusterSecurityGroupQuotaExceededFault) ErrorMessage

                                                                  type ClusterSnapshotAlreadyExistsFault

                                                                  type ClusterSnapshotAlreadyExistsFault struct {
                                                                  	Message *string
                                                                  }

                                                                    The value specified as a snapshot identifier is already used by an existing snapshot.

                                                                    func (*ClusterSnapshotAlreadyExistsFault) Error

                                                                    func (*ClusterSnapshotAlreadyExistsFault) ErrorCode

                                                                    func (*ClusterSnapshotAlreadyExistsFault) ErrorFault

                                                                    func (*ClusterSnapshotAlreadyExistsFault) ErrorMessage

                                                                    func (e *ClusterSnapshotAlreadyExistsFault) ErrorMessage() string

                                                                    type ClusterSnapshotCopyStatus

                                                                    type ClusterSnapshotCopyStatus struct {
                                                                    
                                                                    	// The destination region that snapshots are automatically copied to when
                                                                    	// cross-region snapshot copy is enabled.
                                                                    	DestinationRegion *string
                                                                    
                                                                    	// The number of days that automated snapshots are retained in the destination
                                                                    	// region after they are copied from a source region. If the value is -1, the
                                                                    	// manual snapshot is retained indefinitely. The value must be either -1 or an
                                                                    	// integer between 1 and 3,653.
                                                                    	ManualSnapshotRetentionPeriod int32
                                                                    
                                                                    	// The number of days that automated snapshots are retained in the destination
                                                                    	// region after they are copied from a source region.
                                                                    	RetentionPeriod int64
                                                                    
                                                                    	// The name of the snapshot copy grant.
                                                                    	SnapshotCopyGrantName *string
                                                                    }

                                                                      Returns the destination region and retention period that are configured for cross-region snapshot copy.

                                                                      type ClusterSnapshotNotFoundFault

                                                                      type ClusterSnapshotNotFoundFault struct {
                                                                      	Message *string
                                                                      }

                                                                        The snapshot identifier does not refer to an existing cluster snapshot.

                                                                        func (*ClusterSnapshotNotFoundFault) Error

                                                                        func (*ClusterSnapshotNotFoundFault) ErrorCode

                                                                        func (e *ClusterSnapshotNotFoundFault) ErrorCode() string

                                                                        func (*ClusterSnapshotNotFoundFault) ErrorFault

                                                                        func (*ClusterSnapshotNotFoundFault) ErrorMessage

                                                                        func (e *ClusterSnapshotNotFoundFault) ErrorMessage() string

                                                                        type ClusterSnapshotQuotaExceededFault

                                                                        type ClusterSnapshotQuotaExceededFault struct {
                                                                        	Message *string
                                                                        }

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

                                                                          func (*ClusterSnapshotQuotaExceededFault) Error

                                                                          func (*ClusterSnapshotQuotaExceededFault) ErrorCode

                                                                          func (*ClusterSnapshotQuotaExceededFault) ErrorFault

                                                                          func (*ClusterSnapshotQuotaExceededFault) ErrorMessage

                                                                          func (e *ClusterSnapshotQuotaExceededFault) ErrorMessage() string

                                                                          type ClusterSubnetGroup

                                                                          type ClusterSubnetGroup struct {
                                                                          
                                                                          	// The name of the cluster subnet group.
                                                                          	ClusterSubnetGroupName *string
                                                                          
                                                                          	// The description of the cluster subnet group.
                                                                          	Description *string
                                                                          
                                                                          	// The status of the cluster subnet group. Possible values are Complete, Incomplete
                                                                          	// and Invalid.
                                                                          	SubnetGroupStatus *string
                                                                          
                                                                          	// A list of the VPC Subnet elements.
                                                                          	Subnets []Subnet
                                                                          
                                                                          	// The list of tags for the cluster subnet group.
                                                                          	Tags []Tag
                                                                          
                                                                          	// The VPC ID of the cluster subnet group.
                                                                          	VpcId *string
                                                                          }

                                                                            Describes a subnet group.

                                                                            type ClusterSubnetGroupAlreadyExistsFault

                                                                            type ClusterSubnetGroupAlreadyExistsFault struct {
                                                                            	Message *string
                                                                            }

                                                                              A ClusterSubnetGroupName is already used by an existing cluster subnet group.

                                                                              func (*ClusterSubnetGroupAlreadyExistsFault) Error

                                                                              func (*ClusterSubnetGroupAlreadyExistsFault) ErrorCode

                                                                              func (*ClusterSubnetGroupAlreadyExistsFault) ErrorFault

                                                                              func (*ClusterSubnetGroupAlreadyExistsFault) ErrorMessage

                                                                              func (e *ClusterSubnetGroupAlreadyExistsFault) ErrorMessage() string

                                                                              type ClusterSubnetGroupNotFoundFault

                                                                              type ClusterSubnetGroupNotFoundFault struct {
                                                                              	Message *string
                                                                              }

                                                                                The cluster subnet group name does not refer to an existing cluster subnet group.

                                                                                func (*ClusterSubnetGroupNotFoundFault) Error

                                                                                func (*ClusterSubnetGroupNotFoundFault) ErrorCode

                                                                                func (e *ClusterSubnetGroupNotFoundFault) ErrorCode() string

                                                                                func (*ClusterSubnetGroupNotFoundFault) ErrorFault

                                                                                func (*ClusterSubnetGroupNotFoundFault) ErrorMessage

                                                                                func (e *ClusterSubnetGroupNotFoundFault) ErrorMessage() string

                                                                                type ClusterSubnetGroupQuotaExceededFault

                                                                                type ClusterSubnetGroupQuotaExceededFault struct {
                                                                                	Message *string
                                                                                }

                                                                                  The request would result in user exceeding the allowed number of cluster subnet groups. For information about increasing your quota, go to Limits in Amazon Redshift (https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) in the Amazon Redshift Cluster Management Guide.

                                                                                  func (*ClusterSubnetGroupQuotaExceededFault) Error

                                                                                  func (*ClusterSubnetGroupQuotaExceededFault) ErrorCode

                                                                                  func (*ClusterSubnetGroupQuotaExceededFault) ErrorFault

                                                                                  func (*ClusterSubnetGroupQuotaExceededFault) ErrorMessage

                                                                                  func (e *ClusterSubnetGroupQuotaExceededFault) ErrorMessage() string

                                                                                  type ClusterSubnetQuotaExceededFault

                                                                                  type ClusterSubnetQuotaExceededFault struct {
                                                                                  	Message *string
                                                                                  }

                                                                                    The request would result in user exceeding the allowed number of subnets in a cluster subnet groups. For information about increasing your quota, go to Limits in Amazon Redshift (https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) in the Amazon Redshift Cluster Management Guide.

                                                                                    func (*ClusterSubnetQuotaExceededFault) Error

                                                                                    func (*ClusterSubnetQuotaExceededFault) ErrorCode

                                                                                    func (e *ClusterSubnetQuotaExceededFault) ErrorCode() string

                                                                                    func (*ClusterSubnetQuotaExceededFault) ErrorFault

                                                                                    func (*ClusterSubnetQuotaExceededFault) ErrorMessage

                                                                                    func (e *ClusterSubnetQuotaExceededFault) ErrorMessage() string

                                                                                    type ClusterVersion

                                                                                    type ClusterVersion struct {
                                                                                    
                                                                                    	// The name of the cluster parameter group family for the cluster.
                                                                                    	ClusterParameterGroupFamily *string
                                                                                    
                                                                                    	// The version number used by the cluster.
                                                                                    	ClusterVersion *string
                                                                                    
                                                                                    	// The description of the cluster version.
                                                                                    	Description *string
                                                                                    }

                                                                                      Describes a cluster version, including the parameter group family and description of the version.

                                                                                      type CopyToRegionDisabledFault

                                                                                      type CopyToRegionDisabledFault struct {
                                                                                      	Message *string
                                                                                      }

                                                                                        Cross-region snapshot copy was temporarily disabled. Try your request again.

                                                                                        func (*CopyToRegionDisabledFault) Error

                                                                                        func (e *CopyToRegionDisabledFault) Error() string

                                                                                        func (*CopyToRegionDisabledFault) ErrorCode

                                                                                        func (e *CopyToRegionDisabledFault) ErrorCode() string

                                                                                        func (*CopyToRegionDisabledFault) ErrorFault

                                                                                        func (*CopyToRegionDisabledFault) ErrorMessage

                                                                                        func (e *CopyToRegionDisabledFault) ErrorMessage() string

                                                                                        type DataTransferProgress

                                                                                        type DataTransferProgress struct {
                                                                                        
                                                                                        	// Describes the data transfer rate in MB's per second.
                                                                                        	CurrentRateInMegaBytesPerSecond *float64
                                                                                        
                                                                                        	// Describes the total amount of data that has been transfered in MB's.
                                                                                        	DataTransferredInMegaBytes int64
                                                                                        
                                                                                        	// Describes the number of seconds that have elapsed during the data transfer.
                                                                                        	ElapsedTimeInSeconds *int64
                                                                                        
                                                                                        	// Describes the estimated number of seconds remaining to complete the transfer.
                                                                                        	EstimatedTimeToCompletionInSeconds *int64
                                                                                        
                                                                                        	// Describes the status of the cluster. While the transfer is in progress the
                                                                                        	// status is transferringdata.
                                                                                        	Status *string
                                                                                        
                                                                                        	// Describes the total amount of data to be transfered in megabytes.
                                                                                        	TotalDataInMegaBytes int64
                                                                                        }

                                                                                          Describes the status of a cluster while it is in the process of resizing with an incremental resize.

                                                                                          type DefaultClusterParameters

                                                                                          type DefaultClusterParameters struct {
                                                                                          
                                                                                          	// A value that indicates the starting point for the next set of response records
                                                                                          	// in a subsequent request. If a value is returned in a response, you can retrieve
                                                                                          	// the next set of records by providing this returned marker value in the Marker
                                                                                          	// parameter and retrying the command. If the Marker field is empty, all response
                                                                                          	// records have been retrieved for the request.
                                                                                          	Marker *string
                                                                                          
                                                                                          	// The name of the cluster parameter group family to which the engine default
                                                                                          	// parameters apply.
                                                                                          	ParameterGroupFamily *string
                                                                                          
                                                                                          	// The list of cluster default parameters.
                                                                                          	Parameters []Parameter
                                                                                          }

                                                                                            Describes the default cluster parameters for a parameter group family.

                                                                                            type DeferredMaintenanceWindow

                                                                                            type DeferredMaintenanceWindow struct {
                                                                                            
                                                                                            	// A timestamp for the end of the time period when we defer maintenance.
                                                                                            	DeferMaintenanceEndTime *time.Time
                                                                                            
                                                                                            	// A unique identifier for the maintenance window.
                                                                                            	DeferMaintenanceIdentifier *string
                                                                                            
                                                                                            	// A timestamp for the beginning of the time period when we defer maintenance.
                                                                                            	DeferMaintenanceStartTime *time.Time
                                                                                            }

                                                                                              Describes a deferred maintenance window

                                                                                              type DeleteClusterSnapshotMessage

                                                                                              type DeleteClusterSnapshotMessage struct {
                                                                                              
                                                                                              	// The unique identifier of the manual snapshot to be deleted. Constraints: Must be
                                                                                              	// the name of an existing snapshot that is in the available, failed, or cancelled
                                                                                              	// state.
                                                                                              	//
                                                                                              	// This member is required.
                                                                                              	SnapshotIdentifier *string
                                                                                              
                                                                                              	// The unique identifier of the cluster the snapshot was created from. This
                                                                                              	// parameter is required if your IAM user has a policy containing a snapshot
                                                                                              	// resource element that specifies anything other than * for the cluster name.
                                                                                              	// Constraints: Must be the name of valid cluster.
                                                                                              	SnapshotClusterIdentifier *string
                                                                                              }

                                                                                              type DependentServiceRequestThrottlingFault

                                                                                              type DependentServiceRequestThrottlingFault struct {
                                                                                              	Message *string
                                                                                              }

                                                                                                The request cannot be completed because a dependent service is throttling requests made by Amazon Redshift on your behalf. Wait and retry the request.

                                                                                                func (*DependentServiceRequestThrottlingFault) Error

                                                                                                func (*DependentServiceRequestThrottlingFault) ErrorCode

                                                                                                func (*DependentServiceRequestThrottlingFault) ErrorFault

                                                                                                func (*DependentServiceRequestThrottlingFault) ErrorMessage

                                                                                                type DependentServiceUnavailableFault

                                                                                                type DependentServiceUnavailableFault struct {
                                                                                                	Message *string
                                                                                                }

                                                                                                  Your request cannot be completed because a dependent internal service is temporarily unavailable. Wait 30 to 60 seconds and try again.

                                                                                                  func (*DependentServiceUnavailableFault) Error

                                                                                                  func (*DependentServiceUnavailableFault) ErrorCode

                                                                                                  func (*DependentServiceUnavailableFault) ErrorFault

                                                                                                  func (*DependentServiceUnavailableFault) ErrorMessage

                                                                                                  func (e *DependentServiceUnavailableFault) ErrorMessage() string

                                                                                                  type EC2SecurityGroup

                                                                                                  type EC2SecurityGroup struct {
                                                                                                  
                                                                                                  	// The name of the EC2 Security Group.
                                                                                                  	EC2SecurityGroupName *string
                                                                                                  
                                                                                                  	// The AWS ID of the owner of the EC2 security group specified in the
                                                                                                  	// EC2SecurityGroupName field.
                                                                                                  	EC2SecurityGroupOwnerId *string
                                                                                                  
                                                                                                  	// The status of the EC2 security group.
                                                                                                  	Status *string
                                                                                                  
                                                                                                  	// The list of tags for the EC2 security group.
                                                                                                  	Tags []Tag
                                                                                                  }

                                                                                                    Describes an Amazon EC2 security group.

                                                                                                    type ElasticIpStatus

                                                                                                    type ElasticIpStatus struct {
                                                                                                    
                                                                                                    	// The elastic IP (EIP) address for the cluster.
                                                                                                    	ElasticIp *string
                                                                                                    
                                                                                                    	// The status of the elastic IP (EIP) address.
                                                                                                    	Status *string
                                                                                                    }

                                                                                                      Describes the status of the elastic IP (EIP) address.

                                                                                                      type Endpoint

                                                                                                      type Endpoint struct {
                                                                                                      
                                                                                                      	// The DNS address of the Cluster.
                                                                                                      	Address *string
                                                                                                      
                                                                                                      	// The port that the database engine is listening on.
                                                                                                      	Port int32
                                                                                                      
                                                                                                      	// Describes a connection endpoint.
                                                                                                      	VpcEndpoints []SpartaProxyVpcEndpoint
                                                                                                      }

                                                                                                        Describes a connection endpoint.

                                                                                                        type Event

                                                                                                        type Event struct {
                                                                                                        
                                                                                                        	// The date and time of the event.
                                                                                                        	Date *time.Time
                                                                                                        
                                                                                                        	// A list of the event categories. Values: Configuration, Management, Monitoring,
                                                                                                        	// Security
                                                                                                        	EventCategories []string
                                                                                                        
                                                                                                        	// The identifier of the event.
                                                                                                        	EventId *string
                                                                                                        
                                                                                                        	// The text of this event.
                                                                                                        	Message *string
                                                                                                        
                                                                                                        	// The severity of the event. Values: ERROR, INFO
                                                                                                        	Severity *string
                                                                                                        
                                                                                                        	// The identifier for the source of the event.
                                                                                                        	SourceIdentifier *string
                                                                                                        
                                                                                                        	// The source type for this event.
                                                                                                        	SourceType SourceType
                                                                                                        }

                                                                                                          Describes an event.

                                                                                                          type EventCategoriesMap

                                                                                                          type EventCategoriesMap struct {
                                                                                                          
                                                                                                          	// The events in the event category.
                                                                                                          	Events []EventInfoMap
                                                                                                          
                                                                                                          	// The source type, such as cluster or cluster-snapshot, that the returned
                                                                                                          	// categories belong to.
                                                                                                          	SourceType *string
                                                                                                          }

                                                                                                            Describes event categories.

                                                                                                            type EventInfoMap

                                                                                                            type EventInfoMap struct {
                                                                                                            
                                                                                                            	// The category of an Amazon Redshift event.
                                                                                                            	EventCategories []string
                                                                                                            
                                                                                                            	// The description of an Amazon Redshift event.
                                                                                                            	EventDescription *string
                                                                                                            
                                                                                                            	// The identifier of an Amazon Redshift event.
                                                                                                            	EventId *string
                                                                                                            
                                                                                                            	// The severity of the event. Values: ERROR, INFO
                                                                                                            	Severity *string
                                                                                                            }

                                                                                                              Describes event information.

                                                                                                              type EventSubscription

                                                                                                              type EventSubscription struct {
                                                                                                              
                                                                                                              	// The name of the Amazon Redshift event notification subscription.
                                                                                                              	CustSubscriptionId *string
                                                                                                              
                                                                                                              	// The AWS customer account associated with the Amazon Redshift event notification
                                                                                                              	// subscription.
                                                                                                              	CustomerAwsId *string
                                                                                                              
                                                                                                              	// A boolean value indicating whether the subscription is enabled; true indicates
                                                                                                              	// that the subscription is enabled.
                                                                                                              	Enabled bool
                                                                                                              
                                                                                                              	// The list of Amazon Redshift event categories specified in the event notification
                                                                                                              	// subscription. Values: Configuration, Management, Monitoring, Security
                                                                                                              	EventCategoriesList []string
                                                                                                              
                                                                                                              	// The event severity specified in the Amazon Redshift event notification
                                                                                                              	// subscription. Values: ERROR, INFO
                                                                                                              	Severity *string
                                                                                                              
                                                                                                              	// The Amazon Resource Name (ARN) of the Amazon SNS topic used by the event
                                                                                                              	// notification subscription.
                                                                                                              	SnsTopicArn *string
                                                                                                              
                                                                                                              	// A list of the sources that publish events to the Amazon Redshift event
                                                                                                              	// notification subscription.
                                                                                                              	SourceIdsList []string
                                                                                                              
                                                                                                              	// The source type of the events returned by the Amazon Redshift event
                                                                                                              	// notification, such as cluster, cluster-snapshot, cluster-parameter-group,
                                                                                                              	// cluster-security-group, or scheduled-action.
                                                                                                              	SourceType *string
                                                                                                              
                                                                                                              	// The status of the Amazon Redshift event notification subscription.
                                                                                                              	// Constraints:
                                                                                                              	//
                                                                                                              	// * Can be one of the following: active | no-permission |
                                                                                                              	// topic-not-exist
                                                                                                              	//
                                                                                                              	// * The status "no-permission" indicates that Amazon Redshift no
                                                                                                              	// longer has permission to post to the Amazon SNS topic. The status
                                                                                                              	// "topic-not-exist" indicates that the topic was deleted after the subscription
                                                                                                              	// was created.
                                                                                                              	Status *string
                                                                                                              
                                                                                                              	// The date and time the Amazon Redshift event notification subscription was
                                                                                                              	// created.
                                                                                                              	SubscriptionCreationTime *time.Time
                                                                                                              
                                                                                                              	// The list of tags for the event subscription.
                                                                                                              	Tags []Tag
                                                                                                              }

                                                                                                                Describes event subscriptions.

                                                                                                                type EventSubscriptionQuotaExceededFault

                                                                                                                type EventSubscriptionQuotaExceededFault struct {
                                                                                                                	Message *string
                                                                                                                }

                                                                                                                  The request would exceed the allowed number of event subscriptions for this account. For information about increasing your quota, go to Limits in Amazon Redshift (https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) in the Amazon Redshift Cluster Management Guide.

                                                                                                                  func (*EventSubscriptionQuotaExceededFault) Error

                                                                                                                  func (*EventSubscriptionQuotaExceededFault) ErrorCode

                                                                                                                  func (*EventSubscriptionQuotaExceededFault) ErrorFault

                                                                                                                  func (*EventSubscriptionQuotaExceededFault) ErrorMessage

                                                                                                                  func (e *EventSubscriptionQuotaExceededFault) ErrorMessage() string

                                                                                                                  type HsmClientCertificate

                                                                                                                  type HsmClientCertificate struct {
                                                                                                                  
                                                                                                                  	// The identifier of the HSM client certificate.
                                                                                                                  	HsmClientCertificateIdentifier *string
                                                                                                                  
                                                                                                                  	// The public key that the Amazon Redshift cluster will use to connect to the HSM.
                                                                                                                  	// You must register the public key in the HSM.
                                                                                                                  	HsmClientCertificatePublicKey *string
                                                                                                                  
                                                                                                                  	// The list of tags for the HSM client certificate.
                                                                                                                  	Tags []Tag
                                                                                                                  }

                                                                                                                    Returns information about an HSM client certificate. The certificate is stored in a secure Hardware Storage Module (HSM), and used by the Amazon Redshift cluster to encrypt data files.

                                                                                                                    type HsmClientCertificateAlreadyExistsFault

                                                                                                                    type HsmClientCertificateAlreadyExistsFault struct {
                                                                                                                    	Message *string
                                                                                                                    }

                                                                                                                      There is already an existing Amazon Redshift HSM client certificate with the specified identifier.

                                                                                                                      func (*HsmClientCertificateAlreadyExistsFault) Error

                                                                                                                      func (*HsmClientCertificateAlreadyExistsFault) ErrorCode

                                                                                                                      func (*HsmClientCertificateAlreadyExistsFault) ErrorFault

                                                                                                                      func (*HsmClientCertificateAlreadyExistsFault) ErrorMessage

                                                                                                                      type HsmClientCertificateNotFoundFault

                                                                                                                      type HsmClientCertificateNotFoundFault struct {
                                                                                                                      	Message *string
                                                                                                                      }

                                                                                                                        There is no Amazon Redshift HSM client certificate with the specified identifier.

                                                                                                                        func (*HsmClientCertificateNotFoundFault) Error

                                                                                                                        func (*HsmClientCertificateNotFoundFault) ErrorCode

                                                                                                                        func (*HsmClientCertificateNotFoundFault) ErrorFault

                                                                                                                        func (*HsmClientCertificateNotFoundFault) ErrorMessage

                                                                                                                        func (e *HsmClientCertificateNotFoundFault) ErrorMessage() string

                                                                                                                        type HsmClientCertificateQuotaExceededFault

                                                                                                                        type HsmClientCertificateQuotaExceededFault struct {
                                                                                                                        	Message *string
                                                                                                                        }

                                                                                                                          The quota for HSM client certificates has been reached. For information about increasing your quota, go to Limits in Amazon Redshift (https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) in the Amazon Redshift Cluster Management Guide.

                                                                                                                          func (*HsmClientCertificateQuotaExceededFault) Error

                                                                                                                          func (*HsmClientCertificateQuotaExceededFault) ErrorCode

                                                                                                                          func (*HsmClientCertificateQuotaExceededFault) ErrorFault

                                                                                                                          func (*HsmClientCertificateQuotaExceededFault) ErrorMessage

                                                                                                                          type HsmConfiguration

                                                                                                                          type HsmConfiguration struct {
                                                                                                                          
                                                                                                                          	// A text description of the HSM configuration.
                                                                                                                          	Description *string
                                                                                                                          
                                                                                                                          	// The name of the Amazon Redshift HSM configuration.
                                                                                                                          	HsmConfigurationIdentifier *string
                                                                                                                          
                                                                                                                          	// The IP address that the Amazon Redshift cluster must use to access the HSM.
                                                                                                                          	HsmIpAddress *string
                                                                                                                          
                                                                                                                          	// The name of the partition in the HSM where the Amazon Redshift clusters will
                                                                                                                          	// store their database encryption keys.
                                                                                                                          	HsmPartitionName *string
                                                                                                                          
                                                                                                                          	// The list of tags for the HSM configuration.
                                                                                                                          	Tags []Tag
                                                                                                                          }

                                                                                                                            Returns information about an HSM configuration, which is an object that describes to Amazon Redshift clusters the information they require to connect to an HSM where they can store database encryption keys.

                                                                                                                            type HsmConfigurationAlreadyExistsFault

                                                                                                                            type HsmConfigurationAlreadyExistsFault struct {
                                                                                                                            	Message *string
                                                                                                                            }

                                                                                                                              There is already an existing Amazon Redshift HSM configuration with the specified identifier.

                                                                                                                              func (*HsmConfigurationAlreadyExistsFault) Error

                                                                                                                              func (*HsmConfigurationAlreadyExistsFault) ErrorCode

                                                                                                                              func (*HsmConfigurationAlreadyExistsFault) ErrorFault

                                                                                                                              func (*HsmConfigurationAlreadyExistsFault) ErrorMessage

                                                                                                                              func (e *HsmConfigurationAlreadyExistsFault) ErrorMessage() string

                                                                                                                              type HsmConfigurationNotFoundFault

                                                                                                                              type HsmConfigurationNotFoundFault struct {
                                                                                                                              	Message *string
                                                                                                                              }

                                                                                                                                There is no Amazon Redshift HSM configuration with the specified identifier.

                                                                                                                                func (*HsmConfigurationNotFoundFault) Error

                                                                                                                                func (*HsmConfigurationNotFoundFault) ErrorCode

                                                                                                                                func (e *HsmConfigurationNotFoundFault) ErrorCode() string

                                                                                                                                func (*HsmConfigurationNotFoundFault) ErrorFault

                                                                                                                                func (*HsmConfigurationNotFoundFault) ErrorMessage

                                                                                                                                func (e *HsmConfigurationNotFoundFault) ErrorMessage() string

                                                                                                                                type HsmConfigurationQuotaExceededFault

                                                                                                                                type HsmConfigurationQuotaExceededFault struct {
                                                                                                                                	Message *string
                                                                                                                                }

                                                                                                                                  The quota for HSM configurations has been reached. For information about increasing your quota, go to Limits in Amazon Redshift (https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) in the Amazon Redshift Cluster Management Guide.

                                                                                                                                  func (*HsmConfigurationQuotaExceededFault) Error

                                                                                                                                  func (*HsmConfigurationQuotaExceededFault) ErrorCode

                                                                                                                                  func (*HsmConfigurationQuotaExceededFault) ErrorFault

                                                                                                                                  func (*HsmConfigurationQuotaExceededFault) ErrorMessage

                                                                                                                                  func (e *HsmConfigurationQuotaExceededFault) ErrorMessage() string

                                                                                                                                  type HsmStatus

                                                                                                                                  type HsmStatus struct {
                                                                                                                                  
                                                                                                                                  	// Specifies the name of the HSM client certificate the Amazon Redshift cluster
                                                                                                                                  	// uses to retrieve the data encryption keys stored in an HSM.
                                                                                                                                  	HsmClientCertificateIdentifier *string
                                                                                                                                  
                                                                                                                                  	// Specifies the name of the HSM configuration that contains the information the
                                                                                                                                  	// Amazon Redshift cluster can use to retrieve and store keys in an HSM.
                                                                                                                                  	HsmConfigurationIdentifier *string
                                                                                                                                  
                                                                                                                                  	// Reports whether the Amazon Redshift cluster has finished applying any HSM
                                                                                                                                  	// settings changes specified in a modify cluster command. Values: active, applying
                                                                                                                                  	Status *string
                                                                                                                                  }

                                                                                                                                    Describes the status of changes to HSM settings.

                                                                                                                                    type IPRange

                                                                                                                                    type IPRange struct {
                                                                                                                                    
                                                                                                                                    	// The IP range in Classless Inter-Domain Routing (CIDR) notation.
                                                                                                                                    	CIDRIP *string
                                                                                                                                    
                                                                                                                                    	// The status of the IP range, for example, "authorized".
                                                                                                                                    	Status *string
                                                                                                                                    
                                                                                                                                    	// The list of tags for the IP range.
                                                                                                                                    	Tags []Tag
                                                                                                                                    }

                                                                                                                                      Describes an IP range used in a security group.

                                                                                                                                      type InProgressTableRestoreQuotaExceededFault

                                                                                                                                      type InProgressTableRestoreQuotaExceededFault struct {
                                                                                                                                      	Message *string
                                                                                                                                      }

                                                                                                                                        You have exceeded the allowed number of table restore requests. Wait for your current table restore requests to complete before making a new request.

                                                                                                                                        func (*InProgressTableRestoreQuotaExceededFault) Error

                                                                                                                                        func (*InProgressTableRestoreQuotaExceededFault) ErrorCode

                                                                                                                                        func (*InProgressTableRestoreQuotaExceededFault) ErrorFault

                                                                                                                                        func (*InProgressTableRestoreQuotaExceededFault) ErrorMessage

                                                                                                                                        type IncompatibleOrderableOptions

                                                                                                                                        type IncompatibleOrderableOptions struct {
                                                                                                                                        	Message *string
                                                                                                                                        }

                                                                                                                                          The specified options are incompatible.

                                                                                                                                          func (*IncompatibleOrderableOptions) Error

                                                                                                                                          func (*IncompatibleOrderableOptions) ErrorCode

                                                                                                                                          func (e *IncompatibleOrderableOptions) ErrorCode() string

                                                                                                                                          func (*IncompatibleOrderableOptions) ErrorFault

                                                                                                                                          func (*IncompatibleOrderableOptions) ErrorMessage

                                                                                                                                          func (e *IncompatibleOrderableOptions) ErrorMessage() string

                                                                                                                                          type InsufficientClusterCapacityFault

                                                                                                                                          type InsufficientClusterCapacityFault struct {
                                                                                                                                          	Message *string
                                                                                                                                          }

                                                                                                                                            The number of nodes specified exceeds the allotted capacity of the cluster.

                                                                                                                                            func (*InsufficientClusterCapacityFault) Error

                                                                                                                                            func (*InsufficientClusterCapacityFault) ErrorCode

                                                                                                                                            func (*InsufficientClusterCapacityFault) ErrorFault

                                                                                                                                            func (*InsufficientClusterCapacityFault) ErrorMessage

                                                                                                                                            func (e *InsufficientClusterCapacityFault) ErrorMessage() string

                                                                                                                                            type InsufficientS3BucketPolicyFault

                                                                                                                                            type InsufficientS3BucketPolicyFault struct {
                                                                                                                                            	Message *string
                                                                                                                                            }

                                                                                                                                              The cluster does not have read bucket or put object permissions on the S3 bucket specified when enabling logging.

                                                                                                                                              func (*InsufficientS3BucketPolicyFault) Error

                                                                                                                                              func (*InsufficientS3BucketPolicyFault) ErrorCode

                                                                                                                                              func (e *InsufficientS3BucketPolicyFault) ErrorCode() string

                                                                                                                                              func (*InsufficientS3BucketPolicyFault) ErrorFault

                                                                                                                                              func (*InsufficientS3BucketPolicyFault) ErrorMessage

                                                                                                                                              func (e *InsufficientS3BucketPolicyFault) ErrorMessage() string

                                                                                                                                              type InvalidClusterParameterGroupStateFault

                                                                                                                                              type InvalidClusterParameterGroupStateFault struct {
                                                                                                                                              	Message *string
                                                                                                                                              }

                                                                                                                                                The cluster parameter group action can not be completed because another task is in progress that involves the parameter group. Wait a few moments and try the operation again.

                                                                                                                                                func (*InvalidClusterParameterGroupStateFault) Error

                                                                                                                                                func (*InvalidClusterParameterGroupStateFault) ErrorCode

                                                                                                                                                func (*InvalidClusterParameterGroupStateFault) ErrorFault

                                                                                                                                                func (*InvalidClusterParameterGroupStateFault) ErrorMessage

                                                                                                                                                type InvalidClusterSecurityGroupStateFault

                                                                                                                                                type InvalidClusterSecurityGroupStateFault struct {
                                                                                                                                                	Message *string
                                                                                                                                                }

                                                                                                                                                  The state of the cluster security group is not available.

                                                                                                                                                  func (*InvalidClusterSecurityGroupStateFault) Error

                                                                                                                                                  func (*InvalidClusterSecurityGroupStateFault) ErrorCode

                                                                                                                                                  func (*InvalidClusterSecurityGroupStateFault) ErrorFault

                                                                                                                                                  func (*InvalidClusterSecurityGroupStateFault) ErrorMessage

                                                                                                                                                  type InvalidClusterSnapshotScheduleStateFault

                                                                                                                                                  type InvalidClusterSnapshotScheduleStateFault struct {
                                                                                                                                                  	Message *string
                                                                                                                                                  }

                                                                                                                                                    The cluster snapshot schedule state is not valid.

                                                                                                                                                    func (*InvalidClusterSnapshotScheduleStateFault) Error

                                                                                                                                                    func (*InvalidClusterSnapshotScheduleStateFault) ErrorCode

                                                                                                                                                    func (*InvalidClusterSnapshotScheduleStateFault) ErrorFault

                                                                                                                                                    func (*InvalidClusterSnapshotScheduleStateFault) ErrorMessage

                                                                                                                                                    type InvalidClusterSnapshotStateFault

                                                                                                                                                    type InvalidClusterSnapshotStateFault struct {
                                                                                                                                                    	Message *string
                                                                                                                                                    }

                                                                                                                                                      The specified cluster snapshot is not in the available state, or other accounts are authorized to access the snapshot.

                                                                                                                                                      func (*InvalidClusterSnapshotStateFault) Error

                                                                                                                                                      func (*InvalidClusterSnapshotStateFault) ErrorCode

                                                                                                                                                      func (*InvalidClusterSnapshotStateFault) ErrorFault

                                                                                                                                                      func (*InvalidClusterSnapshotStateFault) ErrorMessage

                                                                                                                                                      func (e *InvalidClusterSnapshotStateFault) ErrorMessage() string

                                                                                                                                                      type InvalidClusterStateFault

                                                                                                                                                      type InvalidClusterStateFault struct {
                                                                                                                                                      	Message *string
                                                                                                                                                      }

                                                                                                                                                        The specified cluster is not in the available state.

                                                                                                                                                        func (*InvalidClusterStateFault) Error

                                                                                                                                                        func (e *InvalidClusterStateFault) Error() string

                                                                                                                                                        func (*InvalidClusterStateFault) ErrorCode

                                                                                                                                                        func (e *InvalidClusterStateFault) ErrorCode() string

                                                                                                                                                        func (*InvalidClusterStateFault) ErrorFault

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

                                                                                                                                                        func (*InvalidClusterStateFault) ErrorMessage

                                                                                                                                                        func (e *InvalidClusterStateFault) ErrorMessage() string

                                                                                                                                                        type InvalidClusterSubnetGroupStateFault

                                                                                                                                                        type InvalidClusterSubnetGroupStateFault struct {
                                                                                                                                                        	Message *string
                                                                                                                                                        }

                                                                                                                                                          The cluster subnet group cannot be deleted because it is in use.

                                                                                                                                                          func (*InvalidClusterSubnetGroupStateFault) Error

                                                                                                                                                          func (*InvalidClusterSubnetGroupStateFault) ErrorCode

                                                                                                                                                          func (*InvalidClusterSubnetGroupStateFault) ErrorFault

                                                                                                                                                          func (*InvalidClusterSubnetGroupStateFault) ErrorMessage

                                                                                                                                                          func (e *InvalidClusterSubnetGroupStateFault) ErrorMessage() string

                                                                                                                                                          type InvalidClusterSubnetStateFault

                                                                                                                                                          type InvalidClusterSubnetStateFault struct {
                                                                                                                                                          	Message *string
                                                                                                                                                          }

                                                                                                                                                            The state of the subnet is invalid.

                                                                                                                                                            func (*InvalidClusterSubnetStateFault) Error

                                                                                                                                                            func (*InvalidClusterSubnetStateFault) ErrorCode

                                                                                                                                                            func (e *InvalidClusterSubnetStateFault) ErrorCode() string

                                                                                                                                                            func (*InvalidClusterSubnetStateFault) ErrorFault

                                                                                                                                                            func (*InvalidClusterSubnetStateFault) ErrorMessage

                                                                                                                                                            func (e *InvalidClusterSubnetStateFault) ErrorMessage() string

                                                                                                                                                            type InvalidClusterTrackFault

                                                                                                                                                            type InvalidClusterTrackFault struct {
                                                                                                                                                            	Message *string
                                                                                                                                                            }

                                                                                                                                                              The provided cluster track name is not valid.

                                                                                                                                                              func (*InvalidClusterTrackFault) Error

                                                                                                                                                              func (e *InvalidClusterTrackFault) Error() string

                                                                                                                                                              func (*InvalidClusterTrackFault) ErrorCode

                                                                                                                                                              func (e *InvalidClusterTrackFault) ErrorCode() string

                                                                                                                                                              func (*InvalidClusterTrackFault) ErrorFault

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

                                                                                                                                                              func (*InvalidClusterTrackFault) ErrorMessage

                                                                                                                                                              func (e *InvalidClusterTrackFault) ErrorMessage() string

                                                                                                                                                              type InvalidElasticIpFault

                                                                                                                                                              type InvalidElasticIpFault struct {
                                                                                                                                                              	Message *string
                                                                                                                                                              }

                                                                                                                                                                The Elastic IP (EIP) is invalid or cannot be found.

                                                                                                                                                                func (*InvalidElasticIpFault) Error

                                                                                                                                                                func (e *InvalidElasticIpFault) Error() string

                                                                                                                                                                func (*InvalidElasticIpFault) ErrorCode

                                                                                                                                                                func (e *InvalidElasticIpFault) ErrorCode() string

                                                                                                                                                                func (*InvalidElasticIpFault) ErrorFault

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

                                                                                                                                                                func (*InvalidElasticIpFault) ErrorMessage

                                                                                                                                                                func (e *InvalidElasticIpFault) ErrorMessage() string

                                                                                                                                                                type InvalidHsmClientCertificateStateFault

                                                                                                                                                                type InvalidHsmClientCertificateStateFault struct {
                                                                                                                                                                	Message *string
                                                                                                                                                                }

                                                                                                                                                                  The specified HSM client certificate is not in the available state, or it is still in use by one or more Amazon Redshift clusters.

                                                                                                                                                                  func (*InvalidHsmClientCertificateStateFault) Error

                                                                                                                                                                  func (*InvalidHsmClientCertificateStateFault) ErrorCode

                                                                                                                                                                  func (*InvalidHsmClientCertificateStateFault) ErrorFault

                                                                                                                                                                  func (*InvalidHsmClientCertificateStateFault) ErrorMessage

                                                                                                                                                                  type InvalidHsmConfigurationStateFault

                                                                                                                                                                  type InvalidHsmConfigurationStateFault struct {
                                                                                                                                                                  	Message *string
                                                                                                                                                                  }

                                                                                                                                                                    The specified HSM configuration is not in the available state, or it is still in use by one or more Amazon Redshift clusters.

                                                                                                                                                                    func (*InvalidHsmConfigurationStateFault) Error

                                                                                                                                                                    func (*InvalidHsmConfigurationStateFault) ErrorCode

                                                                                                                                                                    func (*InvalidHsmConfigurationStateFault) ErrorFault

                                                                                                                                                                    func (*InvalidHsmConfigurationStateFault) ErrorMessage

                                                                                                                                                                    func (e *InvalidHsmConfigurationStateFault) ErrorMessage() string

                                                                                                                                                                    type InvalidReservedNodeStateFault

                                                                                                                                                                    type InvalidReservedNodeStateFault struct {
                                                                                                                                                                    	Message *string
                                                                                                                                                                    }

                                                                                                                                                                      Indicates that the Reserved Node being exchanged is not in an active state.

                                                                                                                                                                      func (*InvalidReservedNodeStateFault) Error

                                                                                                                                                                      func (*InvalidReservedNodeStateFault) ErrorCode

                                                                                                                                                                      func (e *InvalidReservedNodeStateFault) ErrorCode() string

                                                                                                                                                                      func (*InvalidReservedNodeStateFault) ErrorFault

                                                                                                                                                                      func (*InvalidReservedNodeStateFault) ErrorMessage

                                                                                                                                                                      func (e *InvalidReservedNodeStateFault) ErrorMessage() string

                                                                                                                                                                      type InvalidRestoreFault

                                                                                                                                                                      type InvalidRestoreFault struct {
                                                                                                                                                                      	Message *string
                                                                                                                                                                      }

                                                                                                                                                                        The restore is invalid.

                                                                                                                                                                        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 InvalidRetentionPeriodFault

                                                                                                                                                                        type InvalidRetentionPeriodFault struct {
                                                                                                                                                                        	Message *string
                                                                                                                                                                        }

                                                                                                                                                                          The retention period specified is either in the past or is not a valid value. The value must be either -1 or an integer between 1 and 3,653.

                                                                                                                                                                          func (*InvalidRetentionPeriodFault) Error

                                                                                                                                                                          func (*InvalidRetentionPeriodFault) ErrorCode

                                                                                                                                                                          func (e *InvalidRetentionPeriodFault) ErrorCode() string

                                                                                                                                                                          func (*InvalidRetentionPeriodFault) ErrorFault

                                                                                                                                                                          func (*InvalidRetentionPeriodFault) ErrorMessage

                                                                                                                                                                          func (e *InvalidRetentionPeriodFault) ErrorMessage() string

                                                                                                                                                                          type InvalidS3BucketNameFault

                                                                                                                                                                          type InvalidS3BucketNameFault struct {
                                                                                                                                                                          	Message *string
                                                                                                                                                                          }

                                                                                                                                                                            The S3 bucket name is invalid. For more information about naming rules, go to Bucket Restrictions and Limitations (https://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html) in the Amazon Simple Storage Service (S3) Developer Guide.

                                                                                                                                                                            func (*InvalidS3BucketNameFault) Error

                                                                                                                                                                            func (e *InvalidS3BucketNameFault) Error() string

                                                                                                                                                                            func (*InvalidS3BucketNameFault) ErrorCode

                                                                                                                                                                            func (e *InvalidS3BucketNameFault) ErrorCode() string

                                                                                                                                                                            func (*InvalidS3BucketNameFault) ErrorFault

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

                                                                                                                                                                            func (*InvalidS3BucketNameFault) ErrorMessage

                                                                                                                                                                            func (e *InvalidS3BucketNameFault) ErrorMessage() string

                                                                                                                                                                            type InvalidS3KeyPrefixFault

                                                                                                                                                                            type InvalidS3KeyPrefixFault struct {
                                                                                                                                                                            	Message *string
                                                                                                                                                                            }

                                                                                                                                                                              The string specified for the logging S3 key prefix does not comply with the documented constraints.

                                                                                                                                                                              func (*InvalidS3KeyPrefixFault) Error

                                                                                                                                                                              func (e *InvalidS3KeyPrefixFault) Error() string

                                                                                                                                                                              func (*InvalidS3KeyPrefixFault) ErrorCode

                                                                                                                                                                              func (e *InvalidS3KeyPrefixFault) ErrorCode() string

                                                                                                                                                                              func (*InvalidS3KeyPrefixFault) ErrorFault

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

                                                                                                                                                                              func (*InvalidS3KeyPrefixFault) ErrorMessage

                                                                                                                                                                              func (e *InvalidS3KeyPrefixFault) ErrorMessage() string

                                                                                                                                                                              type InvalidScheduleFault

                                                                                                                                                                              type InvalidScheduleFault struct {
                                                                                                                                                                              	Message *string
                                                                                                                                                                              }

                                                                                                                                                                                The schedule you submitted isn't valid.

                                                                                                                                                                                func (*InvalidScheduleFault) Error

                                                                                                                                                                                func (e *InvalidScheduleFault) Error() string

                                                                                                                                                                                func (*InvalidScheduleFault) ErrorCode

                                                                                                                                                                                func (e *InvalidScheduleFault) ErrorCode() string

                                                                                                                                                                                func (*InvalidScheduleFault) ErrorFault

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

                                                                                                                                                                                func (*InvalidScheduleFault) ErrorMessage

                                                                                                                                                                                func (e *InvalidScheduleFault) ErrorMessage() string

                                                                                                                                                                                type InvalidScheduledActionFault

                                                                                                                                                                                type InvalidScheduledActionFault struct {
                                                                                                                                                                                	Message *string
                                                                                                                                                                                }

                                                                                                                                                                                  The scheduled action is not valid.

                                                                                                                                                                                  func (*InvalidScheduledActionFault) Error

                                                                                                                                                                                  func (*InvalidScheduledActionFault) ErrorCode

                                                                                                                                                                                  func (e *InvalidScheduledActionFault) ErrorCode() string

                                                                                                                                                                                  func (*InvalidScheduledActionFault) ErrorFault

                                                                                                                                                                                  func (*InvalidScheduledActionFault) ErrorMessage

                                                                                                                                                                                  func (e *InvalidScheduledActionFault) ErrorMessage() string

                                                                                                                                                                                  type InvalidSnapshotCopyGrantStateFault

                                                                                                                                                                                  type InvalidSnapshotCopyGrantStateFault struct {
                                                                                                                                                                                  	Message *string
                                                                                                                                                                                  }

                                                                                                                                                                                    The snapshot copy grant can't be deleted because it is used by one or more clusters.

                                                                                                                                                                                    func (*InvalidSnapshotCopyGrantStateFault) Error

                                                                                                                                                                                    func (*InvalidSnapshotCopyGrantStateFault) ErrorCode

                                                                                                                                                                                    func (*InvalidSnapshotCopyGrantStateFault) ErrorFault

                                                                                                                                                                                    func (*InvalidSnapshotCopyGrantStateFault) ErrorMessage

                                                                                                                                                                                    func (e *InvalidSnapshotCopyGrantStateFault) ErrorMessage() string

                                                                                                                                                                                    type InvalidSubnet

                                                                                                                                                                                    type InvalidSubnet struct {
                                                                                                                                                                                    	Message *string
                                                                                                                                                                                    }

                                                                                                                                                                                      The requested subnet is not valid, or not all of the subnets are in the same 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 InvalidSubscriptionStateFault

                                                                                                                                                                                      type InvalidSubscriptionStateFault struct {
                                                                                                                                                                                      	Message *string
                                                                                                                                                                                      }

                                                                                                                                                                                        The subscription request is invalid because it is a duplicate request. This subscription request is already in progress.

                                                                                                                                                                                        func (*InvalidSubscriptionStateFault) Error

                                                                                                                                                                                        func (*InvalidSubscriptionStateFault) ErrorCode

                                                                                                                                                                                        func (e *InvalidSubscriptionStateFault) ErrorCode() string

                                                                                                                                                                                        func (*InvalidSubscriptionStateFault) ErrorFault

                                                                                                                                                                                        func (*InvalidSubscriptionStateFault) ErrorMessage

                                                                                                                                                                                        func (e *InvalidSubscriptionStateFault) ErrorMessage() string

                                                                                                                                                                                        type InvalidTableRestoreArgumentFault

                                                                                                                                                                                        type InvalidTableRestoreArgumentFault struct {
                                                                                                                                                                                        	Message *string
                                                                                                                                                                                        }

                                                                                                                                                                                          The value specified for the sourceDatabaseName, sourceSchemaName, or sourceTableName parameter, or a combination of these, doesn't exist in the snapshot.

                                                                                                                                                                                          func (*InvalidTableRestoreArgumentFault) Error

                                                                                                                                                                                          func (*InvalidTableRestoreArgumentFault) ErrorCode

                                                                                                                                                                                          func (*InvalidTableRestoreArgumentFault) ErrorFault

                                                                                                                                                                                          func (*InvalidTableRestoreArgumentFault) ErrorMessage

                                                                                                                                                                                          func (e *InvalidTableRestoreArgumentFault) ErrorMessage() string

                                                                                                                                                                                          type InvalidTagFault

                                                                                                                                                                                          type InvalidTagFault struct {
                                                                                                                                                                                          	Message *string
                                                                                                                                                                                          }

                                                                                                                                                                                            The tag is invalid.

                                                                                                                                                                                            func (*InvalidTagFault) Error

                                                                                                                                                                                            func (e *InvalidTagFault) Error() string

                                                                                                                                                                                            func (*InvalidTagFault) ErrorCode

                                                                                                                                                                                            func (e *InvalidTagFault) ErrorCode() string

                                                                                                                                                                                            func (*InvalidTagFault) ErrorFault

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

                                                                                                                                                                                            func (*InvalidTagFault) ErrorMessage

                                                                                                                                                                                            func (e *InvalidTagFault) ErrorMessage() string

                                                                                                                                                                                            type InvalidUsageLimitFault

                                                                                                                                                                                            type InvalidUsageLimitFault struct {
                                                                                                                                                                                            	Message *string
                                                                                                                                                                                            }

                                                                                                                                                                                              The usage limit is not valid.

                                                                                                                                                                                              func (*InvalidUsageLimitFault) Error

                                                                                                                                                                                              func (e *InvalidUsageLimitFault) Error() string

                                                                                                                                                                                              func (*InvalidUsageLimitFault) ErrorCode

                                                                                                                                                                                              func (e *InvalidUsageLimitFault) ErrorCode() string

                                                                                                                                                                                              func (*InvalidUsageLimitFault) ErrorFault

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

                                                                                                                                                                                              func (*InvalidUsageLimitFault) ErrorMessage

                                                                                                                                                                                              func (e *InvalidUsageLimitFault) ErrorMessage() string

                                                                                                                                                                                              type InvalidVPCNetworkStateFault

                                                                                                                                                                                              type InvalidVPCNetworkStateFault struct {
                                                                                                                                                                                              	Message *string
                                                                                                                                                                                              }

                                                                                                                                                                                                The cluster subnet group does not cover all Availability Zones.

                                                                                                                                                                                                func (*InvalidVPCNetworkStateFault) Error

                                                                                                                                                                                                func (*InvalidVPCNetworkStateFault) ErrorCode

                                                                                                                                                                                                func (e *InvalidVPCNetworkStateFault) ErrorCode() string

                                                                                                                                                                                                func (*InvalidVPCNetworkStateFault) ErrorFault

                                                                                                                                                                                                func (*InvalidVPCNetworkStateFault) ErrorMessage

                                                                                                                                                                                                func (e *InvalidVPCNetworkStateFault) ErrorMessage() string

                                                                                                                                                                                                type LimitExceededFault

                                                                                                                                                                                                type LimitExceededFault struct {
                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                }

                                                                                                                                                                                                  The encryption key has exceeded its grant limit in AWS KMS.

                                                                                                                                                                                                  func (*LimitExceededFault) Error

                                                                                                                                                                                                  func (e *LimitExceededFault) Error() string

                                                                                                                                                                                                  func (*LimitExceededFault) ErrorCode

                                                                                                                                                                                                  func (e *LimitExceededFault) ErrorCode() string

                                                                                                                                                                                                  func (*LimitExceededFault) ErrorFault

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

                                                                                                                                                                                                  func (*LimitExceededFault) ErrorMessage

                                                                                                                                                                                                  func (e *LimitExceededFault) ErrorMessage() string

                                                                                                                                                                                                  type MaintenanceTrack

                                                                                                                                                                                                  type MaintenanceTrack struct {
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The version number for the cluster release.
                                                                                                                                                                                                  	DatabaseVersion *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// The name of the maintenance track. Possible values are current and trailing.
                                                                                                                                                                                                  	MaintenanceTrackName *string
                                                                                                                                                                                                  
                                                                                                                                                                                                  	// An array of UpdateTarget objects to update with the maintenance track.
                                                                                                                                                                                                  	UpdateTargets []UpdateTarget
                                                                                                                                                                                                  }

                                                                                                                                                                                                    Defines a maintenance track that determines which Amazon Redshift version to apply during a maintenance window. If the value for MaintenanceTrack is current, the cluster is updated to the most recently certified maintenance release. If the value is trailing, the cluster is updated to the previously certified maintenance release.

                                                                                                                                                                                                    type Mode

                                                                                                                                                                                                    type Mode string
                                                                                                                                                                                                    const (
                                                                                                                                                                                                    	ModeStandard        Mode = "standard"
                                                                                                                                                                                                    	ModeHighPerformance Mode = "high-performance"
                                                                                                                                                                                                    )

                                                                                                                                                                                                      Enum values for Mode

                                                                                                                                                                                                      func (Mode) Values

                                                                                                                                                                                                      func (Mode) Values() []Mode

                                                                                                                                                                                                        Values returns all known values for Mode. 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 NodeConfigurationOption

                                                                                                                                                                                                        type NodeConfigurationOption struct {
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The estimated disk utilizaton percentage.
                                                                                                                                                                                                        	EstimatedDiskUtilizationPercent *float64
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The category of the node configuration recommendation.
                                                                                                                                                                                                        	Mode Mode
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The node type, such as, "ds2.8xlarge".
                                                                                                                                                                                                        	NodeType *string
                                                                                                                                                                                                        
                                                                                                                                                                                                        	// The number of nodes.
                                                                                                                                                                                                        	NumberOfNodes int32
                                                                                                                                                                                                        }

                                                                                                                                                                                                          A list of node configurations.

                                                                                                                                                                                                          type NodeConfigurationOptionsFilter

                                                                                                                                                                                                          type NodeConfigurationOptionsFilter struct {
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The name of the element to filter.
                                                                                                                                                                                                          	Name NodeConfigurationOptionsFilterName
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The filter operator. If filter Name is NodeType only the 'in' operator is
                                                                                                                                                                                                          	// supported. Provide one value to evaluate for 'eq', 'lt', 'le', 'gt', and 'ge'.
                                                                                                                                                                                                          	// Provide two values to evaluate for 'between'. Provide a list of values for 'in'.
                                                                                                                                                                                                          	Operator OperatorType
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// List of values. Compare Name using Operator to Values. If filter Name is
                                                                                                                                                                                                          	// NumberOfNodes, then values can range from 0 to 200. If filter Name is
                                                                                                                                                                                                          	// EstimatedDiskUtilizationPercent, then values can range from 0 to 100. For
                                                                                                                                                                                                          	// example, filter NumberOfNodes (name) GT (operator) 3 (values).
                                                                                                                                                                                                          	Values []string
                                                                                                                                                                                                          }

                                                                                                                                                                                                            A set of elements to filter the returned node configurations.

                                                                                                                                                                                                            type NodeConfigurationOptionsFilterName

                                                                                                                                                                                                            type NodeConfigurationOptionsFilterName string
                                                                                                                                                                                                            const (
                                                                                                                                                                                                            	NodeConfigurationOptionsFilterNameNodeType                        NodeConfigurationOptionsFilterName = "NodeType"
                                                                                                                                                                                                            	NodeConfigurationOptionsFilterNameNumNodes                        NodeConfigurationOptionsFilterName = "NumberOfNodes"
                                                                                                                                                                                                            	NodeConfigurationOptionsFilterNameEstimatedDiskUtilizationPercent NodeConfigurationOptionsFilterName = "EstimatedDiskUtilizationPercent"
                                                                                                                                                                                                            	NodeConfigurationOptionsFilterNameMode                            NodeConfigurationOptionsFilterName = "Mode"
                                                                                                                                                                                                            )

                                                                                                                                                                                                              Enum values for NodeConfigurationOptionsFilterName

                                                                                                                                                                                                              func (NodeConfigurationOptionsFilterName) Values

                                                                                                                                                                                                                Values returns all known values for NodeConfigurationOptionsFilterName. 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 NumberOfNodesPerClusterLimitExceededFault

                                                                                                                                                                                                                type NumberOfNodesPerClusterLimitExceededFault struct {
                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  The operation would exceed the number of nodes allowed for a cluster.

                                                                                                                                                                                                                  func (*NumberOfNodesPerClusterLimitExceededFault) Error

                                                                                                                                                                                                                  func (*NumberOfNodesPerClusterLimitExceededFault) ErrorCode

                                                                                                                                                                                                                  func (*NumberOfNodesPerClusterLimitExceededFault) ErrorFault

                                                                                                                                                                                                                  func (*NumberOfNodesPerClusterLimitExceededFault) ErrorMessage

                                                                                                                                                                                                                  type NumberOfNodesQuotaExceededFault

                                                                                                                                                                                                                  type NumberOfNodesQuotaExceededFault struct {
                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    The operation would exceed the number of nodes allotted to the account. For information about increasing your quota, go to Limits in Amazon Redshift (https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) in the Amazon Redshift Cluster Management Guide.

                                                                                                                                                                                                                    func (*NumberOfNodesQuotaExceededFault) Error

                                                                                                                                                                                                                    func (*NumberOfNodesQuotaExceededFault) ErrorCode

                                                                                                                                                                                                                    func (e *NumberOfNodesQuotaExceededFault) ErrorCode() string

                                                                                                                                                                                                                    func (*NumberOfNodesQuotaExceededFault) ErrorFault

                                                                                                                                                                                                                    func (*NumberOfNodesQuotaExceededFault) ErrorMessage

                                                                                                                                                                                                                    func (e *NumberOfNodesQuotaExceededFault) ErrorMessage() string

                                                                                                                                                                                                                    type OperatorType

                                                                                                                                                                                                                    type OperatorType string
                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                    	OperatorTypeEq      OperatorType = "eq"
                                                                                                                                                                                                                    	OperatorTypeLt      OperatorType = "lt"
                                                                                                                                                                                                                    	OperatorTypeGt      OperatorType = "gt"
                                                                                                                                                                                                                    	OperatorTypeLe      OperatorType = "le"
                                                                                                                                                                                                                    	OperatorTypeGe      OperatorType = "ge"
                                                                                                                                                                                                                    	OperatorTypeIn      OperatorType = "in"
                                                                                                                                                                                                                    	OperatorTypeBetween OperatorType = "between"
                                                                                                                                                                                                                    )

                                                                                                                                                                                                                      Enum values for OperatorType

                                                                                                                                                                                                                      func (OperatorType) Values

                                                                                                                                                                                                                      func (OperatorType) Values() []OperatorType

                                                                                                                                                                                                                        Values returns all known values for OperatorType. 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 OrderableClusterOption

                                                                                                                                                                                                                        type OrderableClusterOption struct {
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// A list of availability zones for the orderable cluster.
                                                                                                                                                                                                                        	AvailabilityZones []AvailabilityZone
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// The cluster type, for example multi-node.
                                                                                                                                                                                                                        	ClusterType *string
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// The version of the orderable cluster.
                                                                                                                                                                                                                        	ClusterVersion *string
                                                                                                                                                                                                                        
                                                                                                                                                                                                                        	// The node type for the orderable cluster.
                                                                                                                                                                                                                        	NodeType *string
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          Describes an orderable cluster option.

                                                                                                                                                                                                                          type Parameter

                                                                                                                                                                                                                          type Parameter struct {
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The valid range of values for the parameter.
                                                                                                                                                                                                                          	AllowedValues *string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// Specifies how to apply the WLM configuration parameter. Some properties can be
                                                                                                                                                                                                                          	// applied dynamically, while other properties require that any associated clusters
                                                                                                                                                                                                                          	// be rebooted for the configuration changes to be applied. For more information
                                                                                                                                                                                                                          	// about parameters and parameter groups, go to Amazon Redshift Parameter Groups
                                                                                                                                                                                                                          	// (https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-parameter-groups.html)
                                                                                                                                                                                                                          	// in the Amazon Redshift Cluster Management Guide.
                                                                                                                                                                                                                          	ApplyType ParameterApplyType
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The data type of the parameter.
                                                                                                                                                                                                                          	DataType *string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// A description of the parameter.
                                                                                                                                                                                                                          	Description *string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// If true, 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
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The name of the parameter.
                                                                                                                                                                                                                          	ParameterName *string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The value of the parameter.
                                                                                                                                                                                                                          	ParameterValue *string
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// The source of the parameter value, such as "engine-default" or "user".
                                                                                                                                                                                                                          	Source *string
                                                                                                                                                                                                                          }

                                                                                                                                                                                                                            Describes a parameter in a cluster parameter group.

                                                                                                                                                                                                                            type ParameterApplyType

                                                                                                                                                                                                                            type ParameterApplyType string
                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                            	ParameterApplyTypeStatic  ParameterApplyType = "static"
                                                                                                                                                                                                                            	ParameterApplyTypeDynamic ParameterApplyType = "dynamic"
                                                                                                                                                                                                                            )

                                                                                                                                                                                                                              Enum values for ParameterApplyType

                                                                                                                                                                                                                              func (ParameterApplyType) Values

                                                                                                                                                                                                                                Values returns all known values for ParameterApplyType. 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 PauseClusterMessage

                                                                                                                                                                                                                                type PauseClusterMessage struct {
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                	// The identifier of the cluster to be paused.
                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                	ClusterIdentifier *string
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  Describes a pause cluster operation. For example, a scheduled action to run the PauseCluster API operation.

                                                                                                                                                                                                                                  type PendingModifiedValues

                                                                                                                                                                                                                                  type PendingModifiedValues struct {
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The pending or in-progress change of the automated snapshot retention period.
                                                                                                                                                                                                                                  	AutomatedSnapshotRetentionPeriod *int32
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The pending or in-progress change of the new identifier for the cluster.
                                                                                                                                                                                                                                  	ClusterIdentifier *string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The pending or in-progress change of the cluster type.
                                                                                                                                                                                                                                  	ClusterType *string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The pending or in-progress change of the service version.
                                                                                                                                                                                                                                  	ClusterVersion *string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The encryption type for a cluster. Possible values are: KMS and None.
                                                                                                                                                                                                                                  	EncryptionType *string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// An option that specifies whether to create the cluster with enhanced VPC routing
                                                                                                                                                                                                                                  	// enabled. To create a cluster that uses enhanced VPC routing, the cluster must be
                                                                                                                                                                                                                                  	// in a VPC. For more information, see Enhanced VPC Routing
                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html) in
                                                                                                                                                                                                                                  	// the Amazon Redshift Cluster Management Guide. If this option is true, enhanced
                                                                                                                                                                                                                                  	// VPC routing is enabled. Default: false
                                                                                                                                                                                                                                  	EnhancedVpcRouting *bool
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The name of the maintenance track that the cluster will change to during the
                                                                                                                                                                                                                                  	// next maintenance window.
                                                                                                                                                                                                                                  	MaintenanceTrackName *string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The pending or in-progress change of the master user password for the cluster.
                                                                                                                                                                                                                                  	MasterUserPassword *string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The pending or in-progress change of the cluster's node type.
                                                                                                                                                                                                                                  	NodeType *string
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The pending or in-progress change of the number of nodes in the cluster.
                                                                                                                                                                                                                                  	NumberOfNodes *int32
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  	// The pending or in-progress change of the ability to connect to the cluster from
                                                                                                                                                                                                                                  	// the public network.
                                                                                                                                                                                                                                  	PubliclyAccessible *bool
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    Describes cluster attributes that are in a pending state. A change to one or more the attributes was requested and is in progress or will be applied.

                                                                                                                                                                                                                                    type RecurringCharge

                                                                                                                                                                                                                                    type RecurringCharge struct {
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The amount charged per the period of time specified by the recurring charge
                                                                                                                                                                                                                                    	// frequency.
                                                                                                                                                                                                                                    	RecurringChargeAmount float64
                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                    	// The frequency at which the recurring charge amount is applied.
                                                                                                                                                                                                                                    	RecurringChargeFrequency *string
                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                      Describes a recurring charge.

                                                                                                                                                                                                                                      type ReservedNode

                                                                                                                                                                                                                                      type ReservedNode struct {
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The currency code for the reserved cluster.
                                                                                                                                                                                                                                      	CurrencyCode *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The duration of the node reservation in seconds.
                                                                                                                                                                                                                                      	Duration int32
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The fixed cost Amazon Redshift charges you for this reserved node.
                                                                                                                                                                                                                                      	FixedPrice float64
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The number of reserved compute nodes.
                                                                                                                                                                                                                                      	NodeCount int32
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The node type of the reserved node.
                                                                                                                                                                                                                                      	NodeType *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The anticipated utilization of the reserved node, as defined in the reserved
                                                                                                                                                                                                                                      	// node offering.
                                                                                                                                                                                                                                      	OfferingType *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The recurring charges for the reserved node.
                                                                                                                                                                                                                                      	RecurringCharges []RecurringCharge
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The unique identifier for the reservation.
                                                                                                                                                                                                                                      	ReservedNodeId *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The identifier for the reserved node offering.
                                                                                                                                                                                                                                      	ReservedNodeOfferingId *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                      	ReservedNodeOfferingType ReservedNodeOfferingType
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The time the reservation started. You purchase a reserved node offering for a
                                                                                                                                                                                                                                      	// duration. This is the start time of that duration.
                                                                                                                                                                                                                                      	StartTime *time.Time
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The state of the reserved compute node. Possible Values:
                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                      	// * pending-payment-This
                                                                                                                                                                                                                                      	// reserved node has recently been purchased, and the sale has been approved, but
                                                                                                                                                                                                                                      	// payment has not yet been confirmed.
                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                      	// * active-This reserved node is owned by the
                                                                                                                                                                                                                                      	// caller and is available for use.
                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                      	// * payment-failed-Payment failed for the
                                                                                                                                                                                                                                      	// purchase attempt.
                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                      	// * retired-The reserved node is no longer available.
                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                      	// *
                                                                                                                                                                                                                                      	// exchanging-The owner is exchanging the reserved node for another reserved node.
                                                                                                                                                                                                                                      	State *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The hourly rate Amazon Redshift charges you for this reserved node.
                                                                                                                                                                                                                                      	UsagePrice float64
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        Describes a reserved node. You can call the DescribeReservedNodeOfferings API to obtain the available reserved node offerings.

                                                                                                                                                                                                                                        type ReservedNodeAlreadyExistsFault

                                                                                                                                                                                                                                        type ReservedNodeAlreadyExistsFault struct {
                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          User already has a reservation with the given identifier.

                                                                                                                                                                                                                                          func (*ReservedNodeAlreadyExistsFault) Error

                                                                                                                                                                                                                                          func (*ReservedNodeAlreadyExistsFault) ErrorCode

                                                                                                                                                                                                                                          func (e *ReservedNodeAlreadyExistsFault) ErrorCode() string

                                                                                                                                                                                                                                          func (*ReservedNodeAlreadyExistsFault) ErrorFault

                                                                                                                                                                                                                                          func (*ReservedNodeAlreadyExistsFault) ErrorMessage

                                                                                                                                                                                                                                          func (e *ReservedNodeAlreadyExistsFault) ErrorMessage() string

                                                                                                                                                                                                                                          type ReservedNodeAlreadyMigratedFault

                                                                                                                                                                                                                                          type ReservedNodeAlreadyMigratedFault struct {
                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                            Indicates that the reserved node has already been exchanged.

                                                                                                                                                                                                                                            func (*ReservedNodeAlreadyMigratedFault) Error

                                                                                                                                                                                                                                            func (*ReservedNodeAlreadyMigratedFault) ErrorCode

                                                                                                                                                                                                                                            func (*ReservedNodeAlreadyMigratedFault) ErrorFault

                                                                                                                                                                                                                                            func (*ReservedNodeAlreadyMigratedFault) ErrorMessage

                                                                                                                                                                                                                                            func (e *ReservedNodeAlreadyMigratedFault) ErrorMessage() string

                                                                                                                                                                                                                                            type ReservedNodeNotFoundFault

                                                                                                                                                                                                                                            type ReservedNodeNotFoundFault struct {
                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                              The specified reserved compute node not found.

                                                                                                                                                                                                                                              func (*ReservedNodeNotFoundFault) Error

                                                                                                                                                                                                                                              func (e *ReservedNodeNotFoundFault) Error() string

                                                                                                                                                                                                                                              func (*ReservedNodeNotFoundFault) ErrorCode

                                                                                                                                                                                                                                              func (e *ReservedNodeNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                              func (*ReservedNodeNotFoundFault) ErrorFault

                                                                                                                                                                                                                                              func (*ReservedNodeNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                              func (e *ReservedNodeNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                              type ReservedNodeOffering

                                                                                                                                                                                                                                              type ReservedNodeOffering struct {
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The currency code for the compute nodes offering.
                                                                                                                                                                                                                                              	CurrencyCode *string
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The duration, in seconds, for which the offering will reserve the node.
                                                                                                                                                                                                                                              	Duration int32
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The upfront fixed charge you will pay to purchase the specific reserved node
                                                                                                                                                                                                                                              	// offering.
                                                                                                                                                                                                                                              	FixedPrice float64
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The node type offered by the reserved node offering.
                                                                                                                                                                                                                                              	NodeType *string
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The anticipated utilization of the reserved node, as defined in the reserved
                                                                                                                                                                                                                                              	// node offering.
                                                                                                                                                                                                                                              	OfferingType *string
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The charge to your account regardless of whether you are creating any clusters
                                                                                                                                                                                                                                              	// using the node offering. Recurring charges are only in effect for
                                                                                                                                                                                                                                              	// heavy-utilization reserved nodes.
                                                                                                                                                                                                                                              	RecurringCharges []RecurringCharge
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The offering identifier.
                                                                                                                                                                                                                                              	ReservedNodeOfferingId *string
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                              	ReservedNodeOfferingType ReservedNodeOfferingType
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              	// The rate you are charged for each hour the cluster that is using the offering is
                                                                                                                                                                                                                                              	// running.
                                                                                                                                                                                                                                              	UsagePrice float64
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                Describes a reserved node offering.

                                                                                                                                                                                                                                                type ReservedNodeOfferingNotFoundFault

                                                                                                                                                                                                                                                type ReservedNodeOfferingNotFoundFault struct {
                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                  Specified offering does not exist.

                                                                                                                                                                                                                                                  func (*ReservedNodeOfferingNotFoundFault) Error

                                                                                                                                                                                                                                                  func (*ReservedNodeOfferingNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                  func (*ReservedNodeOfferingNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                  func (*ReservedNodeOfferingNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                  func (e *ReservedNodeOfferingNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                  type ReservedNodeOfferingType

                                                                                                                                                                                                                                                  type ReservedNodeOfferingType string
                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                  	ReservedNodeOfferingTypeRegular    ReservedNodeOfferingType = "Regular"
                                                                                                                                                                                                                                                  	ReservedNodeOfferingTypeUpgradable ReservedNodeOfferingType = "Upgradable"
                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                    Enum values for ReservedNodeOfferingType

                                                                                                                                                                                                                                                    func (ReservedNodeOfferingType) Values

                                                                                                                                                                                                                                                      Values returns all known values for ReservedNodeOfferingType. 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 ReservedNodeQuotaExceededFault

                                                                                                                                                                                                                                                      type ReservedNodeQuotaExceededFault struct {
                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                        Request would exceed the user's compute node quota. For information about increasing your quota, go to Limits in Amazon Redshift (https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) in the Amazon Redshift Cluster Management Guide.

                                                                                                                                                                                                                                                        func (*ReservedNodeQuotaExceededFault) Error

                                                                                                                                                                                                                                                        func (*ReservedNodeQuotaExceededFault) ErrorCode

                                                                                                                                                                                                                                                        func (e *ReservedNodeQuotaExceededFault) ErrorCode() string

                                                                                                                                                                                                                                                        func (*ReservedNodeQuotaExceededFault) ErrorFault

                                                                                                                                                                                                                                                        func (*ReservedNodeQuotaExceededFault) ErrorMessage

                                                                                                                                                                                                                                                        func (e *ReservedNodeQuotaExceededFault) ErrorMessage() string

                                                                                                                                                                                                                                                        type ResizeClusterMessage

                                                                                                                                                                                                                                                        type ResizeClusterMessage struct {
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The unique identifier for the cluster to resize.
                                                                                                                                                                                                                                                        	//
                                                                                                                                                                                                                                                        	// This member is required.
                                                                                                                                                                                                                                                        	ClusterIdentifier *string
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// A boolean value indicating whether the resize operation is using the classic
                                                                                                                                                                                                                                                        	// resize process. If you don't provide this parameter or set the value to false,
                                                                                                                                                                                                                                                        	// the resize type is elastic.
                                                                                                                                                                                                                                                        	Classic *bool
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The new cluster type for the specified cluster.
                                                                                                                                                                                                                                                        	ClusterType *string
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The new node type for the nodes you are adding. If not specified, the cluster's
                                                                                                                                                                                                                                                        	// current node type is used.
                                                                                                                                                                                                                                                        	NodeType *string
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The new number of nodes for the cluster. If not specified, the cluster's current
                                                                                                                                                                                                                                                        	// number of nodes is used.
                                                                                                                                                                                                                                                        	NumberOfNodes *int32
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                          Describes a resize cluster operation. For example, a scheduled action to run the ResizeCluster API operation.

                                                                                                                                                                                                                                                          type ResizeInfo

                                                                                                                                                                                                                                                          type ResizeInfo struct {
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// A boolean value indicating if the resize operation can be cancelled.
                                                                                                                                                                                                                                                          	AllowCancelResize bool
                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                          	// Returns the value ClassicResize.
                                                                                                                                                                                                                                                          	ResizeType *string
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            Describes a resize operation.

                                                                                                                                                                                                                                                            type ResizeNotFoundFault

                                                                                                                                                                                                                                                            type ResizeNotFoundFault struct {
                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                              A resize operation for the specified cluster is not found.

                                                                                                                                                                                                                                                              func (*ResizeNotFoundFault) Error

                                                                                                                                                                                                                                                              func (e *ResizeNotFoundFault) Error() string

                                                                                                                                                                                                                                                              func (*ResizeNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                              func (e *ResizeNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                                              func (*ResizeNotFoundFault) ErrorFault

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

                                                                                                                                                                                                                                                              func (*ResizeNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                              func (e *ResizeNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                              type ResourceNotFoundFault

                                                                                                                                                                                                                                                              type ResourceNotFoundFault struct {
                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                The resource could not be 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 RestoreStatus

                                                                                                                                                                                                                                                                type RestoreStatus struct {
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The number of megabytes per second being transferred from the backup storage.
                                                                                                                                                                                                                                                                	// Returns the average rate for a completed backup. This field is only updated when
                                                                                                                                                                                                                                                                	// you restore to DC2 and DS2 node types.
                                                                                                                                                                                                                                                                	CurrentRestoreRateInMegaBytesPerSecond float64
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The amount of time an in-progress restore has been running, or the amount of
                                                                                                                                                                                                                                                                	// time it took a completed restore to finish. This field is only updated when you
                                                                                                                                                                                                                                                                	// restore to DC2 and DS2 node types.
                                                                                                                                                                                                                                                                	ElapsedTimeInSeconds int64
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The estimate of the time remaining before the restore will complete. Returns 0
                                                                                                                                                                                                                                                                	// for a completed restore. This field is only updated when you restore to DC2 and
                                                                                                                                                                                                                                                                	// DS2 node types.
                                                                                                                                                                                                                                                                	EstimatedTimeToCompletionInSeconds int64
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The number of megabytes that have been transferred from snapshot storage. This
                                                                                                                                                                                                                                                                	// field is only updated when you restore to DC2 and DS2 node types.
                                                                                                                                                                                                                                                                	ProgressInMegaBytes int64
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The size of the set of snapshot data used to restore the cluster. This field is
                                                                                                                                                                                                                                                                	// only updated when you restore to DC2 and DS2 node types.
                                                                                                                                                                                                                                                                	SnapshotSizeInMegaBytes int64
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The status of the restore action. Returns starting, restoring, completed, or
                                                                                                                                                                                                                                                                	// failed.
                                                                                                                                                                                                                                                                	Status *string
                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                  Describes the status of a cluster restore action. Returns null if the cluster was not created by restoring a snapshot.

                                                                                                                                                                                                                                                                  type ResumeClusterMessage

                                                                                                                                                                                                                                                                  type ResumeClusterMessage struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The identifier of the cluster to be resumed.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	ClusterIdentifier *string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                    Describes a resume cluster operation. For example, a scheduled action to run the ResumeCluster API operation.

                                                                                                                                                                                                                                                                    type RevisionTarget

                                                                                                                                                                                                                                                                    type RevisionTarget struct {
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// A unique string that identifies the version to update the cluster to. You can
                                                                                                                                                                                                                                                                    	// use this value in ModifyClusterDbRevision.
                                                                                                                                                                                                                                                                    	DatabaseRevision *string
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// The date on which the database revision was released.
                                                                                                                                                                                                                                                                    	DatabaseRevisionReleaseDate *time.Time
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// A string that describes the changes and features that will be applied to the
                                                                                                                                                                                                                                                                    	// cluster when it is updated to the corresponding ClusterDbRevision.
                                                                                                                                                                                                                                                                    	Description *string
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                      Describes a RevisionTarget.

                                                                                                                                                                                                                                                                      type SNSInvalidTopicFault

                                                                                                                                                                                                                                                                      type SNSInvalidTopicFault struct {
                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                      }

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

                                                                                                                                                                                                                                                                        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 specified Amazon SNS topic.

                                                                                                                                                                                                                                                                          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
                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                            An Amazon SNS topic with the specified Amazon Resource Name (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 ScheduleDefinitionTypeUnsupportedFault

                                                                                                                                                                                                                                                                            type ScheduleDefinitionTypeUnsupportedFault struct {
                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                              The definition you submitted is not supported.

                                                                                                                                                                                                                                                                              func (*ScheduleDefinitionTypeUnsupportedFault) Error

                                                                                                                                                                                                                                                                              func (*ScheduleDefinitionTypeUnsupportedFault) ErrorCode

                                                                                                                                                                                                                                                                              func (*ScheduleDefinitionTypeUnsupportedFault) ErrorFault

                                                                                                                                                                                                                                                                              func (*ScheduleDefinitionTypeUnsupportedFault) ErrorMessage

                                                                                                                                                                                                                                                                              type ScheduleState

                                                                                                                                                                                                                                                                              type ScheduleState string
                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                              	ScheduleStateModifying ScheduleState = "MODIFYING"
                                                                                                                                                                                                                                                                              	ScheduleStateActive    ScheduleState = "ACTIVE"
                                                                                                                                                                                                                                                                              	ScheduleStateFailed    ScheduleState = "FAILED"
                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                Enum values for ScheduleState

                                                                                                                                                                                                                                                                                func (ScheduleState) Values

                                                                                                                                                                                                                                                                                func (ScheduleState) Values() []ScheduleState

                                                                                                                                                                                                                                                                                  Values returns all known values for ScheduleState. 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 ScheduledAction

                                                                                                                                                                                                                                                                                  type ScheduledAction struct {
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The end time in UTC when the schedule is no longer active. After this time, the
                                                                                                                                                                                                                                                                                  	// scheduled action does not trigger.
                                                                                                                                                                                                                                                                                  	EndTime *time.Time
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The IAM role to assume to run the scheduled action. This IAM role must have
                                                                                                                                                                                                                                                                                  	// permission to run the Amazon Redshift API operation in the scheduled action.
                                                                                                                                                                                                                                                                                  	// This IAM role must allow the Amazon Redshift scheduler (Principal
                                                                                                                                                                                                                                                                                  	// scheduler.redshift.amazonaws.com) to assume permissions on your behalf. For more
                                                                                                                                                                                                                                                                                  	// information about the IAM role to use with the Amazon Redshift scheduler, see
                                                                                                                                                                                                                                                                                  	// Using Identity-Based Policies for Amazon Redshift
                                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html)
                                                                                                                                                                                                                                                                                  	// in the Amazon Redshift Cluster Management Guide.
                                                                                                                                                                                                                                                                                  	IamRole *string
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// List of times when the scheduled action will run.
                                                                                                                                                                                                                                                                                  	NextInvocations []time.Time
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The schedule for a one-time (at format) or recurring (cron format) scheduled
                                                                                                                                                                                                                                                                                  	// action. Schedule invocations must be separated by at least one hour. Format of
                                                                                                                                                                                                                                                                                  	// at expressions is "at(yyyy-mm-ddThh:mm:ss)". For example,
                                                                                                                                                                                                                                                                                  	// "at(2016-03-04T17:27:00)". Format of cron expressions is "cron(Minutes Hours
                                                                                                                                                                                                                                                                                  	// Day-of-month Month Day-of-week Year)". For example, "cron(0 10 ? * MON *)". For
                                                                                                                                                                                                                                                                                  	// more information, see Cron Expressions
                                                                                                                                                                                                                                                                                  	// (https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html#CronExpressions)
                                                                                                                                                                                                                                                                                  	// in the Amazon CloudWatch Events User Guide.
                                                                                                                                                                                                                                                                                  	Schedule *string
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The description of the scheduled action.
                                                                                                                                                                                                                                                                                  	ScheduledActionDescription *string
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The name of the scheduled action.
                                                                                                                                                                                                                                                                                  	ScheduledActionName *string
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The start time in UTC when the schedule is active. Before this time, the
                                                                                                                                                                                                                                                                                  	// scheduled action does not trigger.
                                                                                                                                                                                                                                                                                  	StartTime *time.Time
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The state of the scheduled action. For example, DISABLED.
                                                                                                                                                                                                                                                                                  	State ScheduledActionState
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// A JSON format string of the Amazon Redshift API operation with input parameters.
                                                                                                                                                                                                                                                                                  	// "{\"ResizeCluster\":{\"NodeType\":\"ds2.8xlarge\",\"ClusterIdentifier\":\"my-test-cluster\",\"NumberOfNodes\":3}}".
                                                                                                                                                                                                                                                                                  	TargetAction *ScheduledActionType
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    Describes a scheduled action. You can use a scheduled action to trigger some Amazon Redshift API operations on a schedule. For information about which API operations can be scheduled, see ScheduledActionType.

                                                                                                                                                                                                                                                                                    type ScheduledActionAlreadyExistsFault

                                                                                                                                                                                                                                                                                    type ScheduledActionAlreadyExistsFault struct {
                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                      The scheduled action already exists.

                                                                                                                                                                                                                                                                                      func (*ScheduledActionAlreadyExistsFault) Error

                                                                                                                                                                                                                                                                                      func (*ScheduledActionAlreadyExistsFault) ErrorCode

                                                                                                                                                                                                                                                                                      func (*ScheduledActionAlreadyExistsFault) ErrorFault

                                                                                                                                                                                                                                                                                      func (*ScheduledActionAlreadyExistsFault) ErrorMessage

                                                                                                                                                                                                                                                                                      func (e *ScheduledActionAlreadyExistsFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                      type ScheduledActionFilter

                                                                                                                                                                                                                                                                                      type ScheduledActionFilter struct {
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// The type of element to filter.
                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                      	Name ScheduledActionFilterName
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// List of values. Compare if the value (of type defined by Name) equals an item in
                                                                                                                                                                                                                                                                                      	// the list of scheduled actions.
                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                                                                      	Values []string
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        A set of elements to filter the returned scheduled actions.

                                                                                                                                                                                                                                                                                        type ScheduledActionFilterName

                                                                                                                                                                                                                                                                                        type ScheduledActionFilterName string
                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                        	ScheduledActionFilterNameClusterIdentifier ScheduledActionFilterName = "cluster-identifier"
                                                                                                                                                                                                                                                                                        	ScheduledActionFilterNameIamRole           ScheduledActionFilterName = "iam-role"
                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                          Enum values for ScheduledActionFilterName

                                                                                                                                                                                                                                                                                          func (ScheduledActionFilterName) Values

                                                                                                                                                                                                                                                                                            Values returns all known values for ScheduledActionFilterName. 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 ScheduledActionNotFoundFault

                                                                                                                                                                                                                                                                                            type ScheduledActionNotFoundFault struct {
                                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                              The scheduled action cannot be found.

                                                                                                                                                                                                                                                                                              func (*ScheduledActionNotFoundFault) Error

                                                                                                                                                                                                                                                                                              func (*ScheduledActionNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                                                              func (e *ScheduledActionNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                                                                              func (*ScheduledActionNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                                                              func (*ScheduledActionNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                                                              func (e *ScheduledActionNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                              type ScheduledActionQuotaExceededFault

                                                                                                                                                                                                                                                                                              type ScheduledActionQuotaExceededFault struct {
                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                The quota for scheduled actions exceeded.

                                                                                                                                                                                                                                                                                                func (*ScheduledActionQuotaExceededFault) Error

                                                                                                                                                                                                                                                                                                func (*ScheduledActionQuotaExceededFault) ErrorCode

                                                                                                                                                                                                                                                                                                func (*ScheduledActionQuotaExceededFault) ErrorFault

                                                                                                                                                                                                                                                                                                func (*ScheduledActionQuotaExceededFault) ErrorMessage

                                                                                                                                                                                                                                                                                                func (e *ScheduledActionQuotaExceededFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                type ScheduledActionState

                                                                                                                                                                                                                                                                                                type ScheduledActionState string
                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                	ScheduledActionStateActive   ScheduledActionState = "ACTIVE"
                                                                                                                                                                                                                                                                                                	ScheduledActionStateDisabled ScheduledActionState = "DISABLED"
                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                  Enum values for ScheduledActionState

                                                                                                                                                                                                                                                                                                  func (ScheduledActionState) Values

                                                                                                                                                                                                                                                                                                    Values returns all known values for ScheduledActionState. 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 ScheduledActionType

                                                                                                                                                                                                                                                                                                    type ScheduledActionType struct {
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// An action that runs a PauseCluster API operation.
                                                                                                                                                                                                                                                                                                    	PauseCluster *PauseClusterMessage
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// An action that runs a ResizeCluster API operation.
                                                                                                                                                                                                                                                                                                    	ResizeCluster *ResizeClusterMessage
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    	// An action that runs a ResumeCluster API operation.
                                                                                                                                                                                                                                                                                                    	ResumeCluster *ResumeClusterMessage
                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                      The action type that specifies an Amazon Redshift API operation that is supported by the Amazon Redshift scheduler.

                                                                                                                                                                                                                                                                                                      type ScheduledActionTypeUnsupportedFault

                                                                                                                                                                                                                                                                                                      type ScheduledActionTypeUnsupportedFault struct {
                                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                        The action type specified for a scheduled action is not supported.

                                                                                                                                                                                                                                                                                                        func (*ScheduledActionTypeUnsupportedFault) Error

                                                                                                                                                                                                                                                                                                        func (*ScheduledActionTypeUnsupportedFault) ErrorCode

                                                                                                                                                                                                                                                                                                        func (*ScheduledActionTypeUnsupportedFault) ErrorFault

                                                                                                                                                                                                                                                                                                        func (*ScheduledActionTypeUnsupportedFault) ErrorMessage

                                                                                                                                                                                                                                                                                                        func (e *ScheduledActionTypeUnsupportedFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                        type ScheduledActionTypeValues

                                                                                                                                                                                                                                                                                                        type ScheduledActionTypeValues string
                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                        	ScheduledActionTypeValuesResizeCluster ScheduledActionTypeValues = "ResizeCluster"
                                                                                                                                                                                                                                                                                                        	ScheduledActionTypeValuesPauseCluster  ScheduledActionTypeValues = "PauseCluster"
                                                                                                                                                                                                                                                                                                        	ScheduledActionTypeValuesResumeCluster ScheduledActionTypeValues = "ResumeCluster"
                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                          Enum values for ScheduledActionTypeValues

                                                                                                                                                                                                                                                                                                          func (ScheduledActionTypeValues) Values

                                                                                                                                                                                                                                                                                                            Values returns all known values for ScheduledActionTypeValues. 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 Snapshot

                                                                                                                                                                                                                                                                                                            type Snapshot struct {
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// A list of the AWS customer accounts authorized to restore the snapshot. Returns
                                                                                                                                                                                                                                                                                                            	// null if no accounts are authorized. Visible only to the snapshot owner.
                                                                                                                                                                                                                                                                                                            	AccountsWithRestoreAccess []AccountWithRestoreAccess
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The size of the incremental backup.
                                                                                                                                                                                                                                                                                                            	ActualIncrementalBackupSizeInMegaBytes float64
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The Availability Zone in which the cluster was created.
                                                                                                                                                                                                                                                                                                            	AvailabilityZone *string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The number of megabytes that have been transferred to the snapshot backup.
                                                                                                                                                                                                                                                                                                            	BackupProgressInMegaBytes float64
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The time (UTC) when the cluster was originally created.
                                                                                                                                                                                                                                                                                                            	ClusterCreateTime *time.Time
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The identifier of the cluster for which the snapshot was taken.
                                                                                                                                                                                                                                                                                                            	ClusterIdentifier *string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The version ID of the Amazon Redshift engine that is running on the cluster.
                                                                                                                                                                                                                                                                                                            	ClusterVersion *string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The number of megabytes per second being transferred to the snapshot backup.
                                                                                                                                                                                                                                                                                                            	// Returns 0 for a completed backup.
                                                                                                                                                                                                                                                                                                            	CurrentBackupRateInMegaBytesPerSecond float64
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The name of the database that was created when the cluster was created.
                                                                                                                                                                                                                                                                                                            	DBName *string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The amount of time an in-progress snapshot backup has been running, or the
                                                                                                                                                                                                                                                                                                            	// amount of time it took a completed backup to finish.
                                                                                                                                                                                                                                                                                                            	ElapsedTimeInSeconds int64
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// If true, the data in the snapshot is encrypted at rest.
                                                                                                                                                                                                                                                                                                            	Encrypted bool
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// A boolean that indicates whether the snapshot data is encrypted using the HSM
                                                                                                                                                                                                                                                                                                            	// keys of the source cluster. true indicates that the data is encrypted using HSM
                                                                                                                                                                                                                                                                                                            	// keys.
                                                                                                                                                                                                                                                                                                            	EncryptedWithHSM bool
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The cluster version of the cluster used to create the snapshot. For example,
                                                                                                                                                                                                                                                                                                            	// 1.0.15503.
                                                                                                                                                                                                                                                                                                            	EngineFullVersion *string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// An option that specifies whether to create the cluster with enhanced VPC routing
                                                                                                                                                                                                                                                                                                            	// enabled. To create a cluster that uses enhanced VPC routing, the cluster must be
                                                                                                                                                                                                                                                                                                            	// in a VPC. For more information, see Enhanced VPC Routing
                                                                                                                                                                                                                                                                                                            	// (https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html) in
                                                                                                                                                                                                                                                                                                            	// the Amazon Redshift Cluster Management Guide. If this option is true, enhanced
                                                                                                                                                                                                                                                                                                            	// VPC routing is enabled. Default: false
                                                                                                                                                                                                                                                                                                            	EnhancedVpcRouting bool
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The estimate of the time remaining before the snapshot backup will complete.
                                                                                                                                                                                                                                                                                                            	// Returns 0 for a completed backup.
                                                                                                                                                                                                                                                                                                            	EstimatedSecondsToCompletion int64
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The AWS Key Management Service (KMS) key ID of the encryption key that was used
                                                                                                                                                                                                                                                                                                            	// to encrypt data in the cluster from which the snapshot was taken.
                                                                                                                                                                                                                                                                                                            	KmsKeyId *string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The name of the maintenance track for the snapshot.
                                                                                                                                                                                                                                                                                                            	MaintenanceTrackName *string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The number of days until a manual snapshot will pass its retention period.
                                                                                                                                                                                                                                                                                                            	ManualSnapshotRemainingDays *int32
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The number of days that a manual snapshot is retained. If the value is -1, the
                                                                                                                                                                                                                                                                                                            	// manual snapshot is retained indefinitely. The value must be either -1 or an
                                                                                                                                                                                                                                                                                                            	// integer between 1 and 3,653.
                                                                                                                                                                                                                                                                                                            	ManualSnapshotRetentionPeriod *int32
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The master user name for the cluster.
                                                                                                                                                                                                                                                                                                            	MasterUsername *string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The node type of the nodes in the cluster.
                                                                                                                                                                                                                                                                                                            	NodeType *string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The number of nodes in the cluster.
                                                                                                                                                                                                                                                                                                            	NumberOfNodes int32
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// For manual snapshots, the AWS customer account used to create or copy the
                                                                                                                                                                                                                                                                                                            	// snapshot. For automatic snapshots, the owner of the cluster. The owner can
                                                                                                                                                                                                                                                                                                            	// perform all snapshot actions, such as sharing a manual snapshot.
                                                                                                                                                                                                                                                                                                            	OwnerAccount *string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The port that the cluster is listening on.
                                                                                                                                                                                                                                                                                                            	Port int32
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The list of node types that this cluster snapshot is able to restore into.
                                                                                                                                                                                                                                                                                                            	RestorableNodeTypes []string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The time (in UTC format) when Amazon Redshift began the snapshot. A snapshot
                                                                                                                                                                                                                                                                                                            	// contains a copy of the cluster data as of this exact time.
                                                                                                                                                                                                                                                                                                            	SnapshotCreateTime *time.Time
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The snapshot identifier that is provided in the request.
                                                                                                                                                                                                                                                                                                            	SnapshotIdentifier *string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// A timestamp representing the start of the retention period for the snapshot.
                                                                                                                                                                                                                                                                                                            	SnapshotRetentionStartTime *time.Time
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The snapshot type. Snapshots created using CreateClusterSnapshot and
                                                                                                                                                                                                                                                                                                            	// CopyClusterSnapshot are of type "manual".
                                                                                                                                                                                                                                                                                                            	SnapshotType *string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The source region from which the snapshot was copied.
                                                                                                                                                                                                                                                                                                            	SourceRegion *string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The snapshot status. The value of the status depends on the API operation
                                                                                                                                                                                                                                                                                                            	// used:
                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                            	// * CreateClusterSnapshot and CopyClusterSnapshot returns status as
                                                                                                                                                                                                                                                                                                            	// "creating".
                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                            	// * DescribeClusterSnapshots returns status as "creating",
                                                                                                                                                                                                                                                                                                            	// "available", "final snapshot", or "failed".
                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                            	// * DeleteClusterSnapshot returns
                                                                                                                                                                                                                                                                                                            	// status as "deleted".
                                                                                                                                                                                                                                                                                                            	Status *string
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The list of tags for the cluster snapshot.
                                                                                                                                                                                                                                                                                                            	Tags []Tag
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The size of the complete set of backup data that would be used to restore the
                                                                                                                                                                                                                                                                                                            	// cluster.
                                                                                                                                                                                                                                                                                                            	TotalBackupSizeInMegaBytes float64
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// The VPC identifier of the cluster if the snapshot is from a cluster in a VPC.
                                                                                                                                                                                                                                                                                                            	// Otherwise, this field is not in the output.
                                                                                                                                                                                                                                                                                                            	VpcId *string
                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                              Describes a snapshot.

                                                                                                                                                                                                                                                                                                              type SnapshotAttributeToSortBy

                                                                                                                                                                                                                                                                                                              type SnapshotAttributeToSortBy string
                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                              	SnapshotAttributeToSortBySourceType SnapshotAttributeToSortBy = "SOURCE_TYPE"
                                                                                                                                                                                                                                                                                                              	SnapshotAttributeToSortByTotalSize  SnapshotAttributeToSortBy = "TOTAL_SIZE"
                                                                                                                                                                                                                                                                                                              	SnapshotAttributeToSortByCreateTime SnapshotAttributeToSortBy = "CREATE_TIME"
                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                Enum values for SnapshotAttributeToSortBy

                                                                                                                                                                                                                                                                                                                func (SnapshotAttributeToSortBy) Values

                                                                                                                                                                                                                                                                                                                  Values returns all known values for SnapshotAttributeToSortBy. 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 SnapshotCopyAlreadyDisabledFault

                                                                                                                                                                                                                                                                                                                  type SnapshotCopyAlreadyDisabledFault struct {
                                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                    The cluster already has cross-region snapshot copy disabled.

                                                                                                                                                                                                                                                                                                                    func (*SnapshotCopyAlreadyDisabledFault) Error

                                                                                                                                                                                                                                                                                                                    func (*SnapshotCopyAlreadyDisabledFault) ErrorCode

                                                                                                                                                                                                                                                                                                                    func (*SnapshotCopyAlreadyDisabledFault) ErrorFault

                                                                                                                                                                                                                                                                                                                    func (*SnapshotCopyAlreadyDisabledFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                    func (e *SnapshotCopyAlreadyDisabledFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                    type SnapshotCopyAlreadyEnabledFault

                                                                                                                                                                                                                                                                                                                    type SnapshotCopyAlreadyEnabledFault struct {
                                                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                      The cluster already has cross-region snapshot copy enabled.

                                                                                                                                                                                                                                                                                                                      func (*SnapshotCopyAlreadyEnabledFault) Error

                                                                                                                                                                                                                                                                                                                      func (*SnapshotCopyAlreadyEnabledFault) ErrorCode

                                                                                                                                                                                                                                                                                                                      func (e *SnapshotCopyAlreadyEnabledFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                      func (*SnapshotCopyAlreadyEnabledFault) ErrorFault

                                                                                                                                                                                                                                                                                                                      func (*SnapshotCopyAlreadyEnabledFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                      func (e *SnapshotCopyAlreadyEnabledFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                      type SnapshotCopyDisabledFault

                                                                                                                                                                                                                                                                                                                      type SnapshotCopyDisabledFault struct {
                                                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                        Cross-region snapshot copy was temporarily disabled. Try your request again.

                                                                                                                                                                                                                                                                                                                        func (*SnapshotCopyDisabledFault) Error

                                                                                                                                                                                                                                                                                                                        func (e *SnapshotCopyDisabledFault) Error() string

                                                                                                                                                                                                                                                                                                                        func (*SnapshotCopyDisabledFault) ErrorCode

                                                                                                                                                                                                                                                                                                                        func (e *SnapshotCopyDisabledFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                        func (*SnapshotCopyDisabledFault) ErrorFault

                                                                                                                                                                                                                                                                                                                        func (*SnapshotCopyDisabledFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                        func (e *SnapshotCopyDisabledFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                        type SnapshotCopyGrant

                                                                                                                                                                                                                                                                                                                        type SnapshotCopyGrant struct {
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The unique identifier of the customer master key (CMK) in AWS KMS to which
                                                                                                                                                                                                                                                                                                                        	// Amazon Redshift is granted permission.
                                                                                                                                                                                                                                                                                                                        	KmsKeyId *string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// The name of the snapshot copy grant.
                                                                                                                                                                                                                                                                                                                        	SnapshotCopyGrantName *string
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// A list of tag instances.
                                                                                                                                                                                                                                                                                                                        	Tags []Tag
                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                          The snapshot copy grant that grants Amazon Redshift permission to encrypt copied snapshots with the specified customer master key (CMK) from AWS KMS in the destination region. For more information about managing snapshot copy grants, go to Amazon Redshift Database Encryption (https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-db-encryption.html) in the Amazon Redshift Cluster Management Guide.

                                                                                                                                                                                                                                                                                                                          type SnapshotCopyGrantAlreadyExistsFault

                                                                                                                                                                                                                                                                                                                          type SnapshotCopyGrantAlreadyExistsFault struct {
                                                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                            The snapshot copy grant can't be created because a grant with the same name already exists.

                                                                                                                                                                                                                                                                                                                            func (*SnapshotCopyGrantAlreadyExistsFault) Error

                                                                                                                                                                                                                                                                                                                            func (*SnapshotCopyGrantAlreadyExistsFault) ErrorCode

                                                                                                                                                                                                                                                                                                                            func (*SnapshotCopyGrantAlreadyExistsFault) ErrorFault

                                                                                                                                                                                                                                                                                                                            func (*SnapshotCopyGrantAlreadyExistsFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                            func (e *SnapshotCopyGrantAlreadyExistsFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                            type SnapshotCopyGrantNotFoundFault

                                                                                                                                                                                                                                                                                                                            type SnapshotCopyGrantNotFoundFault struct {
                                                                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                              The specified snapshot copy grant can't be found. Make sure that the name is typed correctly and that the grant exists in the destination region.

                                                                                                                                                                                                                                                                                                                              func (*SnapshotCopyGrantNotFoundFault) Error

                                                                                                                                                                                                                                                                                                                              func (*SnapshotCopyGrantNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                                                                                              func (e *SnapshotCopyGrantNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                              func (*SnapshotCopyGrantNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                                                                                              func (*SnapshotCopyGrantNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                              func (e *SnapshotCopyGrantNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                              type SnapshotCopyGrantQuotaExceededFault

                                                                                                                                                                                                                                                                                                                              type SnapshotCopyGrantQuotaExceededFault struct {
                                                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                The AWS account has exceeded the maximum number of snapshot copy grants in this region.

                                                                                                                                                                                                                                                                                                                                func (*SnapshotCopyGrantQuotaExceededFault) Error

                                                                                                                                                                                                                                                                                                                                func (*SnapshotCopyGrantQuotaExceededFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                func (*SnapshotCopyGrantQuotaExceededFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                func (*SnapshotCopyGrantQuotaExceededFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                func (e *SnapshotCopyGrantQuotaExceededFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                type SnapshotErrorMessage

                                                                                                                                                                                                                                                                                                                                type SnapshotErrorMessage struct {
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// The failure code for the error.
                                                                                                                                                                                                                                                                                                                                	FailureCode *string
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// The text message describing the error.
                                                                                                                                                                                                                                                                                                                                	FailureReason *string
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// A unique identifier for the cluster.
                                                                                                                                                                                                                                                                                                                                	SnapshotClusterIdentifier *string
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// A unique identifier for the snapshot returning the error.
                                                                                                                                                                                                                                                                                                                                	SnapshotIdentifier *string
                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                  Describes the errors returned by a snapshot.

                                                                                                                                                                                                                                                                                                                                  type SnapshotSchedule

                                                                                                                                                                                                                                                                                                                                  type SnapshotSchedule struct {
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The number of clusters associated with the schedule.
                                                                                                                                                                                                                                                                                                                                  	AssociatedClusterCount *int32
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// A list of clusters associated with the schedule. A maximum of 100 clusters is
                                                                                                                                                                                                                                                                                                                                  	// returned.
                                                                                                                                                                                                                                                                                                                                  	AssociatedClusters []ClusterAssociatedToSchedule
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                                                                  	NextInvocations []time.Time
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// A list of ScheduleDefinitions.
                                                                                                                                                                                                                                                                                                                                  	ScheduleDefinitions []string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// The description of the schedule.
                                                                                                                                                                                                                                                                                                                                  	ScheduleDescription *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// A unique identifier for the schedule.
                                                                                                                                                                                                                                                                                                                                  	ScheduleIdentifier *string
                                                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                                                  	// An optional set of tags describing the schedule.
                                                                                                                                                                                                                                                                                                                                  	Tags []Tag
                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                    Describes a snapshot schedule. You can set a regular interval for creating snapshots of a cluster. You can also schedule snapshots for specific dates.

                                                                                                                                                                                                                                                                                                                                    type SnapshotScheduleAlreadyExistsFault

                                                                                                                                                                                                                                                                                                                                    type SnapshotScheduleAlreadyExistsFault struct {
                                                                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                      The specified snapshot schedule already exists.

                                                                                                                                                                                                                                                                                                                                      func (*SnapshotScheduleAlreadyExistsFault) Error

                                                                                                                                                                                                                                                                                                                                      func (*SnapshotScheduleAlreadyExistsFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                      func (*SnapshotScheduleAlreadyExistsFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                      func (*SnapshotScheduleAlreadyExistsFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                      func (e *SnapshotScheduleAlreadyExistsFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                      type SnapshotScheduleNotFoundFault

                                                                                                                                                                                                                                                                                                                                      type SnapshotScheduleNotFoundFault struct {
                                                                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                        We could not find the specified snapshot schedule.

                                                                                                                                                                                                                                                                                                                                        func (*SnapshotScheduleNotFoundFault) Error

                                                                                                                                                                                                                                                                                                                                        func (*SnapshotScheduleNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                        func (e *SnapshotScheduleNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                        func (*SnapshotScheduleNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                        func (*SnapshotScheduleNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                        func (e *SnapshotScheduleNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                        type SnapshotScheduleQuotaExceededFault

                                                                                                                                                                                                                                                                                                                                        type SnapshotScheduleQuotaExceededFault struct {
                                                                                                                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                          You have exceeded the quota of snapshot schedules.

                                                                                                                                                                                                                                                                                                                                          func (*SnapshotScheduleQuotaExceededFault) Error

                                                                                                                                                                                                                                                                                                                                          func (*SnapshotScheduleQuotaExceededFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                          func (*SnapshotScheduleQuotaExceededFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                          func (*SnapshotScheduleQuotaExceededFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                          func (e *SnapshotScheduleQuotaExceededFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                          type SnapshotScheduleUpdateInProgressFault

                                                                                                                                                                                                                                                                                                                                          type SnapshotScheduleUpdateInProgressFault struct {
                                                                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                            The specified snapshot schedule is already being updated.

                                                                                                                                                                                                                                                                                                                                            func (*SnapshotScheduleUpdateInProgressFault) Error

                                                                                                                                                                                                                                                                                                                                            func (*SnapshotScheduleUpdateInProgressFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                            func (*SnapshotScheduleUpdateInProgressFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                            func (*SnapshotScheduleUpdateInProgressFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                            type SnapshotSortingEntity

                                                                                                                                                                                                                                                                                                                                            type SnapshotSortingEntity struct {
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The category for sorting the snapshots.
                                                                                                                                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                                                                                                                                            	Attribute SnapshotAttributeToSortBy
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            	// The order for listing the attributes.
                                                                                                                                                                                                                                                                                                                                            	SortOrder SortByOrder
                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                              Describes a sorting entity

                                                                                                                                                                                                                                                                                                                                              type SortByOrder

                                                                                                                                                                                                                                                                                                                                              type SortByOrder string
                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                              	SortByOrderAscending  SortByOrder = "ASC"
                                                                                                                                                                                                                                                                                                                                              	SortByOrderDescending SortByOrder = "DESC"
                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                Enum values for SortByOrder

                                                                                                                                                                                                                                                                                                                                                func (SortByOrder) Values

                                                                                                                                                                                                                                                                                                                                                func (SortByOrder) Values() []SortByOrder

                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for SortByOrder. 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 SourceNotFoundFault

                                                                                                                                                                                                                                                                                                                                                  type SourceNotFoundFault struct {
                                                                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                    The specified Amazon Redshift event 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 SourceType

                                                                                                                                                                                                                                                                                                                                                    type SourceType string
                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                    	SourceTypeCluster               SourceType = "cluster"
                                                                                                                                                                                                                                                                                                                                                    	SourceTypeClusterParameterGroup SourceType = "cluster-parameter-group"
                                                                                                                                                                                                                                                                                                                                                    	SourceTypeClusterSecurityGroup  SourceType = "cluster-security-group"
                                                                                                                                                                                                                                                                                                                                                    	SourceTypeClusterSnapshot       SourceType = "cluster-snapshot"
                                                                                                                                                                                                                                                                                                                                                    	SourceTypeScheduledAction       SourceType = "scheduled-action"
                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                      Enum values for SourceType

                                                                                                                                                                                                                                                                                                                                                      func (SourceType) Values

                                                                                                                                                                                                                                                                                                                                                      func (SourceType) Values() []SourceType

                                                                                                                                                                                                                                                                                                                                                        Values returns all known values for SourceType. 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 SpartaProxyVpcEndpoint

                                                                                                                                                                                                                                                                                                                                                        type SpartaProxyVpcEndpoint struct {
                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                        	// The connection endpoint ID for connecting an Amazon Redshift cluster through the
                                                                                                                                                                                                                                                                                                                                                        	// proxy.
                                                                                                                                                                                                                                                                                                                                                        	VpcEndpointId *string
                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                          The connection endpoint for connecting an Amazon Redshift cluster through the proxy.

                                                                                                                                                                                                                                                                                                                                                          type Subnet

                                                                                                                                                                                                                                                                                                                                                          type Subnet struct {
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                          	SubnetAvailabilityZone *AvailabilityZone
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// The identifier of the subnet.
                                                                                                                                                                                                                                                                                                                                                          	SubnetIdentifier *string
                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                          	// The status of the subnet.
                                                                                                                                                                                                                                                                                                                                                          	SubnetStatus *string
                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                            Describes a subnet.

                                                                                                                                                                                                                                                                                                                                                            type SubnetAlreadyInUse

                                                                                                                                                                                                                                                                                                                                                            type SubnetAlreadyInUse struct {
                                                                                                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                              A specified subnet is already in use by another cluster.

                                                                                                                                                                                                                                                                                                                                                              func (*SubnetAlreadyInUse) Error

                                                                                                                                                                                                                                                                                                                                                              func (e *SubnetAlreadyInUse) Error() string

                                                                                                                                                                                                                                                                                                                                                              func (*SubnetAlreadyInUse) ErrorCode

                                                                                                                                                                                                                                                                                                                                                              func (e *SubnetAlreadyInUse) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                              func (*SubnetAlreadyInUse) ErrorFault

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

                                                                                                                                                                                                                                                                                                                                                              func (*SubnetAlreadyInUse) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                              func (e *SubnetAlreadyInUse) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                              type SubscriptionAlreadyExistFault

                                                                                                                                                                                                                                                                                                                                                              type SubscriptionAlreadyExistFault struct {
                                                                                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                There is already an existing event notification subscription with the specified name.

                                                                                                                                                                                                                                                                                                                                                                func (*SubscriptionAlreadyExistFault) Error

                                                                                                                                                                                                                                                                                                                                                                func (*SubscriptionAlreadyExistFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                func (e *SubscriptionAlreadyExistFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                func (*SubscriptionAlreadyExistFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                func (*SubscriptionAlreadyExistFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                func (e *SubscriptionAlreadyExistFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                type SubscriptionCategoryNotFoundFault

                                                                                                                                                                                                                                                                                                                                                                type SubscriptionCategoryNotFoundFault struct {
                                                                                                                                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                  The value specified for the event category was not one of the allowed values, or it specified a category that does not apply to the specified source type. The allowed values are Configuration, Management, Monitoring, and Security.

                                                                                                                                                                                                                                                                                                                                                                  func (*SubscriptionCategoryNotFoundFault) Error

                                                                                                                                                                                                                                                                                                                                                                  func (*SubscriptionCategoryNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                  func (*SubscriptionCategoryNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                  func (*SubscriptionCategoryNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                  func (e *SubscriptionCategoryNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                  type SubscriptionEventIdNotFoundFault

                                                                                                                                                                                                                                                                                                                                                                  type SubscriptionEventIdNotFoundFault struct {
                                                                                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                    An Amazon Redshift event with the specified event ID does not exist.

                                                                                                                                                                                                                                                                                                                                                                    func (*SubscriptionEventIdNotFoundFault) Error

                                                                                                                                                                                                                                                                                                                                                                    func (*SubscriptionEventIdNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                    func (*SubscriptionEventIdNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                    func (*SubscriptionEventIdNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                    func (e *SubscriptionEventIdNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                    type SubscriptionNotFoundFault

                                                                                                                                                                                                                                                                                                                                                                    type SubscriptionNotFoundFault struct {
                                                                                                                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                      An Amazon Redshift event notification subscription with the specified name does not exist.

                                                                                                                                                                                                                                                                                                                                                                      func (*SubscriptionNotFoundFault) Error

                                                                                                                                                                                                                                                                                                                                                                      func (e *SubscriptionNotFoundFault) Error() string

                                                                                                                                                                                                                                                                                                                                                                      func (*SubscriptionNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                      func (e *SubscriptionNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                      func (*SubscriptionNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                      func (*SubscriptionNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                      func (e *SubscriptionNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                      type SubscriptionSeverityNotFoundFault

                                                                                                                                                                                                                                                                                                                                                                      type SubscriptionSeverityNotFoundFault struct {
                                                                                                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                        The value specified for the event severity was not one of the allowed values, or it specified a severity that does not apply to the specified source type. The allowed values are ERROR and INFO.

                                                                                                                                                                                                                                                                                                                                                                        func (*SubscriptionSeverityNotFoundFault) Error

                                                                                                                                                                                                                                                                                                                                                                        func (*SubscriptionSeverityNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                        func (*SubscriptionSeverityNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                        func (*SubscriptionSeverityNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                        func (e *SubscriptionSeverityNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                        type SupportedOperation

                                                                                                                                                                                                                                                                                                                                                                        type SupportedOperation struct {
                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                        	// A list of the supported operations.
                                                                                                                                                                                                                                                                                                                                                                        	OperationName *string
                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                          Describes the operations that are allowed on a maintenance track.

                                                                                                                                                                                                                                                                                                                                                                          type SupportedPlatform

                                                                                                                                                                                                                                                                                                                                                                          type SupportedPlatform struct {
                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                          	Name *string
                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                            A list of supported platforms for orderable clusters.

                                                                                                                                                                                                                                                                                                                                                                            type TableLimitExceededFault

                                                                                                                                                                                                                                                                                                                                                                            type TableLimitExceededFault struct {
                                                                                                                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                              The number of tables in the cluster exceeds the limit for the requested new cluster node type.

                                                                                                                                                                                                                                                                                                                                                                              func (*TableLimitExceededFault) Error

                                                                                                                                                                                                                                                                                                                                                                              func (e *TableLimitExceededFault) Error() string

                                                                                                                                                                                                                                                                                                                                                                              func (*TableLimitExceededFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                              func (e *TableLimitExceededFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                              func (*TableLimitExceededFault) ErrorFault

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

                                                                                                                                                                                                                                                                                                                                                                              func (*TableLimitExceededFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                              func (e *TableLimitExceededFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                              type TableRestoreNotFoundFault

                                                                                                                                                                                                                                                                                                                                                                              type TableRestoreNotFoundFault struct {
                                                                                                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                The specified TableRestoreRequestId value was not found.

                                                                                                                                                                                                                                                                                                                                                                                func (*TableRestoreNotFoundFault) Error

                                                                                                                                                                                                                                                                                                                                                                                func (e *TableRestoreNotFoundFault) Error() string

                                                                                                                                                                                                                                                                                                                                                                                func (*TableRestoreNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                func (e *TableRestoreNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                func (*TableRestoreNotFoundFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                func (*TableRestoreNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                func (e *TableRestoreNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                type TableRestoreStatus

                                                                                                                                                                                                                                                                                                                                                                                type TableRestoreStatus struct {
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// The identifier of the Amazon Redshift cluster that the table is being restored
                                                                                                                                                                                                                                                                                                                                                                                	// to.
                                                                                                                                                                                                                                                                                                                                                                                	ClusterIdentifier *string
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// A description of the status of the table restore request. Status values include
                                                                                                                                                                                                                                                                                                                                                                                	// SUCCEEDED, FAILED, CANCELED, PENDING, IN_PROGRESS.
                                                                                                                                                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// The name of the table to create as a result of the table restore request.
                                                                                                                                                                                                                                                                                                                                                                                	NewTableName *string
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// The amount of data restored to the new table so far, in megabytes (MB).
                                                                                                                                                                                                                                                                                                                                                                                	ProgressInMegaBytes *int64
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// The time that the table restore request was made, in Universal Coordinated Time
                                                                                                                                                                                                                                                                                                                                                                                	// (UTC).
                                                                                                                                                                                                                                                                                                                                                                                	RequestTime *time.Time
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// The identifier of the snapshot that the table is being restored from.
                                                                                                                                                                                                                                                                                                                                                                                	SnapshotIdentifier *string
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// The name of the source database that contains the table being restored.
                                                                                                                                                                                                                                                                                                                                                                                	SourceDatabaseName *string
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// The name of the source schema that contains the table being restored.
                                                                                                                                                                                                                                                                                                                                                                                	SourceSchemaName *string
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// The name of the source table being restored.
                                                                                                                                                                                                                                                                                                                                                                                	SourceTableName *string
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// A value that describes the current state of the table restore request. Valid
                                                                                                                                                                                                                                                                                                                                                                                	// Values: SUCCEEDED, FAILED, CANCELED, PENDING, IN_PROGRESS
                                                                                                                                                                                                                                                                                                                                                                                	Status TableRestoreStatusType
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// The unique identifier for the table restore request.
                                                                                                                                                                                                                                                                                                                                                                                	TableRestoreRequestId *string
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// The name of the database to restore the table to.
                                                                                                                                                                                                                                                                                                                                                                                	TargetDatabaseName *string
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// The name of the schema to restore the table to.
                                                                                                                                                                                                                                                                                                                                                                                	TargetSchemaName *string
                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                	// The total amount of data to restore to the new table, in megabytes (MB).
                                                                                                                                                                                                                                                                                                                                                                                	TotalDataInMegaBytes *int64
                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                  Describes the status of a RestoreTableFromClusterSnapshot operation.

                                                                                                                                                                                                                                                                                                                                                                                  type TableRestoreStatusType

                                                                                                                                                                                                                                                                                                                                                                                  type TableRestoreStatusType string
                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                  	TableRestoreStatusTypePending    TableRestoreStatusType = "PENDING"
                                                                                                                                                                                                                                                                                                                                                                                  	TableRestoreStatusTypeInProgress TableRestoreStatusType = "IN_PROGRESS"
                                                                                                                                                                                                                                                                                                                                                                                  	TableRestoreStatusTypeSucceeded  TableRestoreStatusType = "SUCCEEDED"
                                                                                                                                                                                                                                                                                                                                                                                  	TableRestoreStatusTypeFailed     TableRestoreStatusType = "FAILED"
                                                                                                                                                                                                                                                                                                                                                                                  	TableRestoreStatusTypeCanceled   TableRestoreStatusType = "CANCELED"
                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                    Enum values for TableRestoreStatusType

                                                                                                                                                                                                                                                                                                                                                                                    func (TableRestoreStatusType) Values

                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for TableRestoreStatusType. 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 Tag

                                                                                                                                                                                                                                                                                                                                                                                      type Tag struct {
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      	// The key, or name, for the resource tag.
                                                                                                                                                                                                                                                                                                                                                                                      	Key *string
                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                      	// The value for the resource tag.
                                                                                                                                                                                                                                                                                                                                                                                      	Value *string
                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                        A tag consisting of a name/value pair for a resource.

                                                                                                                                                                                                                                                                                                                                                                                        type TagLimitExceededFault

                                                                                                                                                                                                                                                                                                                                                                                        type TagLimitExceededFault struct {
                                                                                                                                                                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                          You have exceeded the number of tags allowed.

                                                                                                                                                                                                                                                                                                                                                                                          func (*TagLimitExceededFault) Error

                                                                                                                                                                                                                                                                                                                                                                                          func (e *TagLimitExceededFault) Error() string

                                                                                                                                                                                                                                                                                                                                                                                          func (*TagLimitExceededFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                          func (e *TagLimitExceededFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                          func (*TagLimitExceededFault) ErrorFault

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

                                                                                                                                                                                                                                                                                                                                                                                          func (*TagLimitExceededFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                          func (e *TagLimitExceededFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                          type TaggedResource

                                                                                                                                                                                                                                                                                                                                                                                          type TaggedResource struct {
                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                          	// The Amazon Resource Name (ARN) with which the tag is associated, for example:
                                                                                                                                                                                                                                                                                                                                                                                          	// arn:aws:redshift:us-east-2:123456789:cluster:t1.
                                                                                                                                                                                                                                                                                                                                                                                          	ResourceName *string
                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                          	// The type of resource with which the tag is associated. Valid resource types
                                                                                                                                                                                                                                                                                                                                                                                          	// are:
                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                          	// * Cluster
                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                          	// * CIDR/IP
                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                          	// * EC2 security group
                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                          	// * Snapshot
                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                          	// * Cluster security
                                                                                                                                                                                                                                                                                                                                                                                          	// group
                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                          	// * Subnet group
                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                          	// * HSM connection
                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                          	// * HSM certificate
                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                          	// * Parameter
                                                                                                                                                                                                                                                                                                                                                                                          	// group
                                                                                                                                                                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                                                                                                                                                                          	// For more information about Amazon Redshift resource types and
                                                                                                                                                                                                                                                                                                                                                                                          	// constructing ARNs, go to Constructing an Amazon Redshift Amazon Resource Name
                                                                                                                                                                                                                                                                                                                                                                                          	// (ARN)
                                                                                                                                                                                                                                                                                                                                                                                          	// (https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-overview.html#redshift-iam-access-control-specify-actions)
                                                                                                                                                                                                                                                                                                                                                                                          	// in the Amazon Redshift Cluster Management Guide.
                                                                                                                                                                                                                                                                                                                                                                                          	ResourceType *string
                                                                                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                                                                                          	// The tag for the resource.
                                                                                                                                                                                                                                                                                                                                                                                          	Tag *Tag
                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                            A tag and its associated resource.

                                                                                                                                                                                                                                                                                                                                                                                            type UnauthorizedOperation

                                                                                                                                                                                                                                                                                                                                                                                            type UnauthorizedOperation struct {
                                                                                                                                                                                                                                                                                                                                                                                            	Message *string
                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                              Your account is not authorized to perform the requested operation.

                                                                                                                                                                                                                                                                                                                                                                                              func (*UnauthorizedOperation) Error

                                                                                                                                                                                                                                                                                                                                                                                              func (e *UnauthorizedOperation) Error() string

                                                                                                                                                                                                                                                                                                                                                                                              func (*UnauthorizedOperation) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                              func (e *UnauthorizedOperation) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                              func (*UnauthorizedOperation) ErrorFault

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

                                                                                                                                                                                                                                                                                                                                                                                              func (*UnauthorizedOperation) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                              func (e *UnauthorizedOperation) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                              type UnknownSnapshotCopyRegionFault

                                                                                                                                                                                                                                                                                                                                                                                              type UnknownSnapshotCopyRegionFault struct {
                                                                                                                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                The specified region is incorrect or does not exist.

                                                                                                                                                                                                                                                                                                                                                                                                func (*UnknownSnapshotCopyRegionFault) Error

                                                                                                                                                                                                                                                                                                                                                                                                func (*UnknownSnapshotCopyRegionFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                func (e *UnknownSnapshotCopyRegionFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                func (*UnknownSnapshotCopyRegionFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                func (*UnknownSnapshotCopyRegionFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                func (e *UnknownSnapshotCopyRegionFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                type UnsupportedOperationFault

                                                                                                                                                                                                                                                                                                                                                                                                type UnsupportedOperationFault struct {
                                                                                                                                                                                                                                                                                                                                                                                                	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                  The requested operation isn't supported.

                                                                                                                                                                                                                                                                                                                                                                                                  func (*UnsupportedOperationFault) Error

                                                                                                                                                                                                                                                                                                                                                                                                  func (e *UnsupportedOperationFault) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                  func (*UnsupportedOperationFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                  func (e *UnsupportedOperationFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                  func (*UnsupportedOperationFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                  func (*UnsupportedOperationFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                  func (e *UnsupportedOperationFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                  type UnsupportedOptionFault

                                                                                                                                                                                                                                                                                                                                                                                                  type UnsupportedOptionFault struct {
                                                                                                                                                                                                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                    A request option was specified that is not supported.

                                                                                                                                                                                                                                                                                                                                                                                                    func (*UnsupportedOptionFault) Error

                                                                                                                                                                                                                                                                                                                                                                                                    func (e *UnsupportedOptionFault) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                    func (*UnsupportedOptionFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                    func (e *UnsupportedOptionFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                    func (*UnsupportedOptionFault) ErrorFault

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

                                                                                                                                                                                                                                                                                                                                                                                                    func (*UnsupportedOptionFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                    func (e *UnsupportedOptionFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                    type UpdateTarget

                                                                                                                                                                                                                                                                                                                                                                                                    type UpdateTarget struct {
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The cluster version for the new maintenance track.
                                                                                                                                                                                                                                                                                                                                                                                                    	DatabaseVersion *string
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// The name of the new maintenance track.
                                                                                                                                                                                                                                                                                                                                                                                                    	MaintenanceTrackName *string
                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                    	// A list of operations supported by the maintenance track.
                                                                                                                                                                                                                                                                                                                                                                                                    	SupportedOperations []SupportedOperation
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                      A maintenance track that you can switch the current track to.

                                                                                                                                                                                                                                                                                                                                                                                                      type UsageLimit

                                                                                                                                                                                                                                                                                                                                                                                                      type UsageLimit struct {
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// The limit amount. If time-based, this amount is in minutes. If data-based, this
                                                                                                                                                                                                                                                                                                                                                                                                      	// amount is in terabytes (TB).
                                                                                                                                                                                                                                                                                                                                                                                                      	Amount int64
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// The action that Amazon Redshift takes when the limit is reached. Possible values
                                                                                                                                                                                                                                                                                                                                                                                                      	// are:
                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                      	// * log - To log an event in a system table. The default is log.
                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                      	// *
                                                                                                                                                                                                                                                                                                                                                                                                      	// emit-metric - To emit CloudWatch metrics.
                                                                                                                                                                                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                                                                                                                                                                                      	// * disable - To disable the feature
                                                                                                                                                                                                                                                                                                                                                                                                      	// until the next usage period begins.
                                                                                                                                                                                                                                                                                                                                                                                                      	BreachAction UsageLimitBreachAction
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// The identifier of the cluster with a usage limit.
                                                                                                                                                                                                                                                                                                                                                                                                      	ClusterIdentifier *string
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// The Amazon Redshift feature to which the limit applies.
                                                                                                                                                                                                                                                                                                                                                                                                      	FeatureType UsageLimitFeatureType
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// The type of limit. Depending on the feature type, this can be based on a time
                                                                                                                                                                                                                                                                                                                                                                                                      	// duration or data size.
                                                                                                                                                                                                                                                                                                                                                                                                      	LimitType UsageLimitLimitType
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// The time period that the amount applies to. A weekly period begins on Sunday.
                                                                                                                                                                                                                                                                                                                                                                                                      	// The default is monthly.
                                                                                                                                                                                                                                                                                                                                                                                                      	Period UsageLimitPeriod
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// A list of tag instances.
                                                                                                                                                                                                                                                                                                                                                                                                      	Tags []Tag
                                                                                                                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                                                                                                                      	// The identifier of the usage limit.
                                                                                                                                                                                                                                                                                                                                                                                                      	UsageLimitId *string
                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                        Describes a usage limit object for a cluster.

                                                                                                                                                                                                                                                                                                                                                                                                        type UsageLimitAlreadyExistsFault

                                                                                                                                                                                                                                                                                                                                                                                                        type UsageLimitAlreadyExistsFault struct {
                                                                                                                                                                                                                                                                                                                                                                                                        	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                          The usage limit already exists.

                                                                                                                                                                                                                                                                                                                                                                                                          func (*UsageLimitAlreadyExistsFault) Error

                                                                                                                                                                                                                                                                                                                                                                                                          func (*UsageLimitAlreadyExistsFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                          func (e *UsageLimitAlreadyExistsFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                          func (*UsageLimitAlreadyExistsFault) ErrorFault

                                                                                                                                                                                                                                                                                                                                                                                                          func (*UsageLimitAlreadyExistsFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                          func (e *UsageLimitAlreadyExistsFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                          type UsageLimitBreachAction

                                                                                                                                                                                                                                                                                                                                                                                                          type UsageLimitBreachAction string
                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                          	UsageLimitBreachActionLog        UsageLimitBreachAction = "log"
                                                                                                                                                                                                                                                                                                                                                                                                          	UsageLimitBreachActionEmitMetric UsageLimitBreachAction = "emit-metric"
                                                                                                                                                                                                                                                                                                                                                                                                          	UsageLimitBreachActionDisable    UsageLimitBreachAction = "disable"
                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                            Enum values for UsageLimitBreachAction

                                                                                                                                                                                                                                                                                                                                                                                                            func (UsageLimitBreachAction) Values

                                                                                                                                                                                                                                                                                                                                                                                                              Values returns all known values for UsageLimitBreachAction. 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 UsageLimitFeatureType

                                                                                                                                                                                                                                                                                                                                                                                                              type UsageLimitFeatureType string
                                                                                                                                                                                                                                                                                                                                                                                                              const (
                                                                                                                                                                                                                                                                                                                                                                                                              	UsageLimitFeatureTypeSpectrum           UsageLimitFeatureType = "spectrum"
                                                                                                                                                                                                                                                                                                                                                                                                              	UsageLimitFeatureTypeConcurrencyScaling UsageLimitFeatureType = "concurrency-scaling"
                                                                                                                                                                                                                                                                                                                                                                                                              )

                                                                                                                                                                                                                                                                                                                                                                                                                Enum values for UsageLimitFeatureType

                                                                                                                                                                                                                                                                                                                                                                                                                func (UsageLimitFeatureType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                  Values returns all known values for UsageLimitFeatureType. 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 UsageLimitLimitType

                                                                                                                                                                                                                                                                                                                                                                                                                  type UsageLimitLimitType string
                                                                                                                                                                                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                                                                                                                                                                                  	UsageLimitLimitTypeTime        UsageLimitLimitType = "time"
                                                                                                                                                                                                                                                                                                                                                                                                                  	UsageLimitLimitTypeDataScanned UsageLimitLimitType = "data-scanned"
                                                                                                                                                                                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                                                                                                                                                                                    Enum values for UsageLimitLimitType

                                                                                                                                                                                                                                                                                                                                                                                                                    func (UsageLimitLimitType) Values

                                                                                                                                                                                                                                                                                                                                                                                                                      Values returns all known values for UsageLimitLimitType. 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 UsageLimitNotFoundFault

                                                                                                                                                                                                                                                                                                                                                                                                                      type UsageLimitNotFoundFault struct {
                                                                                                                                                                                                                                                                                                                                                                                                                      	Message *string
                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                        The usage limit identifier can't be found.

                                                                                                                                                                                                                                                                                                                                                                                                                        func (*UsageLimitNotFoundFault) Error

                                                                                                                                                                                                                                                                                                                                                                                                                        func (e *UsageLimitNotFoundFault) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                                        func (*UsageLimitNotFoundFault) ErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                                        func (e *UsageLimitNotFoundFault) ErrorCode() string

                                                                                                                                                                                                                                                                                                                                                                                                                        func (*UsageLimitNotFoundFault) ErrorFault

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

                                                                                                                                                                                                                                                                                                                                                                                                                        func (*UsageLimitNotFoundFault) ErrorMessage

                                                                                                                                                                                                                                                                                                                                                                                                                        func (e *UsageLimitNotFoundFault) ErrorMessage() string

                                                                                                                                                                                                                                                                                                                                                                                                                        type UsageLimitPeriod

                                                                                                                                                                                                                                                                                                                                                                                                                        type UsageLimitPeriod string
                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                        	UsageLimitPeriodDaily   UsageLimitPeriod = "daily"
                                                                                                                                                                                                                                                                                                                                                                                                                        	UsageLimitPeriodWeekly  UsageLimitPeriod = "weekly"
                                                                                                                                                                                                                                                                                                                                                                                                                        	UsageLimitPeriodMonthly UsageLimitPeriod = "monthly"
                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                          Enum values for UsageLimitPeriod

                                                                                                                                                                                                                                                                                                                                                                                                                          func (UsageLimitPeriod) Values

                                                                                                                                                                                                                                                                                                                                                                                                                            Values returns all known values for UsageLimitPeriod. 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 VpcSecurityGroupMembership

                                                                                                                                                                                                                                                                                                                                                                                                                            type VpcSecurityGroupMembership struct {
                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                            	// The status of the VPC security group.
                                                                                                                                                                                                                                                                                                                                                                                                                            	Status *string
                                                                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                                                                            	// The identifier of the VPC security group.
                                                                                                                                                                                                                                                                                                                                                                                                                            	VpcSecurityGroupId *string
                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                              Describes the members of a VPC security group.