// Code generated by smithy-go-codegen DO NOT EDIT.

package types

type ApproximateCreationDateTimePrecision string

// Enum values for ApproximateCreationDateTimePrecision
const (
	ApproximateCreationDateTimePrecisionMillisecond ApproximateCreationDateTimePrecision = "MILLISECOND"
	ApproximateCreationDateTimePrecisionMicrosecond ApproximateCreationDateTimePrecision = "MICROSECOND"
)

// Values returns all known values for ApproximateCreationDateTimePrecision. 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.
func (ApproximateCreationDateTimePrecision) Values() []ApproximateCreationDateTimePrecision {
	return []ApproximateCreationDateTimePrecision{
		"MILLISECOND",
		"MICROSECOND",
	}
}

type AttributeAction string

// Enum values for AttributeAction
const (
	AttributeActionAdd    AttributeAction = "ADD"
	AttributeActionPut    AttributeAction = "PUT"
	AttributeActionDelete AttributeAction = "DELETE"
)

// Values returns all known values for AttributeAction. 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.
func (AttributeAction) Values() []AttributeAction {
	return []AttributeAction{
		"ADD",
		"PUT",
		"DELETE",
	}
}

type BackupStatus string

// Enum values for BackupStatus
const (
	BackupStatusCreating  BackupStatus = "CREATING"
	BackupStatusDeleted   BackupStatus = "DELETED"
	BackupStatusAvailable BackupStatus = "AVAILABLE"
)

// Values returns all known values for BackupStatus. 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.
func (BackupStatus) Values() []BackupStatus {
	return []BackupStatus{
		"CREATING",
		"DELETED",
		"AVAILABLE",
	}
}

type BackupType string

// Enum values for BackupType
const (
	BackupTypeUser      BackupType = "USER"
	BackupTypeSystem    BackupType = "SYSTEM"
	BackupTypeAwsBackup BackupType = "AWS_BACKUP"
)

// Values returns all known values for BackupType. 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.
func (BackupType) Values() []BackupType {
	return []BackupType{
		"USER",
		"SYSTEM",
		"AWS_BACKUP",
	}
}

type BackupTypeFilter string

// Enum values for BackupTypeFilter
const (
	BackupTypeFilterUser      BackupTypeFilter = "USER"
	BackupTypeFilterSystem    BackupTypeFilter = "SYSTEM"
	BackupTypeFilterAwsBackup BackupTypeFilter = "AWS_BACKUP"
	BackupTypeFilterAll       BackupTypeFilter = "ALL"
)

// Values returns all known values for BackupTypeFilter. 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.
func (BackupTypeFilter) Values() []BackupTypeFilter {
	return []BackupTypeFilter{
		"USER",
		"SYSTEM",
		"AWS_BACKUP",
		"ALL",
	}
}

type BatchStatementErrorCodeEnum string

// Enum values for BatchStatementErrorCodeEnum
const (
	BatchStatementErrorCodeEnumConditionalCheckFailed          BatchStatementErrorCodeEnum = "ConditionalCheckFailed"
	BatchStatementErrorCodeEnumItemCollectionSizeLimitExceeded BatchStatementErrorCodeEnum = "ItemCollectionSizeLimitExceeded"
	BatchStatementErrorCodeEnumRequestLimitExceeded            BatchStatementErrorCodeEnum = "RequestLimitExceeded"
	BatchStatementErrorCodeEnumValidationError                 BatchStatementErrorCodeEnum = "ValidationError"
	BatchStatementErrorCodeEnumProvisionedThroughputExceeded   BatchStatementErrorCodeEnum = "ProvisionedThroughputExceeded"
	BatchStatementErrorCodeEnumTransactionConflict             BatchStatementErrorCodeEnum = "TransactionConflict"
	BatchStatementErrorCodeEnumThrottlingError                 BatchStatementErrorCodeEnum = "ThrottlingError"
	BatchStatementErrorCodeEnumInternalServerError             BatchStatementErrorCodeEnum = "InternalServerError"
	BatchStatementErrorCodeEnumResourceNotFound                BatchStatementErrorCodeEnum = "ResourceNotFound"
	BatchStatementErrorCodeEnumAccessDenied                    BatchStatementErrorCodeEnum = "AccessDenied"
	BatchStatementErrorCodeEnumDuplicateItem                   BatchStatementErrorCodeEnum = "DuplicateItem"
)

