types

package
v1.1.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 10, 2021 License: Apache-2.0 Imports: 3 Imported by: 16

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 (e *AccessToSnapshotDeniedFault) Error() string

func (*AccessToSnapshotDeniedFault) ErrorCode 

func (e *AccessToSnapshotDeniedFault) ErrorCode() string

func (*AccessToSnapshotDeniedFault) ErrorFault 

func (e *AccessToSnapshotDeniedFault) ErrorFault() smithy.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 added in v0.29.0 

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 (e *AuthorizationAlreadyExistsFault) Error() string

func (*AuthorizationAlreadyExistsFault) ErrorCode 

func (e *AuthorizationAlreadyExistsFault) ErrorCode() string

func (*AuthorizationAlreadyExistsFault) ErrorFault 

func (e *AuthorizationAlreadyExistsFault) ErrorFault() smithy.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 (e *AuthorizationNotFoundFault) Error() string

func (*AuthorizationNotFoundFault) ErrorCode 

func (e *AuthorizationNotFoundFault) ErrorCode() string

func (*AuthorizationNotFoundFault) ErrorFault 

func (e *AuthorizationNotFoundFault) ErrorFault() smithy.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 (e *AuthorizationQuotaExceededFault) Error() string

func (*AuthorizationQuotaExceededFault) ErrorCode 

func (e *AuthorizationQuotaExceededFault) ErrorCode() string

func (*AuthorizationQuotaExceededFault) ErrorFault 

func (e *AuthorizationQuotaExceededFault) ErrorFault() smithy.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 (e *BatchDeleteRequestSizeExceededFault) Error() string

func (*BatchDeleteRequestSizeExceededFault) ErrorCode 

func (e *BatchDeleteRequestSizeExceededFault) ErrorCode() string

func (*BatchDeleteRequestSizeExceededFault) ErrorFault 

func (e *BatchDeleteRequestSizeExceededFault) ErrorFault() smithy.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 (e *BatchModifyClusterSnapshotsLimitExceededFault) Error() string

func (*BatchModifyClusterSnapshotsLimitExceededFault) ErrorCode 

func (e *BatchModifyClusterSnapshotsLimitExceededFault) ErrorCode() string

func (*BatchModifyClusterSnapshotsLimitExceededFault) ErrorFault 

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

func (*BatchModifyClusterSnapshotsLimitExceededFault) ErrorMessage 

func (e *BatchModifyClusterSnapshotsLimitExceededFault) ErrorMessage() string

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 (e *ClusterAlreadyExistsFault) ErrorFault() smithy.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 (e *ClusterOnLatestRevisionFault) Error() string

func (*ClusterOnLatestRevisionFault) ErrorCode 

func (e *ClusterOnLatestRevisionFault) ErrorCode() string

func (*ClusterOnLatestRevisionFault) ErrorFault 

func (e *ClusterOnLatestRevisionFault) ErrorFault() smithy.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 (e *ClusterParameterGroupAlreadyExistsFault) Error() string

func (*ClusterParameterGroupAlreadyExistsFault) ErrorCode 

func (e *ClusterParameterGroupAlreadyExistsFault) ErrorCode() string

func (*ClusterParameterGroupAlreadyExistsFault) ErrorFault 

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

func (*ClusterParameterGroupAlreadyExistsFault) ErrorMessage 

func (e *ClusterParameterGroupAlreadyExistsFault) ErrorMessage() string

type ClusterParameterGroupNotFoundFault 

type ClusterParameterGroupNotFoundFault struct {
	Message *string
}

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

func (*ClusterParameterGroupNotFoundFault) Error 

func (e *ClusterParameterGroupNotFoundFault) Error() string

func (*ClusterParameterGroupNotFoundFault) ErrorCode 

func (e *ClusterParameterGroupNotFoundFault) ErrorCode() string

func (*ClusterParameterGroupNotFoundFault) ErrorFault 

func (e *ClusterParameterGroupNotFoundFault) ErrorFault() smithy.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 (e *ClusterParameterGroupQuotaExceededFault) Error() string

func (*ClusterParameterGroupQuotaExceededFault) ErrorCode 

