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

package types

type ArtifactStatus string

// Enum values for ArtifactStatus
const (
	ArtifactStatusActive     ArtifactStatus = "ACTIVE"
	ArtifactStatusArchived   ArtifactStatus = "ARCHIVED"
	ArtifactStatusActivating ArtifactStatus = "ACTIVATING"
)

// Values returns all known values for ArtifactStatus. 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 (ArtifactStatus) Values() []ArtifactStatus {
	return []ArtifactStatus{
		"ACTIVE",
		"ARCHIVED",
		"ACTIVATING",
	}
}

type ArtifactStatusFilter string

// Enum values for ArtifactStatusFilter
const (
	ArtifactStatusFilterActive     ArtifactStatusFilter = "ACTIVE"
	ArtifactStatusFilterArchived   ArtifactStatusFilter = "ARCHIVED"
	ArtifactStatusFilterActivating ArtifactStatusFilter = "ACTIVATING"
	ArtifactStatusFilterAny        ArtifactStatusFilter = "ANY"
)

// Values returns all known values for ArtifactStatusFilter. 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 (ArtifactStatusFilter) Values() []ArtifactStatusFilter {
	return []ArtifactStatusFilter{
		"ACTIVE",
		"ARCHIVED",
		"ACTIVATING",
		"ANY",
	}
}

type EncryptionType string

// Enum values for EncryptionType
const (
	EncryptionTypeAes256  EncryptionType = "AES256"
	EncryptionTypeKms     EncryptionType = "KMS"
	EncryptionTypeKmsDsse EncryptionType = "KMS_DSSE"
)

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

type FindingSeverity string

// Enum values for FindingSeverity
const (
	FindingSeverityInformational FindingSeverity = "INFORMATIONAL"
	FindingSeverityLow           FindingSeverity = "LOW"
	FindingSeverityMedium        FindingSeverity = "MEDIUM"
	FindingSeverityHigh          FindingSeverity = "HIGH"
	FindingSeverityCritical      FindingSeverity = "CRITICAL"
	FindingSeverityUndefined     FindingSeverity = "UNDEFINED"
)

// Values returns all known values for FindingSeverity. 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 (FindingSeverity) Values() []FindingSeverity {
	return []FindingSeverity{
		"INFORMATIONAL",
		"LOW",
		"MEDIUM",
		"HIGH",
		"CRITICAL",
		"UNDEFINED",
	}
}

type ImageActionType string

// Enum values for ImageActionType
const (
	ImageActionTypeExpire     ImageActionType = "EXPIRE"
	ImageActionTypeTransition ImageActionType = "TRANSITION"
)

// Values returns all known values for ImageActionType. 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 (ImageActionType) Values() []ImageActionType {
	return []ImageActionType{
		"EXPIRE",
		"TRANSITION",
	}
}

type ImageFailureCode string

// Enum values for ImageFailureCode
const (
	ImageFailureCodeInvalidImageDigest            ImageFailureCode = "InvalidImageDigest"
	ImageFailureCodeInvalidImageTag               ImageFailureCode = "InvalidImageTag"
	ImageFailureCodeImageTagDoesNotMatchDigest    ImageFailureCode = "ImageTagDoesNotMatchDigest"
	ImageFailureCodeImageNotFound                 ImageFailureCode = "ImageNotFound"
	ImageFailureCodeMissingDigestAndTag           ImageFailureCode = "MissingDigestAndTag"
	ImageFailureCodeImageReferencedByManifestList ImageFailureCode = "ImageReferencedByManifestList"
	ImageFailureCodeKmsError                      ImageFailureCode = "KmsError"
	ImageFailureCodeUpstreamAccessDenied          ImageFailureCode = "UpstreamAccessDenied"
	ImageFailureCodeUpstreamTooManyRequests       ImageFailureCode = "UpstreamTooManyRequests"
	ImageFailureCodeUpstreamUnavailable           ImageFailureCode = "UpstreamUnavailable"
	ImageFailureCodeImageInaccessible             ImageFailureCode = "ImageInaccessible"
)

// Values returns all known values for ImageFailureCode. 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 (ImageFailureCode) Values() []ImageFailureCode {
	return []ImageFailureCode{
		"InvalidImageDigest",
		"InvalidImageTag",
		"ImageTagDoesNotMatchDigest",
		"ImageNotFound",
		"MissingDigestAndTag",
		"ImageReferencedByManifestList",
		"KmsError",
		"UpstreamAccessDenied",
		"UpstreamTooManyRequests",
		"UpstreamUnavailable",
		"ImageInaccessible",
	}
}

type ImageStatus string

// Enum values for ImageStatus
const (
	ImageStatusActive     ImageStatus = "ACTIVE"
	ImageStatusArchived   ImageStatus = "ARCHIVED"
	ImageStatusActivating ImageStatus = "ACTIVATING"
)

// Values returns all known values for ImageStatus. 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 (ImageStatus) Values() []ImageStatus {
	return []ImageStatus{
		"ACTIVE",
		"ARCHIVED",
		"ACTIVATING",
	}
}

type ImageStatusFilter string