// Values returns all known values for BatchStatementErrorCodeEnum. 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.
func (BatchStatementErrorCodeEnum) Values() []BatchStatementErrorCodeEnum {
	return []BatchStatementErrorCodeEnum{
		"ConditionalCheckFailed",
		"ItemCollectionSizeLimitExceeded",
		"RequestLimitExceeded",
		"ValidationError",
		"ProvisionedThroughputExceeded",
		"TransactionConflict",
		"ThrottlingError",
		"InternalServerError",
		"ResourceNotFound",
		"AccessDenied",
		"DuplicateItem",
	}
}

type BillingMode string

// Enum values for BillingMode
const (
	BillingModeProvisioned   BillingMode = "PROVISIONED"
	BillingModePayPerRequest BillingMode = "PAY_PER_REQUEST"
)

// Values returns all known values for BillingMode. 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.
func (BillingMode) Values() []BillingMode {
	return []BillingMode{
		"PROVISIONED",
		"PAY_PER_REQUEST",
	}
}

type ComparisonOperator string

// Enum values for ComparisonOperator
const (
	ComparisonOperatorEq          ComparisonOperator = "EQ"
	ComparisonOperatorNe          ComparisonOperator = "NE"
	ComparisonOperatorIn          ComparisonOperator = "IN"
	ComparisonOperatorLe          ComparisonOperator = "LE"
	ComparisonOperatorLt          ComparisonOperator = "LT"
	ComparisonOperatorGe          ComparisonOperator = "GE"
	ComparisonOperatorGt          ComparisonOperator = "GT"
	ComparisonOperatorBetween     ComparisonOperator = "BETWEEN"
	ComparisonOperatorNotNull     ComparisonOperator = "NOT_NULL"
	ComparisonOperatorNull        ComparisonOperator = "NULL"
	ComparisonOperatorContains    ComparisonOperator = "CONTAINS"
	ComparisonOperatorNotContains ComparisonOperator = "NOT_CONTAINS"
	ComparisonOperatorBeginsWith  ComparisonOperator = "BEGINS_WITH"
)

// Values returns all known values for ComparisonOperator. 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.
func (ComparisonOperator) Values() []ComparisonOperator {
	return []ComparisonOperator{
		"EQ",
		"NE",
		"IN",
		"LE",
		"LT",
		"GE",
		"GT",
		"BETWEEN",
		"NOT_NULL",
		"NULL",
		"CONTAINS",
		"NOT_CONTAINS",
		"BEGINS_WITH",
	}
}

type ConditionalOperator string

// Enum values for ConditionalOperator
const (
	ConditionalOperatorAnd ConditionalOperator = "AND"
	ConditionalOperatorOr  ConditionalOperator = "OR"
)

// Values returns all known values for ConditionalOperator. 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.
func (ConditionalOperator) Values() []ConditionalOperator {
	return []ConditionalOperator{
		"AND",
		"OR",
	}
}

type ContinuousBackupsStatus string

// Enum values for ContinuousBackupsStatus
const (
	ContinuousBackupsStatusEnabled  ContinuousBackupsStatus = "ENABLED"
	ContinuousBackupsStatusDisabled ContinuousBackupsStatus = "DISABLED"
)

// Values returns all known values for ContinuousBackupsStatus. 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.
func (ContinuousBackupsStatus) Values() []ContinuousBackupsStatus {
	return []ContinuousBackupsStatus{
		"ENABLED",
		"DISABLED",
	}
}

type ContributorInsightsAction string

// Enum values for ContributorInsightsAction
const (
	ContributorInsightsActionEnable  ContributorInsightsAction = "ENABLE"
	ContributorInsightsActionDisable ContributorInsightsAction = "DISABLE"
)

// Values returns all known values for ContributorInsightsAction. 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.
func (ContributorInsightsAction) Values() []ContributorInsightsAction {
	return []ContributorInsightsAction{
		"ENABLE",
		"DISABLE",
	}
}

type ContributorInsightsStatus string