func (e *ClusterParameterGroupQuotaExceededFault) ErrorCode() string

func (*ClusterParameterGroupQuotaExceededFault) ErrorFault 

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

func (*ClusterParameterGroupQuotaExceededFault) ErrorMessage 

func (e *ClusterParameterGroupQuotaExceededFault) ErrorMessage() string

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 (e *ClusterQuotaExceededFault) ErrorFault() smithy.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 (e *ClusterSecurityGroupAlreadyExistsFault) Error() string

func (*ClusterSecurityGroupAlreadyExistsFault) ErrorCode 

func (e *ClusterSecurityGroupAlreadyExistsFault) ErrorCode() string

func (*ClusterSecurityGroupAlreadyExistsFault) ErrorFault 

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

func (*ClusterSecurityGroupAlreadyExistsFault) ErrorMessage 

func (e *ClusterSecurityGroupAlreadyExistsFault) ErrorMessage() string

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 (e *ClusterSecurityGroupNotFoundFault) Error() string

func (*ClusterSecurityGroupNotFoundFault) ErrorCode 

func (e *ClusterSecurityGroupNotFoundFault) ErrorCode() string

func (*ClusterSecurityGroupNotFoundFault) ErrorFault 

func (e *ClusterSecurityGroupNotFoundFault) ErrorFault() smithy.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 (e *ClusterSecurityGroupQuotaExceededFault) Error() string

func (*ClusterSecurityGroupQuotaExceededFault) ErrorCode 

func (e *ClusterSecurityGroupQuotaExceededFault) ErrorCode() string

func (*ClusterSecurityGroupQuotaExceededFault) ErrorFault 

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

func (*ClusterSecurityGroupQuotaExceededFault) ErrorMessage 

func (e *ClusterSecurityGroupQuotaExceededFault) ErrorMessage() string

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 (e *ClusterSnapshotAlreadyExistsFault) Error() string

func (*ClusterSnapshotAlreadyExistsFault) ErrorCode 

func (e *ClusterSnapshotAlreadyExistsFault) ErrorCode() string

func (*ClusterSnapshotAlreadyExistsFault) ErrorFault 

func (e *ClusterSnapshotAlreadyExistsFault) ErrorFault() smithy.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 (e *ClusterSnapshotNotFoundFault) Error() string

func (*ClusterSnapshotNotFoundFault) ErrorCode 

func (e *ClusterSnapshotNotFoundFault) ErrorCode() string

func (*ClusterSnapshotNotFoundFault) ErrorFault 

func (e *ClusterSnapshotNotFoundFault) ErrorFault() smithy.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 (e *ClusterSnapshotQuotaExceededFault) Error() string

func (*ClusterSnapshotQuotaExceededFault) ErrorCode 

func (e *ClusterSnapshotQuotaExceededFault) ErrorCode() string

func (*ClusterSnapshotQuotaExceededFault) ErrorFault 

func (e *ClusterSnapshotQuotaExceededFault) ErrorFault() smithy.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 (e *ClusterSubnetGroupAlreadyExistsFault) Error() string

func (*ClusterSubnetGroupAlreadyExistsFault) ErrorCode 

func (e *ClusterSubnetGroupAlreadyExistsFault) ErrorCode() string

func (*ClusterSubnetGroupAlreadyExistsFault) ErrorFault 

func (e *ClusterSubnetGroupAlreadyExistsFault) ErrorFault() smithy.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 (e *ClusterSubnetGroupNotFoundFault) Error() string

func (*ClusterSubnetGroupNotFoundFault) ErrorCode 

func (e *ClusterSubnetGroupNotFoundFault) ErrorCode() string

func (*ClusterSubnetGroupNotFoundFault) ErrorFault 

func (e *ClusterSubnetGroupNotFoundFault) ErrorFault() smithy.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 (e *ClusterSubnetGroupQuotaExceededFault) Error() string

func (*ClusterSubnetGroupQuotaExceededFault) ErrorCode 

func (e *ClusterSubnetGroupQuotaExceededFault) ErrorCode() string

