Module aws_sdk_redshift::model

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.

HsmConfiguration

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.

HsmStatus

Describes the status of changes to HSM settings.

IpRange

Describes an IP range used in a security group.

MaintenanceTrack

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.

NetworkInterface

Describes a network interface.

NodeConfigurationOption

A list of node configurations.

NodeConfigurationOptionsFilter

A set of elements to filter the returned node configurations.

OrderableClusterOption

Describes an orderable cluster option.

Parameter

Describes a parameter in a cluster parameter group.

PartnerIntegrationInfo

Describes a partner integration.

PauseClusterMessage

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

PendingModifiedValues

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.

RecurringCharge

Describes a recurring charge.

ReservedNode

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

ReservedNodeConfigurationOption

Details for a reserved-node exchange. Examples include the node type for a reserved node, the price for a node, the node's state, and other details.

ReservedNodeExchangeStatus

Reserved-node status details, such as the source reserved-node identifier, the target reserved-node identifier, the node type, the node count, and other details.

ReservedNodeOffering

Describes a reserved node offering.

ResizeClusterMessage

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

ResizeInfo

Describes a resize operation.

RestoreStatus

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

ResumeClusterMessage

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

RevisionTarget

Describes a RevisionTarget.

ScheduledAction

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.

ScheduledActionFilter

A set of elements to filter the returned scheduled actions.

ScheduledActionType

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

Snapshot

Describes a snapshot.

SnapshotCopyGrant

The snapshot copy grant that grants Amazon Redshift permission to encrypt copied snapshots with the specified encrypted symmetric key from Amazon Web Services KMS in the destination region.

SnapshotErrorMessage

Describes the errors returned by a snapshot.

SnapshotSchedule

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

SnapshotSortingEntity

Describes a sorting entity

Subnet

Describes a subnet.

SupportedOperation

Describes the operations that are allowed on a maintenance track.

SupportedPlatform

A list of supported platforms for orderable clusters.

TableRestoreStatus

Describes the status of a RestoreTableFromClusterSnapshot operation.

Tag

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

TaggedResource

A tag and its associated resource.

UpdateTarget

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

UsageLimit

Describes a usage limit object for a cluster.

VpcEndpoint

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

VpcSecurityGroupMembership

Describes the members of a VPC security group.

Enums

ActionType

When writing a match expression against ActionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AquaConfigurationStatus

When writing a match expression against AquaConfigurationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AquaStatus

When writing a match expression against AquaStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AuthorizationStatus

When writing a match expression against AuthorizationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DataShareStatus

When writing a match expression against DataShareStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DataShareStatusForConsumer

When writing a match expression against DataShareStatusForConsumer, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

DataShareStatusForProducer

When writing a match expression against DataShareStatusForProducer, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LogDestinationType

When writing a match expression against LogDestinationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Mode

When writing a match expression against Mode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

NodeConfigurationOptionsFilterName

When writing a match expression against NodeConfigurationOptionsFilterName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

OperatorType

When writing a match expression against OperatorType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ParameterApplyType

When writing a match expression against ParameterApplyType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

PartnerIntegrationStatus

When writing a match expression against PartnerIntegrationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ReservedNodeExchangeActionType

When writing a match expression against ReservedNodeExchangeActionType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ReservedNodeExchangeStatusType

When writing a match expression against ReservedNodeExchangeStatusType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ReservedNodeOfferingType

When writing a match expression against ReservedNodeOfferingType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ScheduleState

When writing a match expression against ScheduleState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ScheduledActionFilterName

When writing a match expression against ScheduledActionFilterName, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ScheduledActionState

When writing a match expression against ScheduledActionState, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ScheduledActionTypeValues

When writing a match expression against ScheduledActionTypeValues, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SnapshotAttributeToSortBy

When writing a match expression against SnapshotAttributeToSortBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SortByOrder

When writing a match expression against SortByOrder, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SourceType

When writing a match expression against SourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TableRestoreStatusType

When writing a match expression against TableRestoreStatusType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

UsageLimitBreachAction

When writing a match expression against UsageLimitBreachAction, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

UsageLimitFeatureType

When writing a match expression against UsageLimitFeatureType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

UsageLimitLimitType

When writing a match expression against UsageLimitLimitType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

UsageLimitPeriod

When writing a match expression against UsageLimitPeriod, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.