// Enum values for ContributorInsightsStatus
const (
	ContributorInsightsStatusEnabling  ContributorInsightsStatus = "ENABLING"
	ContributorInsightsStatusEnabled   ContributorInsightsStatus = "ENABLED"
	ContributorInsightsStatusDisabling ContributorInsightsStatus = "DISABLING"
	ContributorInsightsStatusDisabled  ContributorInsightsStatus = "DISABLED"
	ContributorInsightsStatusFailed    ContributorInsightsStatus = "FAILED"
)

// Values returns all known values for ContributorInsightsStatus. 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.
func (ContributorInsightsStatus) Values() []ContributorInsightsStatus {
	return []ContributorInsightsStatus{
		"ENABLING",
		"ENABLED",
		"DISABLING",
		"DISABLED",
		"FAILED",
	}
}

type DestinationStatus string

// Enum values for DestinationStatus
const (
	DestinationStatusEnabling     DestinationStatus = "ENABLING"
	DestinationStatusActive       DestinationStatus = "ACTIVE"
	DestinationStatusDisabling    DestinationStatus = "DISABLING"
	DestinationStatusDisabled     DestinationStatus = "DISABLED"
	DestinationStatusEnableFailed DestinationStatus = "ENABLE_FAILED"
	DestinationStatusUpdating     DestinationStatus = "UPDATING"
)

// Values returns all known values for DestinationStatus. 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.
func (DestinationStatus) Values() []DestinationStatus {
	return []DestinationStatus{
		"ENABLING",
		"ACTIVE",
		"DISABLING",
		"DISABLED",
		"ENABLE_FAILED",
		"UPDATING",
	}
}

type ExportFormat string

// Enum values for ExportFormat
const (
	ExportFormatDynamodbJson ExportFormat = "DYNAMODB_JSON"
	ExportFormatIon          ExportFormat = "ION"
)

// Values returns all known values for ExportFormat. 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.
func (ExportFormat) Values() []ExportFormat {
	return []ExportFormat{
		"DYNAMODB_JSON",
		"ION",
	}
}

type ExportStatus string

// Enum values for ExportStatus
const (
	ExportStatusInProgress ExportStatus = "IN_PROGRESS"
	ExportStatusCompleted  ExportStatus = "COMPLETED"
	ExportStatusFailed     ExportStatus = "FAILED"
)

// Values returns all known values for ExportStatus. 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.
func (ExportStatus) Values() []ExportStatus {
	return []ExportStatus{
		"IN_PROGRESS",
		"COMPLETED",
		"FAILED",
	}
}

type ExportType string

// Enum values for ExportType
const (
	ExportTypeFullExport        ExportType = "FULL_EXPORT"
	ExportTypeIncrementalExport ExportType = "INCREMENTAL_EXPORT"
)

// Values returns all known values for ExportType. 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.
func (ExportType) Values() []ExportType {
	return []ExportType{
		"FULL_EXPORT",
		"INCREMENTAL_EXPORT",
	}
}

type ExportViewType string

// Enum values for ExportViewType
const (
	ExportViewTypeNewImage        ExportViewType = "NEW_IMAGE"
	ExportViewTypeNewAndOldImages ExportViewType = "NEW_AND_OLD_IMAGES"
)

// Values returns all known values for ExportViewType. 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.
func (ExportViewType) Values() []ExportViewType {
	return []ExportViewType{
		"NEW_IMAGE",
		"NEW_AND_OLD_IMAGES",
	}
}

type GlobalTableStatus string

// Enum values for GlobalTableStatus
const (
	GlobalTableStatusCreating GlobalTableStatus = "CREATING"
	GlobalTableStatusActive   GlobalTableStatus = "ACTIVE"
	GlobalTableStatusDeleting GlobalTableStatus = "DELETING"
	GlobalTableStatusUpdating GlobalTableStatus = "UPDATING"
)

// Values returns all known values for GlobalTableStatus. 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.
func (GlobalTableStatus) Values() []GlobalTableStatus {
	return []GlobalTableStatus{
		"CREATING",
		"ACTIVE",
		"DELETING",
		"UPDATING",
	}
}

type ImportStatus string

// Enum values for ImportStatus
const (
	ImportStatusInProgress ImportStatus = "IN_PROGRESS"
	ImportStatusCompleted  ImportStatus = "COMPLETED"
	ImportStatusCancelling ImportStatus = "CANCELLING"
	ImportStatusCancelled  ImportStatus = "CANCELLED"
	ImportStatusFailed     ImportStatus = "FAILED"
)