func (*ClusterSubnetGroupQuotaExceededFault) ErrorFault 

func (e *ClusterSubnetGroupQuotaExceededFault) ErrorFault() smithy.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 (e *ClusterSubnetQuotaExceededFault) Error() string

func (*ClusterSubnetQuotaExceededFault) ErrorCode 

func (e *ClusterSubnetQuotaExceededFault) ErrorCode() string

func (*ClusterSubnetQuotaExceededFault) ErrorFault 

func (e *ClusterSubnetQuotaExceededFault) ErrorFault() smithy.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 (e *CopyToRegionDisabledFault) ErrorFault() smithy.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 (e *DependentServiceRequestThrottlingFault) Error() string

func (*DependentServiceRequestThrottlingFault) ErrorCode 

func (e *DependentServiceRequestThrottlingFault) ErrorCode() string

func (*DependentServiceRequestThrottlingFault) ErrorFault 

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

func (*DependentServiceRequestThrottlingFault) ErrorMessage 

func (e *DependentServiceRequestThrottlingFault) ErrorMessage() string

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 (e *DependentServiceUnavailableFault) Error() string

func (*DependentServiceUnavailableFault) ErrorCode 

func (e *DependentServiceUnavailableFault) ErrorCode() string

func (*DependentServiceUnavailableFault) ErrorFault 

func (e *DependentServiceUnavailableFault) ErrorFault() smithy.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 (e *EventSubscriptionQuotaExceededFault) Error() string

func (*EventSubscriptionQuotaExceededFault) ErrorCode 

func (e *EventSubscriptionQuotaExceededFault) ErrorCode() string

func (*EventSubscriptionQuotaExceededFault) ErrorFault 

func (e *EventSubscriptionQuotaExceededFault) ErrorFault() smithy.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 (e *HsmClientCertificateAlreadyExistsFault) Error() string

func (*HsmClientCertificateAlreadyExistsFault) ErrorCode 

func (e *HsmClientCertificateAlreadyExistsFault) ErrorCode() string

func (*HsmClientCertificateAlreadyExistsFault) ErrorFault 

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

func (*HsmClientCertificateAlreadyExistsFault) ErrorMessage 

func (e *HsmClientCertificateAlreadyExistsFault) ErrorMessage() string

type HsmClientCertificateNotFoundFault 

type HsmClientCertificateNotFoundFault struct {
	Message *string
}

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

func (*HsmClientCertificateNotFoundFault) Error 

func (e *HsmClientCertificateNotFoundFault) Error() string

func (*HsmClientCertificateNotFoundFault) ErrorCode 

func (e *HsmClientCertificateNotFoundFault) ErrorCode() string

func (*HsmClientCertificateNotFoundFault) ErrorFault 

func (e *HsmClientCertificateNotFoundFault) ErrorFault() smithy.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 (e *HsmClientCertificateQuotaExceededFault) Error() string

func (*HsmClientCertificateQuotaExceededFault) ErrorCode 

func (e *HsmClientCertificateQuotaExceededFault) ErrorCode() string

func (*HsmClientCertificateQuotaExceededFault) ErrorFault 

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

func (*HsmClientCertificateQuotaExceededFault) ErrorMessage 

func (e *HsmClientCertificateQuotaExceededFault) ErrorMessage() string

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 (e *HsmConfigurationAlreadyExistsFault) Error() string

func (*HsmConfigurationAlreadyExistsFault) ErrorCode 

func (e *HsmConfigurationAlreadyExistsFault) ErrorCode() string

func (*HsmConfigurationAlreadyExistsFault) ErrorFault 

func (e *HsmConfigurationAlreadyExistsFault) ErrorFault() smithy.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 (e *HsmConfigurationNotFoundFault) Error() string

func (*HsmConfigurationNotFoundFault) ErrorCode 

func (e *HsmConfigurationNotFoundFault) ErrorCode() string

func (*HsmConfigurationNotFoundFault) ErrorFault 

func (e *HsmConfigurationNotFoundFault) ErrorFault() smithy.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 (e *HsmConfigurationQuotaExceededFault) Error() string

func (*HsmConfigurationQuotaExceededFault) ErrorCode 