// Enum values for ImageStatusFilter
const (
	ImageStatusFilterActive     ImageStatusFilter = "ACTIVE"
	ImageStatusFilterArchived   ImageStatusFilter = "ARCHIVED"
	ImageStatusFilterActivating ImageStatusFilter = "ACTIVATING"
	ImageStatusFilterAny        ImageStatusFilter = "ANY"
)

// Values returns all known values for ImageStatusFilter. 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 (ImageStatusFilter) Values() []ImageStatusFilter {
	return []ImageStatusFilter{
		"ACTIVE",
		"ARCHIVED",
		"ACTIVATING",
		"ANY",
	}
}

type ImageTagMutability string

// Enum values for ImageTagMutability
const (
	ImageTagMutabilityMutable                ImageTagMutability = "MUTABLE"
	ImageTagMutabilityImmutable              ImageTagMutability = "IMMUTABLE"
	ImageTagMutabilityImmutableWithExclusion ImageTagMutability = "IMMUTABLE_WITH_EXCLUSION"
	ImageTagMutabilityMutableWithExclusion   ImageTagMutability = "MUTABLE_WITH_EXCLUSION"
)

// Values returns all known values for ImageTagMutability. 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 (ImageTagMutability) Values() []ImageTagMutability {
	return []ImageTagMutability{
		"MUTABLE",
		"IMMUTABLE",
		"IMMUTABLE_WITH_EXCLUSION",
		"MUTABLE_WITH_EXCLUSION",
	}
}

type ImageTagMutabilityExclusionFilterType string

// Enum values for ImageTagMutabilityExclusionFilterType
const (
	ImageTagMutabilityExclusionFilterTypeWildcard ImageTagMutabilityExclusionFilterType = "WILDCARD"
)

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

type LayerAvailability string

// Enum values for LayerAvailability
const (
	LayerAvailabilityAvailable   LayerAvailability = "AVAILABLE"
	LayerAvailabilityUnavailable LayerAvailability = "UNAVAILABLE"
	LayerAvailabilityArchived    LayerAvailability = "ARCHIVED"
)

// Values returns all known values for LayerAvailability. 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 (LayerAvailability) Values() []LayerAvailability {
	return []LayerAvailability{
		"AVAILABLE",
		"UNAVAILABLE",
		"ARCHIVED",
	}
}

type LayerFailureCode string

// Enum values for LayerFailureCode
const (
	LayerFailureCodeInvalidLayerDigest LayerFailureCode = "InvalidLayerDigest"
	LayerFailureCodeMissingLayerDigest LayerFailureCode = "MissingLayerDigest"
)

// Values returns all known values for LayerFailureCode. 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 (LayerFailureCode) Values() []LayerFailureCode {
	return []LayerFailureCode{
		"InvalidLayerDigest",
		"MissingLayerDigest",
	}
}

type LifecyclePolicyPreviewStatus string

// Enum values for LifecyclePolicyPreviewStatus
const (
	LifecyclePolicyPreviewStatusInProgress LifecyclePolicyPreviewStatus = "IN_PROGRESS"
	LifecyclePolicyPreviewStatusComplete   LifecyclePolicyPreviewStatus = "COMPLETE"
	LifecyclePolicyPreviewStatusExpired    LifecyclePolicyPreviewStatus = "EXPIRED"
	LifecyclePolicyPreviewStatusFailed     LifecyclePolicyPreviewStatus = "FAILED"
)

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

type LifecyclePolicyStorageClass string

// Enum values for LifecyclePolicyStorageClass
const (
	LifecyclePolicyStorageClassArchive  LifecyclePolicyStorageClass = "ARCHIVE"
	LifecyclePolicyStorageClassStandard LifecyclePolicyStorageClass = "STANDARD"
)

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

type LifecyclePolicyTargetStorageClass string

// Enum values for LifecyclePolicyTargetStorageClass
const (
	LifecyclePolicyTargetStorageClassArchive LifecyclePolicyTargetStorageClass = "ARCHIVE"
)

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

type RCTAppliedFor string

// Enum values for RCTAppliedFor
const (
	RCTAppliedForReplication      RCTAppliedFor = "REPLICATION"
	RCTAppliedForPullThroughCache RCTAppliedFor = "PULL_THROUGH_CACHE"
	RCTAppliedForCreateOnPush     RCTAppliedFor = "CREATE_ON_PUSH"
)

// Values returns all known values for RCTAppliedFor. 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 (RCTAppliedFor) Values() []RCTAppliedFor {
	return []RCTAppliedFor{
		"REPLICATION",
		"PULL_THROUGH_CACHE",
		"CREATE_ON_PUSH",
	}
}

type ReplicationStatus string

// Enum values for ReplicationStatus
const (
	ReplicationStatusInProgress ReplicationStatus = "IN_PROGRESS"
	ReplicationStatusComplete   ReplicationStatus = "COMPLETE"
	ReplicationStatusFailed     ReplicationStatus = "FAILED"
)

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

type RepositoryFilterType string

// Enum values for RepositoryFilterType
const (
	RepositoryFilterTypePrefixMatch RepositoryFilterType = "PREFIX_MATCH"
)

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

type ScanFrequency string