// Values returns all known values for ImportStatus. 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.
func (ImportStatus) Values() []ImportStatus {
	return []ImportStatus{
		"IN_PROGRESS",
		"COMPLETED",
		"CANCELLING",
		"CANCELLED",
		"FAILED",
	}
}

type IndexStatus string

// Enum values for IndexStatus
const (
	IndexStatusCreating IndexStatus = "CREATING"
	IndexStatusUpdating IndexStatus = "UPDATING"
	IndexStatusDeleting IndexStatus = "DELETING"
	IndexStatusActive   IndexStatus = "ACTIVE"
)

// Values returns all known values for IndexStatus. 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.
func (IndexStatus) Values() []IndexStatus {
	return []IndexStatus{
		"CREATING",
		"UPDATING",
		"DELETING",
		"ACTIVE",
	}
}

type InputCompressionType string

// Enum values for InputCompressionType
const (
	InputCompressionTypeGzip InputCompressionType = "GZIP"
	InputCompressionTypeZstd InputCompressionType = "ZSTD"
	InputCompressionTypeNone InputCompressionType = "NONE"
)

// Values returns all known values for InputCompressionType. 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.
func (InputCompressionType) Values() []InputCompressionType {
	return []InputCompressionType{
		"GZIP",
		"ZSTD",
		"NONE",
	}
}

type InputFormat string

// Enum values for InputFormat
const (
	InputFormatDynamodbJson InputFormat = "DYNAMODB_JSON"
	InputFormatIon          InputFormat = "ION"
	InputFormatCsv          InputFormat = "CSV"
)

// Values returns all known values for InputFormat. 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.
func (InputFormat) Values() []InputFormat {
	return []InputFormat{
		"DYNAMODB_JSON",
		"ION",
		"CSV",
	}
}

type KeyType string

// Enum values for KeyType
const (
	KeyTypeHash  KeyType = "HASH"
	KeyTypeRange KeyType = "RANGE"
)

// Values returns all known values for KeyType. 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.
func (KeyType) Values() []KeyType {
	return []KeyType{
		"HASH",
		"RANGE",
	}
}

type MultiRegionConsistency string

// Enum values for MultiRegionConsistency
const (
	MultiRegionConsistencyEventual MultiRegionConsistency = "EVENTUAL"
	MultiRegionConsistencyStrong   MultiRegionConsistency = "STRONG"
)

// Values returns all known values for MultiRegionConsistency. 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.
func (MultiRegionConsistency) Values() []MultiRegionConsistency {
	return []MultiRegionConsistency{
		"EVENTUAL",
		"STRONG",
	}
}

type PointInTimeRecoveryStatus string

// Enum values for PointInTimeRecoveryStatus
const (
	PointInTimeRecoveryStatusEnabled  PointInTimeRecoveryStatus = "ENABLED"
	PointInTimeRecoveryStatusDisabled PointInTimeRecoveryStatus = "DISABLED"
)

// Values returns all known values for PointInTimeRecoveryStatus. 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.
func (PointInTimeRecoveryStatus) Values() []PointInTimeRecoveryStatus {
	return []PointInTimeRecoveryStatus{
		"ENABLED",
		"DISABLED",
	}
}

type ProjectionType string

// Enum values for ProjectionType
const (
	ProjectionTypeAll      ProjectionType = "ALL"
	ProjectionTypeKeysOnly ProjectionType = "KEYS_ONLY"
	ProjectionTypeInclude  ProjectionType = "INCLUDE"
)

// Values returns all known values for ProjectionType. 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.
func (ProjectionType) Values() []ProjectionType {
	return []ProjectionType{
		"ALL",
		"KEYS_ONLY",
		"INCLUDE",
	}
}

type ReplicaStatus string

// Enum values for ReplicaStatus
const (
	ReplicaStatusCreating                          ReplicaStatus = "CREATING"
	ReplicaStatusCreationFailed                    ReplicaStatus = "CREATION_FAILED"
	ReplicaStatusUpdating                          ReplicaStatus = "UPDATING"
	ReplicaStatusDeleting                          ReplicaStatus = "DELETING"
	ReplicaStatusActive                            ReplicaStatus = "ACTIVE"
	ReplicaStatusRegionDisabled                    ReplicaStatus = "REGION_DISABLED"
	ReplicaStatusInaccessibleEncryptionCredentials ReplicaStatus = "INACCESSIBLE_ENCRYPTION_CREDENTIALS"
)