func (e *HsmConfigurationQuotaExceededFault) ErrorCode() string

func (*HsmConfigurationQuotaExceededFault) ErrorFault 

func (e *HsmConfigurationQuotaExceededFault) ErrorFault() smithy.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 (e *InProgressTableRestoreQuotaExceededFault) Error() string

func (*InProgressTableRestoreQuotaExceededFault) ErrorCode 

func (e *InProgressTableRestoreQuotaExceededFault) ErrorCode() string

func (*InProgressTableRestoreQuotaExceededFault) ErrorFault 

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

func (*InProgressTableRestoreQuotaExceededFault) ErrorMessage 

func (e *InProgressTableRestoreQuotaExceededFault) ErrorMessage() string

type IncompatibleOrderableOptions 

type IncompatibleOrderableOptions struct {
	Message *string
}

The specified options are incompatible.

func (*IncompatibleOrderableOptions) Error 

func (e *IncompatibleOrderableOptions) Error() string

func (*IncompatibleOrderableOptions) ErrorCode 

func (e *IncompatibleOrderableOptions) ErrorCode() string

func (*IncompatibleOrderableOptions) ErrorFault 

func (e *IncompatibleOrderableOptions) ErrorFault() smithy.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 (e *InsufficientClusterCapacityFault) Error() string

func (*InsufficientClusterCapacityFault) ErrorCode 

func (e *InsufficientClusterCapacityFault) ErrorCode() string

func (*InsufficientClusterCapacityFault) ErrorFault 

func (e *InsufficientClusterCapacityFault) ErrorFault() smithy.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 (e *InsufficientS3BucketPolicyFault) Error() string

func (*InsufficientS3BucketPolicyFault) ErrorCode 

func (e *InsufficientS3BucketPolicyFault) ErrorCode() string

func (*InsufficientS3BucketPolicyFault) ErrorFault 

func (e *InsufficientS3BucketPolicyFault) ErrorFault() smithy.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 (e *InvalidClusterParameterGroupStateFault) Error() string

func (*InvalidClusterParameterGroupStateFault) ErrorCode 

func (e *InvalidClusterParameterGroupStateFault) ErrorCode() string

func (*InvalidClusterParameterGroupStateFault) ErrorFault 

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

func (*InvalidClusterParameterGroupStateFault) ErrorMessage 

func (e *InvalidClusterParameterGroupStateFault) ErrorMessage() string

type InvalidClusterSecurityGroupStateFault 

type InvalidClusterSecurityGroupStateFault struct {
	Message *string
}

The state of the cluster security group is not available.

func (*InvalidClusterSecurityGroupStateFault) Error 

func (e *InvalidClusterSecurityGroupStateFault) Error() string

func (*InvalidClusterSecurityGroupStateFault) ErrorCode 

func (e *InvalidClusterSecurityGroupStateFault) ErrorCode() string

func (*InvalidClusterSecurityGroupStateFault) ErrorFault 

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

func (*InvalidClusterSecurityGroupStateFault) ErrorMessage 

func (e *InvalidClusterSecurityGroupStateFault) ErrorMessage() string

type InvalidClusterSnapshotScheduleStateFault 

type InvalidClusterSnapshotScheduleStateFault struct {
	Message *string
}

The cluster snapshot schedule state is not valid.

func (*InvalidClusterSnapshotScheduleStateFault) Error 

func (e *InvalidClusterSnapshotScheduleStateFault) Error() string

func (*InvalidClusterSnapshotScheduleStateFault) ErrorCode 

func (e *InvalidClusterSnapshotScheduleStateFault) ErrorCode() string

func (*InvalidClusterSnapshotScheduleStateFault) ErrorFault 

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

func (*InvalidClusterSnapshotScheduleStateFault) ErrorMessage 

func (e *InvalidClusterSnapshotScheduleStateFault) ErrorMessage() string

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 (e *InvalidClusterSnapshotStateFault) Error() string

func (*InvalidClusterSnapshotStateFault) ErrorCode 

func (e *InvalidClusterSnapshotStateFault) ErrorCode() string