// Enum values for ScanFrequency
const (
	ScanFrequencyScanOnPush     ScanFrequency = "SCAN_ON_PUSH"
	ScanFrequencyContinuousScan ScanFrequency = "CONTINUOUS_SCAN"
	ScanFrequencyManual         ScanFrequency = "MANUAL"
)

// Values returns all known values for ScanFrequency. 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 (ScanFrequency) Values() []ScanFrequency {
	return []ScanFrequency{
		"SCAN_ON_PUSH",
		"CONTINUOUS_SCAN",
		"MANUAL",
	}
}

type ScanningConfigurationFailureCode string

// Enum values for ScanningConfigurationFailureCode
const (
	ScanningConfigurationFailureCodeRepositoryNotFound ScanningConfigurationFailureCode = "REPOSITORY_NOT_FOUND"
)

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

type ScanningRepositoryFilterType string

// Enum values for ScanningRepositoryFilterType
const (
	ScanningRepositoryFilterTypeWildcard ScanningRepositoryFilterType = "WILDCARD"
)

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

type ScanStatus string

// Enum values for ScanStatus
const (
	ScanStatusInProgress             ScanStatus = "IN_PROGRESS"
	ScanStatusComplete               ScanStatus = "COMPLETE"
	ScanStatusFailed                 ScanStatus = "FAILED"
	ScanStatusUnsupportedImage       ScanStatus = "UNSUPPORTED_IMAGE"
	ScanStatusActive                 ScanStatus = "ACTIVE"
	ScanStatusPending                ScanStatus = "PENDING"
	ScanStatusScanEligibilityExpired ScanStatus = "SCAN_ELIGIBILITY_EXPIRED"
	ScanStatusFindingsUnavailable    ScanStatus = "FINDINGS_UNAVAILABLE"
	ScanStatusLimitExceeded          ScanStatus = "LIMIT_EXCEEDED"
	ScanStatusImageArchived          ScanStatus = "IMAGE_ARCHIVED"
)

// Values returns all known values for ScanStatus. 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 (ScanStatus) Values() []ScanStatus {
	return []ScanStatus{
		"IN_PROGRESS",
		"COMPLETE",
		"FAILED",
		"UNSUPPORTED_IMAGE",
		"ACTIVE",
		"PENDING",
		"SCAN_ELIGIBILITY_EXPIRED",
		"FINDINGS_UNAVAILABLE",
		"LIMIT_EXCEEDED",
		"IMAGE_ARCHIVED",
	}
}

type ScanType string

// Enum values for ScanType
const (
	ScanTypeBasic    ScanType = "BASIC"
	ScanTypeEnhanced ScanType = "ENHANCED"
)

// Values returns all known values for ScanType. 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 (ScanType) Values() []ScanType {
	return []ScanType{
		"BASIC",
		"ENHANCED",
	}
}

type SigningRepositoryFilterType string

// Enum values for SigningRepositoryFilterType
const (
	SigningRepositoryFilterTypeWildcardMatch SigningRepositoryFilterType = "WILDCARD_MATCH"
)

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

type SigningStatus string

// Enum values for SigningStatus
const (
	SigningStatusInProgress SigningStatus = "IN_PROGRESS"
	SigningStatusComplete   SigningStatus = "COMPLETE"
	SigningStatusFailed     SigningStatus = "FAILED"
)

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

type TagStatus string

// Enum values for TagStatus
const (
	TagStatusTagged   TagStatus = "TAGGED"
	TagStatusUntagged TagStatus = "UNTAGGED"
	TagStatusAny      TagStatus = "ANY"
)

// Values returns all known values for TagStatus. 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 (TagStatus) Values() []TagStatus {
	return []TagStatus{
		"TAGGED",
		"UNTAGGED",
		"ANY",
	}
}

type TargetStorageClass string

// Enum values for TargetStorageClass
const (
	TargetStorageClassStandard TargetStorageClass = "STANDARD"
	TargetStorageClassArchive  TargetStorageClass = "ARCHIVE"
)

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

type UpstreamRegistry string

// Enum values for UpstreamRegistry
const (
	UpstreamRegistryEcr                     UpstreamRegistry = "ecr"
	UpstreamRegistryEcrPublic               UpstreamRegistry = "ecr-public"
	UpstreamRegistryQuay                    UpstreamRegistry = "quay"
	UpstreamRegistryK8s                     UpstreamRegistry = "k8s"
	UpstreamRegistryDockerHub               UpstreamRegistry = "docker-hub"
	UpstreamRegistryGitHubContainerRegistry UpstreamRegistry = "github-container-registry"
	UpstreamRegistryAzureContainerRegistry  UpstreamRegistry = "azure-container-registry"
	UpstreamRegistryGitLabContainerRegistry UpstreamRegistry = "gitlab-container-registry"
)

// Values returns all known values for UpstreamRegistry. 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 (UpstreamRegistry) Values() []UpstreamRegistry {
	return []UpstreamRegistry{
		"ecr",
		"ecr-public",
		"quay",
		"k8s",
		"docker-hub",
		"github-container-registry",
		"azure-container-registry",
		"gitlab-container-registry",
	}
}