// Values returns all known values for ReplicaStatus. 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.
func (ReplicaStatus) Values() []ReplicaStatus {
	return []ReplicaStatus{
		"CREATING",
		"CREATION_FAILED",
		"UPDATING",
		"DELETING",
		"ACTIVE",
		"REGION_DISABLED",
		"INACCESSIBLE_ENCRYPTION_CREDENTIALS",
	}
}

type ReturnConsumedCapacity string

// Enum values for ReturnConsumedCapacity
const (
	ReturnConsumedCapacityIndexes ReturnConsumedCapacity = "INDEXES"
	ReturnConsumedCapacityTotal   ReturnConsumedCapacity = "TOTAL"
	ReturnConsumedCapacityNone    ReturnConsumedCapacity = "NONE"
)

// Values returns all known values for ReturnConsumedCapacity. 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.
func (ReturnConsumedCapacity) Values() []ReturnConsumedCapacity {
	return []ReturnConsumedCapacity{
		"INDEXES",
		"TOTAL",
		"NONE",
	}
}

type ReturnItemCollectionMetrics string

// Enum values for ReturnItemCollectionMetrics
const (
	ReturnItemCollectionMetricsSize ReturnItemCollectionMetrics = "SIZE"
	ReturnItemCollectionMetricsNone ReturnItemCollectionMetrics = "NONE"
)

// Values returns all known values for ReturnItemCollectionMetrics. 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.
func (ReturnItemCollectionMetrics) Values() []ReturnItemCollectionMetrics {
	return []ReturnItemCollectionMetrics{
		"SIZE",
		"NONE",
	}
}

type ReturnValue string

// Enum values for ReturnValue
const (
	ReturnValueNone       ReturnValue = "NONE"
	ReturnValueAllOld     ReturnValue = "ALL_OLD"
	ReturnValueUpdatedOld ReturnValue = "UPDATED_OLD"
	ReturnValueAllNew     ReturnValue = "ALL_NEW"
	ReturnValueUpdatedNew ReturnValue = "UPDATED_NEW"
)

// Values returns all known values for ReturnValue. 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.
func (ReturnValue) Values() []ReturnValue {
	return []ReturnValue{
		"NONE",
		"ALL_OLD",
		"UPDATED_OLD",
		"ALL_NEW",
		"UPDATED_NEW",
	}
}

type ReturnValuesOnConditionCheckFailure string

// Enum values for ReturnValuesOnConditionCheckFailure
const (
	ReturnValuesOnConditionCheckFailureAllOld ReturnValuesOnConditionCheckFailure = "ALL_OLD"
	ReturnValuesOnConditionCheckFailureNone   ReturnValuesOnConditionCheckFailure = "NONE"
)

// Values returns all known values for ReturnValuesOnConditionCheckFailure. 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.
func (ReturnValuesOnConditionCheckFailure) Values() []ReturnValuesOnConditionCheckFailure {
	return []ReturnValuesOnConditionCheckFailure{
		"ALL_OLD",
		"NONE",
	}
}

type S3SseAlgorithm string

// Enum values for S3SseAlgorithm
const (
	S3SseAlgorithmAes256 S3SseAlgorithm = "AES256"
	S3SseAlgorithmKms    S3SseAlgorithm = "KMS"
)

// Values returns all known values for S3SseAlgorithm. 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.
func (S3SseAlgorithm) Values() []S3SseAlgorithm {
	return []S3SseAlgorithm{
		"AES256",
		"KMS",
	}
}

type ScalarAttributeType string

// Enum values for ScalarAttributeType
const (
	ScalarAttributeTypeS ScalarAttributeType = "S"
	ScalarAttributeTypeN ScalarAttributeType = "N"
	ScalarAttributeTypeB ScalarAttributeType = "B"
)

// Values returns all known values for ScalarAttributeType. 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.
func (ScalarAttributeType) Values() []ScalarAttributeType {
	return []ScalarAttributeType{
		"S",
		"N",
		"B",
	}
}

type Select string