func (*InvalidClusterSnapshotStateFault) ErrorFault 

func (e *InvalidClusterSnapshotStateFault) ErrorFault() smithy.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 (e *InvalidClusterSubnetGroupStateFault) Error() string

func (*InvalidClusterSubnetGroupStateFault) ErrorCode 

func (e *InvalidClusterSubnetGroupStateFault) ErrorCode() string

func (*InvalidClusterSubnetGroupStateFault) ErrorFault 

func (e *InvalidClusterSubnetGroupStateFault) ErrorFault() smithy.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 (e *InvalidClusterSubnetStateFault) Error() string

func (*InvalidClusterSubnetStateFault) ErrorCode 

func (e *InvalidClusterSubnetStateFault) ErrorCode() string

func (*InvalidClusterSubnetStateFault) ErrorFault 

func (e *InvalidClusterSubnetStateFault) ErrorFault() smithy.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 (e *InvalidHsmClientCertificateStateFault) Error() string

func (*InvalidHsmClientCertificateStateFault) ErrorCode 

func (e *InvalidHsmClientCertificateStateFault) ErrorCode() string

func (*InvalidHsmClientCertificateStateFault) ErrorFault 

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

func (*InvalidHsmClientCertificateStateFault) ErrorMessage 

func (e *InvalidHsmClientCertificateStateFault) ErrorMessage() string

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 (e *InvalidHsmConfigurationStateFault) Error() string

func (*InvalidHsmConfigurationStateFault) ErrorCode 

func (e *InvalidHsmConfigurationStateFault) ErrorCode() string

func (*InvalidHsmConfigurationStateFault) ErrorFault 

func (e *InvalidHsmConfigurationStateFault) ErrorFault() smithy.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 (e *InvalidReservedNodeStateFault) Error() string

func (*InvalidReservedNodeStateFault) ErrorCode 

func (e *InvalidReservedNodeStateFault) ErrorCode() string

func (*InvalidReservedNodeStateFault) ErrorFault 

func (e *InvalidReservedNodeStateFault) ErrorFault() smithy.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 (e *InvalidRetentionPeriodFault) Error() string

func (*InvalidRetentionPeriodFault) ErrorCode 

func (e *InvalidRetentionPeriodFault) ErrorCode() string

func (*InvalidRetentionPeriodFault) ErrorFault 

func (e *InvalidRetentionPeriodFault) ErrorFault() smithy.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 (e *InvalidScheduledActionFault) Error() string

func (*InvalidScheduledActionFault) ErrorCode 

func (e *InvalidScheduledActionFault) ErrorCode() string

func (*InvalidScheduledActionFault) ErrorFault 

func (e *InvalidScheduledActionFault) ErrorFault() smithy.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 (e *InvalidSnapshotCopyGrantStateFault) Error() string

func (*InvalidSnapshotCopyGrantStateFault) ErrorCode 

func (e *InvalidSnapshotCopyGrantStateFault) ErrorCode() string

func (*InvalidSnapshotCopyGrantStateFault) ErrorFault 

func (e *InvalidSnapshotCopyGrantStateFault) ErrorFault() smithy.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 (e *InvalidSubscriptionStateFault) Error() string

func (*InvalidSubscriptionStateFault) ErrorCode 

func (e *InvalidSubscriptionStateFault) ErrorCode() string

func (*InvalidSubscriptionStateFault) ErrorFault 

func (e *InvalidSubscriptionStateFault) ErrorFault() smithy.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 (e *InvalidTableRestoreArgumentFault) Error() string

func (*InvalidTableRestoreArgumentFault) ErrorCode 

func (e *InvalidTableRestoreArgumentFault) ErrorCode() string

func (*InvalidTableRestoreArgumentFault) ErrorFault 

func (e *InvalidTableRestoreArgumentFault) ErrorFault() smithy.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 (e *InvalidVPCNetworkStateFault) Error() string

func (*InvalidVPCNetworkStateFault) ErrorCode 

func (e *InvalidVPCNetworkStateFault) ErrorCode() string

func (*InvalidVPCNetworkStateFault) ErrorFault 

func (e *InvalidVPCNetworkStateFault) ErrorFault() smithy.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 added in v0.29.0 

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 added in v0.29.0 

func (NodeConfigurationOptionsFilterName) Values() []NodeConfigurationOptionsFilterName

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 (e *NumberOfNodesPerClusterLimitExceededFault) Error() string

func (*NumberOfNodesPerClusterLimitExceededFault) ErrorCode 

func (e *NumberOfNodesPerClusterLimitExceededFault) ErrorCode() string

func (*NumberOfNodesPerClusterLimitExceededFault) ErrorFault 

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

func (*NumberOfNodesPerClusterLimitExceededFault) ErrorMessage 

func (e *NumberOfNodesPerClusterLimitExceededFault) ErrorMessage() string

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 (e *NumberOfNodesQuotaExceededFault) Error() string

func (*NumberOfNodesQuotaExceededFault) ErrorCode 

func (e *NumberOfNodesQuotaExceededFault) ErrorCode() string

func (*NumberOfNodesQuotaExceededFault) ErrorFault 

func (e *NumberOfNodesQuotaExceededFault) ErrorFault() smithy.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 added in v0.29.0 

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 added in v0.29.0 

func (ParameterApplyType) Values() []ParameterApplyType

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 (e *ReservedNodeAlreadyExistsFault) Error() string

func (*ReservedNodeAlreadyExistsFault) ErrorCode 

func (e *ReservedNodeAlreadyExistsFault) ErrorCode() string

func (*ReservedNodeAlreadyExistsFault) ErrorFault 

func (e *ReservedNodeAlreadyExistsFault) ErrorFault() smithy.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 (e *ReservedNodeAlreadyMigratedFault) Error() string

func (*ReservedNodeAlreadyMigratedFault) ErrorCode 

func (e *ReservedNodeAlreadyMigratedFault) ErrorCode() string

func (*ReservedNodeAlreadyMigratedFault) ErrorFault 

func (e *ReservedNodeAlreadyMigratedFault) ErrorFault() smithy.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 (e *ReservedNodeNotFoundFault) ErrorFault() smithy.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 (e *ReservedNodeOfferingNotFoundFault) Error() string

func (*ReservedNodeOfferingNotFoundFault) ErrorCode 

func (e *ReservedNodeOfferingNotFoundFault) ErrorCode() string

func (*ReservedNodeOfferingNotFoundFault) ErrorFault 

func (e *ReservedNodeOfferingNotFoundFault) ErrorFault() smithy.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 added in v0.29.0 

func (ReservedNodeOfferingType) Values() []ReservedNodeOfferingType

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 (e *ReservedNodeQuotaExceededFault) Error() string

func (*ReservedNodeQuotaExceededFault) ErrorCode 

func (e *ReservedNodeQuotaExceededFault) ErrorCode() string

func (*ReservedNodeQuotaExceededFault) ErrorFault 

func (e *ReservedNodeQuotaExceededFault) ErrorFault() smithy.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 (e *ScheduleDefinitionTypeUnsupportedFault) Error() string

func (*ScheduleDefinitionTypeUnsupportedFault) ErrorCode 

func (e *ScheduleDefinitionTypeUnsupportedFault) ErrorCode() string

func (*ScheduleDefinitionTypeUnsupportedFault) ErrorFault 

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

func (*ScheduleDefinitionTypeUnsupportedFault) ErrorMessage 

func (e *ScheduleDefinitionTypeUnsupportedFault) ErrorMessage() string

type ScheduleState 

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

Enum values for ScheduleState

func (ScheduleState) Values added in v0.29.0 

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 (e *ScheduledActionAlreadyExistsFault) Error() string

func (*ScheduledActionAlreadyExistsFault) ErrorCode 

func (e *ScheduledActionAlreadyExistsFault) ErrorCode() string

func (*ScheduledActionAlreadyExistsFault) ErrorFault 

func (e *ScheduledActionAlreadyExistsFault) ErrorFault() smithy.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 added in v0.29.0 

func (ScheduledActionFilterName) Values() []ScheduledActionFilterName

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 (e *ScheduledActionNotFoundFault) Error() string