// Enum values for Select
const (
	SelectAllAttributes          Select = "ALL_ATTRIBUTES"
	SelectAllProjectedAttributes Select = "ALL_PROJECTED_ATTRIBUTES"
	SelectSpecificAttributes     Select = "SPECIFIC_ATTRIBUTES"
	SelectCount                  Select = "COUNT"
)

// Values returns all known values for Select. 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.
func (Select) Values() []Select {
	return []Select{
		"ALL_ATTRIBUTES",
		"ALL_PROJECTED_ATTRIBUTES",
		"SPECIFIC_ATTRIBUTES",
		"COUNT",
	}
}

type SSEStatus string

// Enum values for SSEStatus
const (
	SSEStatusEnabling  SSEStatus = "ENABLING"
	SSEStatusEnabled   SSEStatus = "ENABLED"
	SSEStatusDisabling SSEStatus = "DISABLING"
	SSEStatusDisabled  SSEStatus = "DISABLED"
	SSEStatusUpdating  SSEStatus = "UPDATING"
)

// Values returns all known values for SSEStatus. 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.
func (SSEStatus) Values() []SSEStatus {
	return []SSEStatus{
		"ENABLING",
		"ENABLED",
		"DISABLING",
		"DISABLED",
		"UPDATING",
	}
}

type SSEType string

// Enum values for SSEType
const (
	SSETypeAes256 SSEType = "AES256"
	SSETypeKms    SSEType = "KMS"
)

// Values returns all known values for SSEType. 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.
func (SSEType) Values() []SSEType {
	return []SSEType{
		"AES256",
		"KMS",
	}
}

type StreamViewType string

// Enum values for StreamViewType
const (
	StreamViewTypeNewImage        StreamViewType = "NEW_IMAGE"
	StreamViewTypeOldImage        StreamViewType = "OLD_IMAGE"
	StreamViewTypeNewAndOldImages StreamViewType = "NEW_AND_OLD_IMAGES"
	StreamViewTypeKeysOnly        StreamViewType = "KEYS_ONLY"
)

// Values returns all known values for StreamViewType. 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.
func (StreamViewType) Values() []StreamViewType {
	return []StreamViewType{
		"NEW_IMAGE",
		"OLD_IMAGE",
		"NEW_AND_OLD_IMAGES",
		"KEYS_ONLY",
	}
}

type TableClass string

// Enum values for TableClass
const (
	TableClassStandard                 TableClass = "STANDARD"
	TableClassStandardInfrequentAccess TableClass = "STANDARD_INFREQUENT_ACCESS"
)

// Values returns all known values for TableClass. 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.
func (TableClass) Values() []TableClass {
	return []TableClass{
		"STANDARD",
		"STANDARD_INFREQUENT_ACCESS",
	}
}

type TableStatus string

// Enum values for TableStatus
const (
	TableStatusCreating                          TableStatus = "CREATING"
	TableStatusUpdating                          TableStatus = "UPDATING"
	TableStatusDeleting                          TableStatus = "DELETING"
	TableStatusActive                            TableStatus = "ACTIVE"
	TableStatusInaccessibleEncryptionCredentials TableStatus = "INACCESSIBLE_ENCRYPTION_CREDENTIALS"
	TableStatusArchiving                         TableStatus = "ARCHIVING"
	TableStatusArchived                          TableStatus = "ARCHIVED"
)

// Values returns all known values for TableStatus. 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.
func (TableStatus) Values() []TableStatus {
	return []TableStatus{
		"CREATING",
		"UPDATING",
		"DELETING",
		"ACTIVE",
		"INACCESSIBLE_ENCRYPTION_CREDENTIALS",
		"ARCHIVING",
		"ARCHIVED",
	}
}

type TimeToLiveStatus string

// Enum values for TimeToLiveStatus
const (
	TimeToLiveStatusEnabling  TimeToLiveStatus = "ENABLING"
	TimeToLiveStatusDisabling TimeToLiveStatus = "DISABLING"
	TimeToLiveStatusEnabled   TimeToLiveStatus = "ENABLED"
	TimeToLiveStatusDisabled  TimeToLiveStatus = "DISABLED"
)

// Values returns all known values for TimeToLiveStatus. 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.
func (TimeToLiveStatus) Values() []TimeToLiveStatus {
	return []TimeToLiveStatus{
		"ENABLING",
		"DISABLING",
		"ENABLED",
		"DISABLED",
	}
}