func (*ScheduledActionNotFoundFault) ErrorCode 

func (e *ScheduledActionNotFoundFault) ErrorCode() string

func (*ScheduledActionNotFoundFault) ErrorFault 

func (e *ScheduledActionNotFoundFault) ErrorFault() smithy.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 (e *ScheduledActionQuotaExceededFault) Error() string

func (*ScheduledActionQuotaExceededFault) ErrorCode 

func (e *ScheduledActionQuotaExceededFault) ErrorCode() string

func (*ScheduledActionQuotaExceededFault) ErrorFault 

func (e *ScheduledActionQuotaExceededFault) ErrorFault() smithy.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 added in v0.29.0 

func (ScheduledActionState) Values() []ScheduledActionState

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 (e *ScheduledActionTypeUnsupportedFault) Error() string

func (*ScheduledActionTypeUnsupportedFault) ErrorCode 

func (e *ScheduledActionTypeUnsupportedFault) ErrorCode() string

func (*ScheduledActionTypeUnsupportedFault) ErrorFault 

func (e *ScheduledActionTypeUnsupportedFault) ErrorFault() smithy.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 added in v0.29.0 

func (ScheduledActionTypeValues) Values() []ScheduledActionTypeValues

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 added in v0.29.0 

func (SnapshotAttributeToSortBy) Values() []SnapshotAttributeToSortBy

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 (e *SnapshotCopyAlreadyDisabledFault) Error() string

func (*SnapshotCopyAlreadyDisabledFault) ErrorCode 

func (e *SnapshotCopyAlreadyDisabledFault) ErrorCode() string

func (*SnapshotCopyAlreadyDisabledFault) ErrorFault 

func (e *SnapshotCopyAlreadyDisabledFault) ErrorFault() smithy.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 (e *SnapshotCopyAlreadyEnabledFault) Error() string

func (*SnapshotCopyAlreadyEnabledFault) ErrorCode 

func (e *SnapshotCopyAlreadyEnabledFault) ErrorCode() string

func (*SnapshotCopyAlreadyEnabledFault) ErrorFault 

func (e *SnapshotCopyAlreadyEnabledFault) ErrorFault() smithy.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 (e *SnapshotCopyDisabledFault) ErrorFault() smithy.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 (e *SnapshotCopyGrantAlreadyExistsFault) Error() string

func (*SnapshotCopyGrantAlreadyExistsFault) ErrorCode 

func (e *SnapshotCopyGrantAlreadyExistsFault) ErrorCode() string

func (*SnapshotCopyGrantAlreadyExistsFault) ErrorFault 

func (e *SnapshotCopyGrantAlreadyExistsFault) ErrorFault() smithy.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 (e *SnapshotCopyGrantNotFoundFault) Error() string

func (*SnapshotCopyGrantNotFoundFault) ErrorCode 

func (e *SnapshotCopyGrantNotFoundFault) ErrorCode() string

func (*SnapshotCopyGrantNotFoundFault) ErrorFault 

func (e *SnapshotCopyGrantNotFoundFault) ErrorFault() smithy.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 (e *SnapshotCopyGrantQuotaExceededFault) Error() string

func (*SnapshotCopyGrantQuotaExceededFault) ErrorCode 

func (e *SnapshotCopyGrantQuotaExceededFault) ErrorCode() string

func (*SnapshotCopyGrantQuotaExceededFault) ErrorFault 

func (e *SnapshotCopyGrantQuotaExceededFault) ErrorFault() smithy.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 (e *SnapshotScheduleAlreadyExistsFault) Error() string

func (*SnapshotScheduleAlreadyExistsFault) ErrorCode 

func (e *SnapshotScheduleAlreadyExistsFault) ErrorCode() string

func (*SnapshotScheduleAlreadyExistsFault) ErrorFault 

func (e *SnapshotScheduleAlreadyExistsFault) ErrorFault() smithy.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 (e *SnapshotScheduleNotFoundFault) Error() string

func (*SnapshotScheduleNotFoundFault) ErrorCode 

func (e *SnapshotScheduleNotFoundFault) ErrorCode() string

func (*SnapshotScheduleNotFoundFault) ErrorFault 

func (e *SnapshotScheduleNotFoundFault) ErrorFault() smithy.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 (e *SnapshotScheduleQuotaExceededFault) Error() string

func (*SnapshotScheduleQuotaExceededFault) ErrorCode 

func (e *SnapshotScheduleQuotaExceededFault) ErrorCode() string

func (*SnapshotScheduleQuotaExceededFault) ErrorFault 

func (e *SnapshotScheduleQuotaExceededFault) ErrorFault() smithy.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 (e *SnapshotScheduleUpdateInProgressFault) Error() string

func (*SnapshotScheduleUpdateInProgressFault) ErrorCode 

func (e *SnapshotScheduleUpdateInProgressFault) ErrorCode() string

func (*SnapshotScheduleUpdateInProgressFault) ErrorFault 

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

func (*SnapshotScheduleUpdateInProgressFault) ErrorMessage 

func (e *SnapshotScheduleUpdateInProgressFault) ErrorMessage() string

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 added in v0.29.0 

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 added in v0.29.0 

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 added in v0.31.0 

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 (e *SubscriptionAlreadyExistFault) Error() string

func (*SubscriptionAlreadyExistFault) ErrorCode 

func (e *SubscriptionAlreadyExistFault) ErrorCode() string

func (*SubscriptionAlreadyExistFault) ErrorFault 

func (e *SubscriptionAlreadyExistFault) ErrorFault() smithy.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 (e *SubscriptionCategoryNotFoundFault) Error() string

func (*SubscriptionCategoryNotFoundFault) ErrorCode 

func (e *SubscriptionCategoryNotFoundFault) ErrorCode() string

func (*SubscriptionCategoryNotFoundFault) ErrorFault 

func (e *SubscriptionCategoryNotFoundFault) ErrorFault() smithy.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 (e *SubscriptionEventIdNotFoundFault) Error() string

func (*SubscriptionEventIdNotFoundFault) ErrorCode 

func (e *SubscriptionEventIdNotFoundFault) ErrorCode() string

func (*SubscriptionEventIdNotFoundFault) ErrorFault 

func (e *SubscriptionEventIdNotFoundFault) ErrorFault() smithy.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 (e *SubscriptionNotFoundFault) ErrorFault() smithy.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 (e *SubscriptionSeverityNotFoundFault) Error() string

func (*SubscriptionSeverityNotFoundFault) ErrorCode 

func (e *SubscriptionSeverityNotFoundFault) ErrorCode() string

func (*SubscriptionSeverityNotFoundFault) ErrorFault 

func (e *SubscriptionSeverityNotFoundFault) ErrorFault() smithy.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 (e *TableRestoreNotFoundFault) ErrorFault() smithy.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 added in v0.29.0 

func (TableRestoreStatusType) Values() []TableRestoreStatusType

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 (e *UnknownSnapshotCopyRegionFault) Error() string

func (*UnknownSnapshotCopyRegionFault) ErrorCode 

func (e *UnknownSnapshotCopyRegionFault) ErrorCode() string

func (*UnknownSnapshotCopyRegionFault) ErrorFault 

func (e *UnknownSnapshotCopyRegionFault) ErrorFault() smithy.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 (e *UnsupportedOperationFault) ErrorFault() smithy.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 (e *UsageLimitAlreadyExistsFault) Error() string

func (*UsageLimitAlreadyExistsFault) ErrorCode 

func (e *UsageLimitAlreadyExistsFault) ErrorCode() string

func (*UsageLimitAlreadyExistsFault) ErrorFault 

func (e *UsageLimitAlreadyExistsFault) ErrorFault() smithy.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 added in v0.29.0 

func (UsageLimitBreachAction) Values() []UsageLimitBreachAction

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 added in v0.29.0 

func (UsageLimitFeatureType) Values() []UsageLimitFeatureType

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 added in v0.29.0 

func (UsageLimitLimitType) Values() []UsageLimitLimitType

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 added in v0.29.0 

func (UsageLimitPeriod) Values() []UsageLimitPeriod

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.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.