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

package types

type AcceleratorManufacturer string

// Enum values for AcceleratorManufacturer
const (
	AcceleratorManufacturerAmazonWebServices AcceleratorManufacturer = "amazon-web-services"
	AcceleratorManufacturerAmd               AcceleratorManufacturer = "amd"
	AcceleratorManufacturerNvidia            AcceleratorManufacturer = "nvidia"
	AcceleratorManufacturerXilinx            AcceleratorManufacturer = "xilinx"
	AcceleratorManufacturerHabana            AcceleratorManufacturer = "habana"
)

// Values returns all known values for AcceleratorManufacturer. 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 (AcceleratorManufacturer) Values() []AcceleratorManufacturer {
	return []AcceleratorManufacturer{
		"amazon-web-services",
		"amd",
		"nvidia",
		"xilinx",
		"habana",
	}
}

type AcceleratorName string

// Enum values for AcceleratorName
const (
	AcceleratorNameA100          AcceleratorName = "a100"
	AcceleratorNameInferentia    AcceleratorName = "inferentia"
	AcceleratorNameK520          AcceleratorName = "k520"
	AcceleratorNameK80           AcceleratorName = "k80"
	AcceleratorNameM60           AcceleratorName = "m60"
	AcceleratorNameRadeonProV520 AcceleratorName = "radeon-pro-v520"
	AcceleratorNameT4            AcceleratorName = "t4"
	AcceleratorNameVu9p          AcceleratorName = "vu9p"
	AcceleratorNameV100          AcceleratorName = "v100"
	AcceleratorNameA10g          AcceleratorName = "a10g"
	AcceleratorNameH100          AcceleratorName = "h100"
	AcceleratorNameT4g           AcceleratorName = "t4g"
)

// Values returns all known values for AcceleratorName. 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 (AcceleratorName) Values() []AcceleratorName {
	return []AcceleratorName{
		"a100",
		"inferentia",
		"k520",
		"k80",
		"m60",
		"radeon-pro-v520",
		"t4",
		"vu9p",
		"v100",
		"a10g",
		"h100",
		"t4g",
	}
}

type AcceleratorType string

// Enum values for AcceleratorType
const (
	AcceleratorTypeGpu       AcceleratorType = "gpu"
	AcceleratorTypeFpga      AcceleratorType = "fpga"
	AcceleratorTypeInference AcceleratorType = "inference"
)

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

type AccountAttributeName string

// Enum values for AccountAttributeName
const (
	AccountAttributeNameSupportedPlatforms AccountAttributeName = "supported-platforms"
	AccountAttributeNameDefaultVpc         AccountAttributeName = "default-vpc"
)

// Values returns all known values for AccountAttributeName. 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 (AccountAttributeName) Values() []AccountAttributeName {
	return []AccountAttributeName{
		"supported-platforms",
		"default-vpc",
	}
}

type ActivityStatus string

// Enum values for ActivityStatus
const (
	ActivityStatusError              ActivityStatus = "error"
	ActivityStatusPendingFulfillment ActivityStatus = "pending_fulfillment"
	ActivityStatusPendingTermination ActivityStatus = "pending_termination"
	ActivityStatusFulfilled          ActivityStatus = "fulfilled"
)

// Values returns all known values for ActivityStatus. 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 (ActivityStatus) Values() []ActivityStatus {
	return []ActivityStatus{
		"error",
		"pending_fulfillment",
		"pending_termination",
		"fulfilled",
	}
}

type AddressAttributeName string

// Enum values for AddressAttributeName
const (
	AddressAttributeNameDomainName AddressAttributeName = "domain-name"
)

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

type AddressFamily string

// Enum values for AddressFamily
const (
	AddressFamilyIpv4 AddressFamily = "ipv4"
	AddressFamilyIpv6 AddressFamily = "ipv6"
)

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

type AddressTransferStatus string

// Enum values for AddressTransferStatus
const (
	AddressTransferStatusPending  AddressTransferStatus = "pending"
	AddressTransferStatusDisabled AddressTransferStatus = "disabled"
	AddressTransferStatusAccepted AddressTransferStatus = "accepted"
)

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

type Affinity string

// Enum values for Affinity
const (
	AffinityDefault Affinity = "default"
	AffinityHost    Affinity = "host"
)

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

type AllocationState string

// Enum values for AllocationState
const (
	AllocationStateAvailable                AllocationState = "available"
	AllocationStateUnderAssessment          AllocationState = "under-assessment"
	AllocationStatePermanentFailure         AllocationState = "permanent-failure"
	AllocationStateReleased                 AllocationState = "released"
	AllocationStateReleasedPermanentFailure AllocationState = "released-permanent-failure"
	AllocationStatePending                  AllocationState = "pending"
)

// Values returns all known values for AllocationState. 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 (AllocationState) Values() []AllocationState {
	return []AllocationState{
		"available",
		"under-assessment",
		"permanent-failure",
		"released",
		"released-permanent-failure",
		"pending",
	}
}

type AllocationStrategy string

// Enum values for AllocationStrategy
const (
	AllocationStrategyLowestPrice                  AllocationStrategy = "lowestPrice"
	AllocationStrategyDiversified                  AllocationStrategy = "diversified"
	AllocationStrategyCapacityOptimized            AllocationStrategy = "capacityOptimized"
	AllocationStrategyCapacityOptimizedPrioritized AllocationStrategy = "capacityOptimizedPrioritized"
	AllocationStrategyPriceCapacityOptimized       AllocationStrategy = "priceCapacityOptimized"
)

// Values returns all known values for AllocationStrategy. 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 (AllocationStrategy) Values() []AllocationStrategy {
	return []AllocationStrategy{
		"lowestPrice",
		"diversified",
		"capacityOptimized",
		"capacityOptimizedPrioritized",
		"priceCapacityOptimized",
	}
}

type AllocationType string

// Enum values for AllocationType
const (
	AllocationTypeUsed AllocationType = "used"
)

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

type AllowsMultipleInstanceTypes string

// Enum values for AllowsMultipleInstanceTypes
const (
	AllowsMultipleInstanceTypesOn  AllowsMultipleInstanceTypes = "on"
	AllowsMultipleInstanceTypesOff AllowsMultipleInstanceTypes = "off"
)

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

type AmdSevSnpSpecification string

// Enum values for AmdSevSnpSpecification
const (
	AmdSevSnpSpecificationEnabled  AmdSevSnpSpecification = "enabled"
	AmdSevSnpSpecificationDisabled AmdSevSnpSpecification = "disabled"
)

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

type AnalysisStatus string

// Enum values for AnalysisStatus
const (
	AnalysisStatusRunning   AnalysisStatus = "running"
	AnalysisStatusSucceeded AnalysisStatus = "succeeded"
	AnalysisStatusFailed    AnalysisStatus = "failed"
)

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

type ApplianceModeSupportValue string

// Enum values for ApplianceModeSupportValue
const (
	ApplianceModeSupportValueEnable  ApplianceModeSupportValue = "enable"
	ApplianceModeSupportValueDisable ApplianceModeSupportValue = "disable"
)

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

type ArchitectureType string

// Enum values for ArchitectureType
const (
	ArchitectureTypeI386     ArchitectureType = "i386"
	ArchitectureTypeX8664    ArchitectureType = "x86_64"
	ArchitectureTypeArm64    ArchitectureType = "arm64"
	ArchitectureTypeX8664Mac ArchitectureType = "x86_64_mac"
	ArchitectureTypeArm64Mac ArchitectureType = "arm64_mac"
)

// Values returns all known values for ArchitectureType. 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 (ArchitectureType) Values() []ArchitectureType {
	return []ArchitectureType{
		"i386",
		"x86_64",
		"arm64",
		"x86_64_mac",
		"arm64_mac",
	}
}

type ArchitectureValues string

// Enum values for ArchitectureValues
const (
	ArchitectureValuesI386     ArchitectureValues = "i386"
	ArchitectureValuesX8664    ArchitectureValues = "x86_64"
	ArchitectureValuesArm64    ArchitectureValues = "arm64"
	ArchitectureValuesX8664Mac ArchitectureValues = "x86_64_mac"
	ArchitectureValuesArm64Mac ArchitectureValues = "arm64_mac"
)

// Values returns all known values for ArchitectureValues. 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 (ArchitectureValues) Values() []ArchitectureValues {
	return []ArchitectureValues{
		"i386",
		"x86_64",
		"arm64",
		"x86_64_mac",
		"arm64_mac",
	}
}

type AsnAssociationState string

// Enum values for AsnAssociationState
const (
	AsnAssociationStateDisassociated         AsnAssociationState = "disassociated"
	AsnAssociationStateFailedDisassociation  AsnAssociationState = "failed-disassociation"
	AsnAssociationStateFailedAssociation     AsnAssociationState = "failed-association"
	AsnAssociationStatePendingDisassociation AsnAssociationState = "pending-disassociation"
	AsnAssociationStatePendingAssociation    AsnAssociationState = "pending-association"
	AsnAssociationStateAssociated            AsnAssociationState = "associated"
)

// Values returns all known values for AsnAssociationState. 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 (AsnAssociationState) Values() []AsnAssociationState {
	return []AsnAssociationState{
		"disassociated",
		"failed-disassociation",
		"failed-association",
		"pending-disassociation",
		"pending-association",
		"associated",
	}
}

type AsnState string

// Enum values for AsnState
const (
	AsnStateDeprovisioned      AsnState = "deprovisioned"
	AsnStateFailedDeprovision  AsnState = "failed-deprovision"
	AsnStateFailedProvision    AsnState = "failed-provision"
	AsnStatePendingDeprovision AsnState = "pending-deprovision"
	AsnStatePendingProvision   AsnState = "pending-provision"
	AsnStateProvisioned        AsnState = "provisioned"
)

// Values returns all known values for AsnState. 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 (AsnState) Values() []AsnState {
	return []AsnState{
		"deprovisioned",
		"failed-deprovision",
		"failed-provision",
		"pending-deprovision",
		"pending-provision",
		"provisioned",
	}
}

type AssociatedNetworkType string

// Enum values for AssociatedNetworkType
const (
	AssociatedNetworkTypeVpc AssociatedNetworkType = "vpc"
)

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

type AssociationStatusCode string

// Enum values for AssociationStatusCode
const (
	AssociationStatusCodeAssociating       AssociationStatusCode = "associating"
	AssociationStatusCodeAssociated        AssociationStatusCode = "associated"
	AssociationStatusCodeAssociationFailed AssociationStatusCode = "association-failed"
	AssociationStatusCodeDisassociating    AssociationStatusCode = "disassociating"
	AssociationStatusCodeDisassociated     AssociationStatusCode = "disassociated"
)

// Values returns all known values for AssociationStatusCode. 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 (AssociationStatusCode) Values() []AssociationStatusCode {
	return []AssociationStatusCode{
		"associating",
		"associated",
		"association-failed",
		"disassociating",
		"disassociated",
	}
}

type AttachmentStatus string

// Enum values for AttachmentStatus
const (
	AttachmentStatusAttaching AttachmentStatus = "attaching"
	AttachmentStatusAttached  AttachmentStatus = "attached"
	AttachmentStatusDetaching AttachmentStatus = "detaching"
	AttachmentStatusDetached  AttachmentStatus = "detached"
)

// Values returns all known values for AttachmentStatus. 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 (AttachmentStatus) Values() []AttachmentStatus {
	return []AttachmentStatus{
		"attaching",
		"attached",
		"detaching",
		"detached",
	}
}

type AutoAcceptSharedAssociationsValue string

// Enum values for AutoAcceptSharedAssociationsValue
const (
	AutoAcceptSharedAssociationsValueEnable  AutoAcceptSharedAssociationsValue = "enable"
	AutoAcceptSharedAssociationsValueDisable AutoAcceptSharedAssociationsValue = "disable"
)

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

type AutoAcceptSharedAttachmentsValue string

// Enum values for AutoAcceptSharedAttachmentsValue
const (
	AutoAcceptSharedAttachmentsValueEnable  AutoAcceptSharedAttachmentsValue = "enable"
	AutoAcceptSharedAttachmentsValueDisable AutoAcceptSharedAttachmentsValue = "disable"
)

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

type AutoPlacement string

// Enum values for AutoPlacement
const (
	AutoPlacementOn  AutoPlacement = "on"
	AutoPlacementOff AutoPlacement = "off"
)

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

type AvailabilityZoneOptInStatus string

// Enum values for AvailabilityZoneOptInStatus
const (
	AvailabilityZoneOptInStatusOptInNotRequired AvailabilityZoneOptInStatus = "opt-in-not-required"
	AvailabilityZoneOptInStatusOptedIn          AvailabilityZoneOptInStatus = "opted-in"
	AvailabilityZoneOptInStatusNotOptedIn       AvailabilityZoneOptInStatus = "not-opted-in"
)

// Values returns all known values for AvailabilityZoneOptInStatus. 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 (AvailabilityZoneOptInStatus) Values() []AvailabilityZoneOptInStatus {
	return []AvailabilityZoneOptInStatus{
		"opt-in-not-required",
		"opted-in",
		"not-opted-in",
	}
}

type AvailabilityZoneState string

// Enum values for AvailabilityZoneState
const (
	AvailabilityZoneStateAvailable   AvailabilityZoneState = "available"
	AvailabilityZoneStateInformation AvailabilityZoneState = "information"
	AvailabilityZoneStateImpaired    AvailabilityZoneState = "impaired"
	AvailabilityZoneStateUnavailable AvailabilityZoneState = "unavailable"
	AvailabilityZoneStateConstrained AvailabilityZoneState = "constrained"
)

// Values returns all known values for AvailabilityZoneState. 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 (AvailabilityZoneState) Values() []AvailabilityZoneState {
	return []AvailabilityZoneState{
		"available",
		"information",
		"impaired",
		"unavailable",
		"constrained",
	}
}

type BareMetal string

// Enum values for BareMetal
const (
	BareMetalIncluded BareMetal = "included"
	BareMetalRequired BareMetal = "required"
	BareMetalExcluded BareMetal = "excluded"
)

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

type BatchState string

// Enum values for BatchState
const (
	BatchStateSubmitted                     BatchState = "submitted"
	BatchStateActive                        BatchState = "active"
	BatchStateCancelled                     BatchState = "cancelled"
	BatchStateFailed                        BatchState = "failed"
	BatchStateCancelledRunning              BatchState = "cancelled_running"
	BatchStateCancelledTerminatingInstances BatchState = "cancelled_terminating"
	BatchStateModifying                     BatchState = "modifying"
)

// Values returns all known values for BatchState. 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 (BatchState) Values() []BatchState {
	return []BatchState{
		"submitted",
		"active",
		"cancelled",
		"failed",
		"cancelled_running",
		"cancelled_terminating",
		"modifying",
	}
}

type BgpStatus string

// Enum values for BgpStatus
const (
	BgpStatusUp   BgpStatus = "up"
	BgpStatusDown BgpStatus = "down"
)

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

type BlockPublicAccessMode string

// Enum values for BlockPublicAccessMode
const (
	BlockPublicAccessModeOff                BlockPublicAccessMode = "off"
	BlockPublicAccessModeBlockBidirectional BlockPublicAccessMode = "block-bidirectional"
	BlockPublicAccessModeBlockIngress       BlockPublicAccessMode = "block-ingress"
)

// Values returns all known values for BlockPublicAccessMode. 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 (BlockPublicAccessMode) Values() []BlockPublicAccessMode {
	return []BlockPublicAccessMode{
		"off",
		"block-bidirectional",
		"block-ingress",
	}
}

type BootModeType string

// Enum values for BootModeType
const (
	BootModeTypeLegacyBios BootModeType = "legacy-bios"
	BootModeTypeUefi       BootModeType = "uefi"
)

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

type BootModeValues string

// Enum values for BootModeValues
const (
	BootModeValuesLegacyBios    BootModeValues = "legacy-bios"
	BootModeValuesUefi          BootModeValues = "uefi"
	BootModeValuesUefiPreferred BootModeValues = "uefi-preferred"
)

// Values returns all known values for BootModeValues. 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 (BootModeValues) Values() []BootModeValues {
	return []BootModeValues{
		"legacy-bios",
		"uefi",
		"uefi-preferred",
	}
}

type BundleTaskState string

// Enum values for BundleTaskState
const (
	BundleTaskStatePending            BundleTaskState = "pending"
	BundleTaskStateWaitingForShutdown BundleTaskState = "waiting-for-shutdown"
	BundleTaskStateBundling           BundleTaskState = "bundling"
	BundleTaskStateStoring            BundleTaskState = "storing"
	BundleTaskStateCancelling         BundleTaskState = "cancelling"
	BundleTaskStateComplete           BundleTaskState = "complete"
	BundleTaskStateFailed             BundleTaskState = "failed"
)

// Values returns all known values for BundleTaskState. 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 (BundleTaskState) Values() []BundleTaskState {
	return []BundleTaskState{
		"pending",
		"waiting-for-shutdown",
		"bundling",
		"storing",
		"cancelling",
		"complete",
		"failed",
	}
}

type BurstablePerformance string

// Enum values for BurstablePerformance
const (
	BurstablePerformanceIncluded BurstablePerformance = "included"
	BurstablePerformanceRequired BurstablePerformance = "required"
	BurstablePerformanceExcluded BurstablePerformance = "excluded"
)

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

type ByoipCidrState string

// Enum values for ByoipCidrState
const (
	ByoipCidrStateAdvertised                         ByoipCidrState = "advertised"
	ByoipCidrStateDeprovisioned                      ByoipCidrState = "deprovisioned"
	ByoipCidrStateFailedDeprovision                  ByoipCidrState = "failed-deprovision"
	ByoipCidrStateFailedProvision                    ByoipCidrState = "failed-provision"
	ByoipCidrStatePendingDeprovision                 ByoipCidrState = "pending-deprovision"
	ByoipCidrStatePendingProvision                   ByoipCidrState = "pending-provision"
	ByoipCidrStateProvisioned                        ByoipCidrState = "provisioned"
	ByoipCidrStateProvisionedNotPubliclyAdvertisable ByoipCidrState = "provisioned-not-publicly-advertisable"
)

// Values returns all known values for ByoipCidrState. 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 (ByoipCidrState) Values() []ByoipCidrState {
	return []ByoipCidrState{
		"advertised",
		"deprovisioned",
		"failed-deprovision",
		"failed-provision",
		"pending-deprovision",
		"pending-provision",
		"provisioned",
		"provisioned-not-publicly-advertisable",
	}
}

type CallerRole string

// Enum values for CallerRole
const (
	CallerRoleOdcrOwner                     CallerRole = "odcr-owner"
	CallerRoleUnusedReservationBillingOwner CallerRole = "unused-reservation-billing-owner"
)

// Values returns all known values for CallerRole. 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 (CallerRole) Values() []CallerRole {
	return []CallerRole{
		"odcr-owner",
		"unused-reservation-billing-owner",
	}
}

type CancelBatchErrorCode string

// Enum values for CancelBatchErrorCode
const (
	CancelBatchErrorCodeFleetRequestIdDoesNotExist        CancelBatchErrorCode = "fleetRequestIdDoesNotExist"
	CancelBatchErrorCodeFleetRequestIdMalformed           CancelBatchErrorCode = "fleetRequestIdMalformed"
	CancelBatchErrorCodeFleetRequestNotInCancellableState CancelBatchErrorCode = "fleetRequestNotInCancellableState"
	CancelBatchErrorCodeUnexpectedError                   CancelBatchErrorCode = "unexpectedError"
)

// Values returns all known values for CancelBatchErrorCode. 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 (CancelBatchErrorCode) Values() []CancelBatchErrorCode {
	return []CancelBatchErrorCode{
		"fleetRequestIdDoesNotExist",
		"fleetRequestIdMalformed",
		"fleetRequestNotInCancellableState",
		"unexpectedError",
	}
}

type CancelSpotInstanceRequestState string

// Enum values for CancelSpotInstanceRequestState
const (
	CancelSpotInstanceRequestStateActive    CancelSpotInstanceRequestState = "active"
	CancelSpotInstanceRequestStateOpen      CancelSpotInstanceRequestState = "open"
	CancelSpotInstanceRequestStateClosed    CancelSpotInstanceRequestState = "closed"
	CancelSpotInstanceRequestStateCancelled CancelSpotInstanceRequestState = "cancelled"
	CancelSpotInstanceRequestStateCompleted CancelSpotInstanceRequestState = "completed"
)

// Values returns all known values for CancelSpotInstanceRequestState. 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 (CancelSpotInstanceRequestState) Values() []CancelSpotInstanceRequestState {
	return []CancelSpotInstanceRequestState{
		"active",
		"open",
		"closed",
		"cancelled",
		"completed",
	}
}

type CapacityBlockExtensionStatus string

// Enum values for CapacityBlockExtensionStatus
const (
	CapacityBlockExtensionStatusPaymentPending   CapacityBlockExtensionStatus = "payment-pending"
	CapacityBlockExtensionStatusPaymentFailed    CapacityBlockExtensionStatus = "payment-failed"
	CapacityBlockExtensionStatusPaymentSucceeded CapacityBlockExtensionStatus = "payment-succeeded"
)

// Values returns all known values for CapacityBlockExtensionStatus. 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 (CapacityBlockExtensionStatus) Values() []CapacityBlockExtensionStatus {
	return []CapacityBlockExtensionStatus{
		"payment-pending",
		"payment-failed",
		"payment-succeeded",
	}
}

type CapacityReservationBillingRequestStatus string

// Enum values for CapacityReservationBillingRequestStatus
const (
	CapacityReservationBillingRequestStatusPending   CapacityReservationBillingRequestStatus = "pending"
	CapacityReservationBillingRequestStatusAccepted  CapacityReservationBillingRequestStatus = "accepted"
	CapacityReservationBillingRequestStatusRejected  CapacityReservationBillingRequestStatus = "rejected"
	CapacityReservationBillingRequestStatusCancelled CapacityReservationBillingRequestStatus = "cancelled"
	CapacityReservationBillingRequestStatusRevoked   CapacityReservationBillingRequestStatus = "revoked"
	CapacityReservationBillingRequestStatusExpired   CapacityReservationBillingRequestStatus = "expired"
)

// Values returns all known values for CapacityReservationBillingRequestStatus.
// 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 (CapacityReservationBillingRequestStatus) Values() []CapacityReservationBillingRequestStatus {
	return []CapacityReservationBillingRequestStatus{
		"pending",
		"accepted",
		"rejected",
		"cancelled",
		"revoked",
		"expired",
	}
}

type CapacityReservationDeliveryPreference string

// Enum values for CapacityReservationDeliveryPreference
const (
	CapacityReservationDeliveryPreferenceFixed       CapacityReservationDeliveryPreference = "fixed"
	CapacityReservationDeliveryPreferenceIncremental CapacityReservationDeliveryPreference = "incremental"
)

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

type CapacityReservationFleetState string

// Enum values for CapacityReservationFleetState
const (
	CapacityReservationFleetStateSubmitted          CapacityReservationFleetState = "submitted"
	CapacityReservationFleetStateModifying          CapacityReservationFleetState = "modifying"
	CapacityReservationFleetStateActive             CapacityReservationFleetState = "active"
	CapacityReservationFleetStatePartiallyFulfilled CapacityReservationFleetState = "partially_fulfilled"
	CapacityReservationFleetStateExpiring           CapacityReservationFleetState = "expiring"
	CapacityReservationFleetStateExpired            CapacityReservationFleetState = "expired"
	CapacityReservationFleetStateCancelling         CapacityReservationFleetState = "cancelling"
	CapacityReservationFleetStateCancelled          CapacityReservationFleetState = "cancelled"
	CapacityReservationFleetStateFailed             CapacityReservationFleetState = "failed"
)

// Values returns all known values for CapacityReservationFleetState. 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 (CapacityReservationFleetState) Values() []CapacityReservationFleetState {
	return []CapacityReservationFleetState{
		"submitted",
		"modifying",
		"active",
		"partially_fulfilled",
		"expiring",
		"expired",
		"cancelling",
		"cancelled",
		"failed",
	}
}

type CapacityReservationInstancePlatform string

// Enum values for CapacityReservationInstancePlatform
const (
	CapacityReservationInstancePlatformLinuxUnix                        CapacityReservationInstancePlatform = "Linux/UNIX"
	CapacityReservationInstancePlatformRedHatEnterpriseLinux            CapacityReservationInstancePlatform = "Red Hat Enterprise Linux"
	CapacityReservationInstancePlatformSuseLinux                        CapacityReservationInstancePlatform = "SUSE Linux"
	CapacityReservationInstancePlatformWindows                          CapacityReservationInstancePlatform = "Windows"
	CapacityReservationInstancePlatformWindowsWithSqlServer             CapacityReservationInstancePlatform = "Windows with SQL Server"
	CapacityReservationInstancePlatformWindowsWithSqlServerEnterprise   CapacityReservationInstancePlatform = "Windows with SQL Server Enterprise"
	CapacityReservationInstancePlatformWindowsWithSqlServerStandard     CapacityReservationInstancePlatform = "Windows with SQL Server Standard"
	CapacityReservationInstancePlatformWindowsWithSqlServerWeb          CapacityReservationInstancePlatform = "Windows with SQL Server Web"
	CapacityReservationInstancePlatformLinuxWithSqlServerStandard       CapacityReservationInstancePlatform = "Linux with SQL Server Standard"
	CapacityReservationInstancePlatformLinuxWithSqlServerWeb            CapacityReservationInstancePlatform = "Linux with SQL Server Web"
	CapacityReservationInstancePlatformLinuxWithSqlServerEnterprise     CapacityReservationInstancePlatform = "Linux with SQL Server Enterprise"
	CapacityReservationInstancePlatformRhelWithSqlServerStandard        CapacityReservationInstancePlatform = "RHEL with SQL Server Standard"
	CapacityReservationInstancePlatformRhelWithSqlServerEnterprise      CapacityReservationInstancePlatform = "RHEL with SQL Server Enterprise"
	CapacityReservationInstancePlatformRhelWithSqlServerWeb             CapacityReservationInstancePlatform = "RHEL with SQL Server Web"
	CapacityReservationInstancePlatformRhelWithHa                       CapacityReservationInstancePlatform = "RHEL with HA"
	CapacityReservationInstancePlatformRhelWithHaAndSqlServerStandard   CapacityReservationInstancePlatform = "RHEL with HA and SQL Server Standard"
	CapacityReservationInstancePlatformRhelWithHaAndSqlServerEnterprise CapacityReservationInstancePlatform = "RHEL with HA and SQL Server Enterprise"
	CapacityReservationInstancePlatformUbuntuProLinux                   CapacityReservationInstancePlatform = "Ubuntu Pro"
)

// Values returns all known values for CapacityReservationInstancePlatform. 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 (CapacityReservationInstancePlatform) Values() []CapacityReservationInstancePlatform {
	return []CapacityReservationInstancePlatform{
		"Linux/UNIX",
		"Red Hat Enterprise Linux",
		"SUSE Linux",
		"Windows",
		"Windows with SQL Server",
		"Windows with SQL Server Enterprise",
		"Windows with SQL Server Standard",
		"Windows with SQL Server Web",
		"Linux with SQL Server Standard",
		"Linux with SQL Server Web",
		"Linux with SQL Server Enterprise",
		"RHEL with SQL Server Standard",
		"RHEL with SQL Server Enterprise",
		"RHEL with SQL Server Web",
		"RHEL with HA",
		"RHEL with HA and SQL Server Standard",
		"RHEL with HA and SQL Server Enterprise",
		"Ubuntu Pro",
	}
}

type CapacityReservationPreference string

// Enum values for CapacityReservationPreference
const (
	CapacityReservationPreferenceCapacityReservationsOnly CapacityReservationPreference = "capacity-reservations-only"
	CapacityReservationPreferenceOpen                     CapacityReservationPreference = "open"
	CapacityReservationPreferenceNone                     CapacityReservationPreference = "none"
)

// Values returns all known values for CapacityReservationPreference. 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 (CapacityReservationPreference) Values() []CapacityReservationPreference {
	return []CapacityReservationPreference{
		"capacity-reservations-only",
		"open",
		"none",
	}
}

type CapacityReservationState string

// Enum values for CapacityReservationState
const (
	CapacityReservationStateActive         CapacityReservationState = "active"
	CapacityReservationStateExpired        CapacityReservationState = "expired"
	CapacityReservationStateCancelled      CapacityReservationState = "cancelled"
	CapacityReservationStatePending        CapacityReservationState = "pending"
	CapacityReservationStateFailed         CapacityReservationState = "failed"
	CapacityReservationStateScheduled      CapacityReservationState = "scheduled"
	CapacityReservationStatePaymentPending CapacityReservationState = "payment-pending"
	CapacityReservationStatePaymentFailed  CapacityReservationState = "payment-failed"
	CapacityReservationStateAssessing      CapacityReservationState = "assessing"
	CapacityReservationStateDelayed        CapacityReservationState = "delayed"
	CapacityReservationStateUnsupported    CapacityReservationState = "unsupported"
)

// Values returns all known values for CapacityReservationState. 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 (CapacityReservationState) Values() []CapacityReservationState {
	return []CapacityReservationState{
		"active",
		"expired",
		"cancelled",
		"pending",
		"failed",
		"scheduled",
		"payment-pending",
		"payment-failed",
		"assessing",
		"delayed",
		"unsupported",
	}
}

type CapacityReservationTenancy string

// Enum values for CapacityReservationTenancy
const (
	CapacityReservationTenancyDefault   CapacityReservationTenancy = "default"
	CapacityReservationTenancyDedicated CapacityReservationTenancy = "dedicated"
)

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

type CapacityReservationType string

// Enum values for CapacityReservationType
const (
	CapacityReservationTypeDefault       CapacityReservationType = "default"
	CapacityReservationTypeCapacityBlock CapacityReservationType = "capacity-block"
)

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

type CarrierGatewayState string

// Enum values for CarrierGatewayState
const (
	CarrierGatewayStatePending   CarrierGatewayState = "pending"
	CarrierGatewayStateAvailable CarrierGatewayState = "available"
	CarrierGatewayStateDeleting  CarrierGatewayState = "deleting"
	CarrierGatewayStateDeleted   CarrierGatewayState = "deleted"
)

// Values returns all known values for CarrierGatewayState. 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 (CarrierGatewayState) Values() []CarrierGatewayState {
	return []CarrierGatewayState{
		"pending",
		"available",
		"deleting",
		"deleted",
	}
}

type ClientCertificateRevocationListStatusCode string

// Enum values for ClientCertificateRevocationListStatusCode
const (
	ClientCertificateRevocationListStatusCodePending ClientCertificateRevocationListStatusCode = "pending"
	ClientCertificateRevocationListStatusCodeActive  ClientCertificateRevocationListStatusCode = "active"
)

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

type ClientVpnAuthenticationType string

// Enum values for ClientVpnAuthenticationType
const (
	ClientVpnAuthenticationTypeCertificateAuthentication      ClientVpnAuthenticationType = "certificate-authentication"
	ClientVpnAuthenticationTypeDirectoryServiceAuthentication ClientVpnAuthenticationType = "directory-service-authentication"
	ClientVpnAuthenticationTypeFederatedAuthentication        ClientVpnAuthenticationType = "federated-authentication"
)

// Values returns all known values for ClientVpnAuthenticationType. 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 (ClientVpnAuthenticationType) Values() []ClientVpnAuthenticationType {
	return []ClientVpnAuthenticationType{
		"certificate-authentication",
		"directory-service-authentication",
		"federated-authentication",
	}
}

type ClientVpnAuthorizationRuleStatusCode string

// Enum values for ClientVpnAuthorizationRuleStatusCode
const (
	ClientVpnAuthorizationRuleStatusCodeAuthorizing ClientVpnAuthorizationRuleStatusCode = "authorizing"
	ClientVpnAuthorizationRuleStatusCodeActive      ClientVpnAuthorizationRuleStatusCode = "active"
	ClientVpnAuthorizationRuleStatusCodeFailed      ClientVpnAuthorizationRuleStatusCode = "failed"
	ClientVpnAuthorizationRuleStatusCodeRevoking    ClientVpnAuthorizationRuleStatusCode = "revoking"
)

// Values returns all known values for ClientVpnAuthorizationRuleStatusCode. 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 (ClientVpnAuthorizationRuleStatusCode) Values() []ClientVpnAuthorizationRuleStatusCode {
	return []ClientVpnAuthorizationRuleStatusCode{
		"authorizing",
		"active",
		"failed",
		"revoking",
	}
}

type ClientVpnConnectionStatusCode string

// Enum values for ClientVpnConnectionStatusCode
const (
	ClientVpnConnectionStatusCodeActive            ClientVpnConnectionStatusCode = "active"
	ClientVpnConnectionStatusCodeFailedToTerminate ClientVpnConnectionStatusCode = "failed-to-terminate"
	ClientVpnConnectionStatusCodeTerminating       ClientVpnConnectionStatusCode = "terminating"
	ClientVpnConnectionStatusCodeTerminated        ClientVpnConnectionStatusCode = "terminated"
)

// Values returns all known values for ClientVpnConnectionStatusCode. 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 (ClientVpnConnectionStatusCode) Values() []ClientVpnConnectionStatusCode {
	return []ClientVpnConnectionStatusCode{
		"active",
		"failed-to-terminate",
		"terminating",
		"terminated",
	}
}

type ClientVpnEndpointAttributeStatusCode string

// Enum values for ClientVpnEndpointAttributeStatusCode
const (
	ClientVpnEndpointAttributeStatusCodeApplying ClientVpnEndpointAttributeStatusCode = "applying"
	ClientVpnEndpointAttributeStatusCodeApplied  ClientVpnEndpointAttributeStatusCode = "applied"
)

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

type ClientVpnEndpointStatusCode string

// Enum values for ClientVpnEndpointStatusCode
const (
	ClientVpnEndpointStatusCodePendingAssociate ClientVpnEndpointStatusCode = "pending-associate"
	ClientVpnEndpointStatusCodeAvailable        ClientVpnEndpointStatusCode = "available"
	ClientVpnEndpointStatusCodeDeleting         ClientVpnEndpointStatusCode = "deleting"
	ClientVpnEndpointStatusCodeDeleted          ClientVpnEndpointStatusCode = "deleted"
)

// Values returns all known values for ClientVpnEndpointStatusCode. 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 (ClientVpnEndpointStatusCode) Values() []ClientVpnEndpointStatusCode {
	return []ClientVpnEndpointStatusCode{
		"pending-associate",
		"available",
		"deleting",
		"deleted",
	}
}

type ClientVpnRouteStatusCode string

// Enum values for ClientVpnRouteStatusCode
const (
	ClientVpnRouteStatusCodeCreating ClientVpnRouteStatusCode = "creating"
	ClientVpnRouteStatusCodeActive   ClientVpnRouteStatusCode = "active"
	ClientVpnRouteStatusCodeFailed   ClientVpnRouteStatusCode = "failed"
	ClientVpnRouteStatusCodeDeleting ClientVpnRouteStatusCode = "deleting"
)

// Values returns all known values for ClientVpnRouteStatusCode. 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 (ClientVpnRouteStatusCode) Values() []ClientVpnRouteStatusCode {
	return []ClientVpnRouteStatusCode{
		"creating",
		"active",
		"failed",
		"deleting",
	}
}

type ConnectionNotificationState string

// Enum values for ConnectionNotificationState
const (
	ConnectionNotificationStateEnabled  ConnectionNotificationState = "Enabled"
	ConnectionNotificationStateDisabled ConnectionNotificationState = "Disabled"
)

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

type ConnectionNotificationType string

// Enum values for ConnectionNotificationType
const (
	ConnectionNotificationTypeTopic ConnectionNotificationType = "Topic"
)

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

type ConnectivityType string

// Enum values for ConnectivityType
const (
	ConnectivityTypePrivate ConnectivityType = "private"
	ConnectivityTypePublic  ConnectivityType = "public"
)

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

type ContainerFormat string

// Enum values for ContainerFormat
const (
	ContainerFormatOva ContainerFormat = "ova"
)

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

type ConversionTaskState string

// Enum values for ConversionTaskState
const (
	ConversionTaskStateActive     ConversionTaskState = "active"
	ConversionTaskStateCancelling ConversionTaskState = "cancelling"
	ConversionTaskStateCancelled  ConversionTaskState = "cancelled"
	ConversionTaskStateCompleted  ConversionTaskState = "completed"
)

// Values returns all known values for ConversionTaskState. 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 (ConversionTaskState) Values() []ConversionTaskState {
	return []ConversionTaskState{
		"active",
		"cancelling",
		"cancelled",
		"completed",
	}
}

type CopyTagsFromSource string

// Enum values for CopyTagsFromSource
const (
	CopyTagsFromSourceVolume CopyTagsFromSource = "volume"
)

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

type CpuManufacturer string

// Enum values for CpuManufacturer
const (
	CpuManufacturerIntel             CpuManufacturer = "intel"
	CpuManufacturerAmd               CpuManufacturer = "amd"
	CpuManufacturerAmazonWebServices CpuManufacturer = "amazon-web-services"
	CpuManufacturerApple             CpuManufacturer = "apple"
)

// Values returns all known values for CpuManufacturer. 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 (CpuManufacturer) Values() []CpuManufacturer {
	return []CpuManufacturer{
		"intel",
		"amd",
		"amazon-web-services",
		"apple",
	}
}

type CurrencyCodeValues string

// Enum values for CurrencyCodeValues
const (
	CurrencyCodeValuesUsd CurrencyCodeValues = "USD"
)

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

type DatafeedSubscriptionState string

// Enum values for DatafeedSubscriptionState
const (
	DatafeedSubscriptionStateActive   DatafeedSubscriptionState = "Active"
	DatafeedSubscriptionStateInactive DatafeedSubscriptionState = "Inactive"
)

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

type DefaultInstanceMetadataEndpointState string

// Enum values for DefaultInstanceMetadataEndpointState
const (
	DefaultInstanceMetadataEndpointStateDisabled     DefaultInstanceMetadataEndpointState = "disabled"
	DefaultInstanceMetadataEndpointStateEnabled      DefaultInstanceMetadataEndpointState = "enabled"
	DefaultInstanceMetadataEndpointStateNoPreference DefaultInstanceMetadataEndpointState = "no-preference"
)

// Values returns all known values for DefaultInstanceMetadataEndpointState. 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 (DefaultInstanceMetadataEndpointState) Values() []DefaultInstanceMetadataEndpointState {
	return []DefaultInstanceMetadataEndpointState{
		"disabled",
		"enabled",
		"no-preference",
	}
}

type DefaultInstanceMetadataTagsState string

// Enum values for DefaultInstanceMetadataTagsState
const (
	DefaultInstanceMetadataTagsStateDisabled     DefaultInstanceMetadataTagsState = "disabled"
	DefaultInstanceMetadataTagsStateEnabled      DefaultInstanceMetadataTagsState = "enabled"
	DefaultInstanceMetadataTagsStateNoPreference DefaultInstanceMetadataTagsState = "no-preference"
)

// Values returns all known values for DefaultInstanceMetadataTagsState. 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 (DefaultInstanceMetadataTagsState) Values() []DefaultInstanceMetadataTagsState {
	return []DefaultInstanceMetadataTagsState{
		"disabled",
		"enabled",
		"no-preference",
	}
}

type DefaultRouteTableAssociationValue string

// Enum values for DefaultRouteTableAssociationValue
const (
	DefaultRouteTableAssociationValueEnable  DefaultRouteTableAssociationValue = "enable"
	DefaultRouteTableAssociationValueDisable DefaultRouteTableAssociationValue = "disable"
)

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

type DefaultRouteTablePropagationValue string

// Enum values for DefaultRouteTablePropagationValue
const (
	DefaultRouteTablePropagationValueEnable  DefaultRouteTablePropagationValue = "enable"
	DefaultRouteTablePropagationValueDisable DefaultRouteTablePropagationValue = "disable"
)

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

type DefaultTargetCapacityType string

// Enum values for DefaultTargetCapacityType
const (
	DefaultTargetCapacityTypeSpot          DefaultTargetCapacityType = "spot"
	DefaultTargetCapacityTypeOnDemand      DefaultTargetCapacityType = "on-demand"
	DefaultTargetCapacityTypeCapacityBlock DefaultTargetCapacityType = "capacity-block"
)

// Values returns all known values for DefaultTargetCapacityType. 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 (DefaultTargetCapacityType) Values() []DefaultTargetCapacityType {
	return []DefaultTargetCapacityType{
		"spot",
		"on-demand",
		"capacity-block",
	}
}

type DeleteFleetErrorCode string

// Enum values for DeleteFleetErrorCode
const (
	DeleteFleetErrorCodeFleetIdDoesNotExist      DeleteFleetErrorCode = "fleetIdDoesNotExist"
	DeleteFleetErrorCodeFleetIdMalformed         DeleteFleetErrorCode = "fleetIdMalformed"
	DeleteFleetErrorCodeFleetNotInDeletableState DeleteFleetErrorCode = "fleetNotInDeletableState"
	DeleteFleetErrorCodeUnexpectedError          DeleteFleetErrorCode = "unexpectedError"
)

// Values returns all known values for DeleteFleetErrorCode. 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 (DeleteFleetErrorCode) Values() []DeleteFleetErrorCode {
	return []DeleteFleetErrorCode{
		"fleetIdDoesNotExist",
		"fleetIdMalformed",
		"fleetNotInDeletableState",
		"unexpectedError",
	}
}

type DeleteQueuedReservedInstancesErrorCode string

// Enum values for DeleteQueuedReservedInstancesErrorCode
const (
	DeleteQueuedReservedInstancesErrorCodeReservedInstancesIdInvalid        DeleteQueuedReservedInstancesErrorCode = "reserved-instances-id-invalid"
	DeleteQueuedReservedInstancesErrorCodeReservedInstancesNotInQueuedState DeleteQueuedReservedInstancesErrorCode = "reserved-instances-not-in-queued-state"
	DeleteQueuedReservedInstancesErrorCodeUnexpectedError                   DeleteQueuedReservedInstancesErrorCode = "unexpected-error"
)

// Values returns all known values for DeleteQueuedReservedInstancesErrorCode.
// 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 (DeleteQueuedReservedInstancesErrorCode) Values() []DeleteQueuedReservedInstancesErrorCode {
	return []DeleteQueuedReservedInstancesErrorCode{
		"reserved-instances-id-invalid",
		"reserved-instances-not-in-queued-state",
		"unexpected-error",
	}
}

type DestinationFileFormat string

// Enum values for DestinationFileFormat
const (
	DestinationFileFormatPlainText DestinationFileFormat = "plain-text"
	DestinationFileFormatParquet   DestinationFileFormat = "parquet"
)

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

type DeviceTrustProviderType string

// Enum values for DeviceTrustProviderType
const (
	DeviceTrustProviderTypeJamf        DeviceTrustProviderType = "jamf"
	DeviceTrustProviderTypeCrowdstrike DeviceTrustProviderType = "crowdstrike"
	DeviceTrustProviderTypeJumpcloud   DeviceTrustProviderType = "jumpcloud"
)

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

type DeviceType string

// Enum values for DeviceType
const (
	DeviceTypeEbs           DeviceType = "ebs"
	DeviceTypeInstanceStore DeviceType = "instance-store"
)

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

type DiskImageFormat string

// Enum values for DiskImageFormat
const (
	DiskImageFormatVmdk DiskImageFormat = "VMDK"
	DiskImageFormatRaw  DiskImageFormat = "RAW"
	DiskImageFormatVhd  DiskImageFormat = "VHD"
)

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

type DiskType string

// Enum values for DiskType
const (
	DiskTypeHdd DiskType = "hdd"
	DiskTypeSsd DiskType = "ssd"
)

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

type DnsNameState string

// Enum values for DnsNameState
const (
	DnsNameStatePendingVerification DnsNameState = "pendingVerification"
	DnsNameStateVerified            DnsNameState = "verified"
	DnsNameStateFailed              DnsNameState = "failed"
)

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

type DnsRecordIpType string

// Enum values for DnsRecordIpType
const (
	DnsRecordIpTypeIpv4           DnsRecordIpType = "ipv4"
	DnsRecordIpTypeDualstack      DnsRecordIpType = "dualstack"
	DnsRecordIpTypeIpv6           DnsRecordIpType = "ipv6"
	DnsRecordIpTypeServiceDefined DnsRecordIpType = "service-defined"
)

// Values returns all known values for DnsRecordIpType. 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 (DnsRecordIpType) Values() []DnsRecordIpType {
	return []DnsRecordIpType{
		"ipv4",
		"dualstack",
		"ipv6",
		"service-defined",
	}
}

type DnsSupportValue string

// Enum values for DnsSupportValue
const (
	DnsSupportValueEnable  DnsSupportValue = "enable"
	DnsSupportValueDisable DnsSupportValue = "disable"
)

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

type DomainType string

// Enum values for DomainType
const (
	DomainTypeVpc      DomainType = "vpc"
	DomainTypeStandard DomainType = "standard"
)

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

type DynamicRoutingValue string

// Enum values for DynamicRoutingValue
const (
	DynamicRoutingValueEnable  DynamicRoutingValue = "enable"
	DynamicRoutingValueDisable DynamicRoutingValue = "disable"
)

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

type EbsEncryptionSupport string

// Enum values for EbsEncryptionSupport
const (
	EbsEncryptionSupportUnsupported EbsEncryptionSupport = "unsupported"
	EbsEncryptionSupportSupported   EbsEncryptionSupport = "supported"
)

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

type EbsNvmeSupport string

// Enum values for EbsNvmeSupport
const (
	EbsNvmeSupportUnsupported EbsNvmeSupport = "unsupported"
	EbsNvmeSupportSupported   EbsNvmeSupport = "supported"
	EbsNvmeSupportRequired    EbsNvmeSupport = "required"
)

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

type EbsOptimizedSupport string

// Enum values for EbsOptimizedSupport
const (
	EbsOptimizedSupportUnsupported EbsOptimizedSupport = "unsupported"
	EbsOptimizedSupportSupported   EbsOptimizedSupport = "supported"
	EbsOptimizedSupportDefault     EbsOptimizedSupport = "default"
)

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

type Ec2InstanceConnectEndpointState string

// Enum values for Ec2InstanceConnectEndpointState
const (
	Ec2InstanceConnectEndpointStateCreateInProgress Ec2InstanceConnectEndpointState = "create-in-progress"
	Ec2InstanceConnectEndpointStateCreateComplete   Ec2InstanceConnectEndpointState = "create-complete"
	Ec2InstanceConnectEndpointStateCreateFailed     Ec2InstanceConnectEndpointState = "create-failed"
	Ec2InstanceConnectEndpointStateDeleteInProgress Ec2InstanceConnectEndpointState = "delete-in-progress"
	Ec2InstanceConnectEndpointStateDeleteComplete   Ec2InstanceConnectEndpointState = "delete-complete"
	Ec2InstanceConnectEndpointStateDeleteFailed     Ec2InstanceConnectEndpointState = "delete-failed"
)

// Values returns all known values for Ec2InstanceConnectEndpointState. 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 (Ec2InstanceConnectEndpointState) Values() []Ec2InstanceConnectEndpointState {
	return []Ec2InstanceConnectEndpointState{
		"create-in-progress",
		"create-complete",
		"create-failed",
		"delete-in-progress",
		"delete-complete",
		"delete-failed",
	}
}

type EkPubKeyFormat string

// Enum values for EkPubKeyFormat
const (
	EkPubKeyFormatDer  EkPubKeyFormat = "der"
	EkPubKeyFormatTpmt EkPubKeyFormat = "tpmt"
)

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

type EkPubKeyType string

// Enum values for EkPubKeyType
const (
	EkPubKeyTypeRsa2048    EkPubKeyType = "rsa-2048"
	EkPubKeyTypeEccSecP384 EkPubKeyType = "ecc-sec-p384"
)

// Values returns all known values for EkPubKeyType. 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 (EkPubKeyType) Values() []EkPubKeyType {
	return []EkPubKeyType{
		"rsa-2048",
		"ecc-sec-p384",
	}
}

type ElasticGpuState string

// Enum values for ElasticGpuState
const (
	ElasticGpuStateAttached ElasticGpuState = "ATTACHED"
)

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

type ElasticGpuStatus string

// Enum values for ElasticGpuStatus
const (
	ElasticGpuStatusOk       ElasticGpuStatus = "OK"
	ElasticGpuStatusImpaired ElasticGpuStatus = "IMPAIRED"
)

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

type EnaSupport string

// Enum values for EnaSupport
const (
	EnaSupportUnsupported EnaSupport = "unsupported"
	EnaSupportSupported   EnaSupport = "supported"
	EnaSupportRequired    EnaSupport = "required"
)

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

type EndDateType string

// Enum values for EndDateType
const (
	EndDateTypeUnlimited EndDateType = "unlimited"
	EndDateTypeLimited   EndDateType = "limited"
)

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

type EphemeralNvmeSupport string

// Enum values for EphemeralNvmeSupport
const (
	EphemeralNvmeSupportUnsupported EphemeralNvmeSupport = "unsupported"
	EphemeralNvmeSupportSupported   EphemeralNvmeSupport = "supported"
	EphemeralNvmeSupportRequired    EphemeralNvmeSupport = "required"
)

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

type EventCode string

// Enum values for EventCode
const (
	EventCodeInstanceReboot     EventCode = "instance-reboot"
	EventCodeSystemReboot       EventCode = "system-reboot"
	EventCodeSystemMaintenance  EventCode = "system-maintenance"
	EventCodeInstanceRetirement EventCode = "instance-retirement"
	EventCodeInstanceStop       EventCode = "instance-stop"
)

// Values returns all known values for EventCode. 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 (EventCode) Values() []EventCode {
	return []EventCode{
		"instance-reboot",
		"system-reboot",
		"system-maintenance",
		"instance-retirement",
		"instance-stop",
	}
}

type EventType string

// Enum values for EventType
const (
	EventTypeInstanceChange EventType = "instanceChange"
	EventTypeBatchChange    EventType = "fleetRequestChange"
	EventTypeError          EventType = "error"
	EventTypeInformation    EventType = "information"
)

// Values returns all known values for EventType. 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 (EventType) Values() []EventType {
	return []EventType{
		"instanceChange",
		"fleetRequestChange",
		"error",
		"information",
	}
}

type ExcessCapacityTerminationPolicy string

// Enum values for ExcessCapacityTerminationPolicy
const (
	ExcessCapacityTerminationPolicyNoTermination ExcessCapacityTerminationPolicy = "noTermination"
	ExcessCapacityTerminationPolicyDefault       ExcessCapacityTerminationPolicy = "default"
)

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

type ExportEnvironment string

// Enum values for ExportEnvironment
const (
	ExportEnvironmentCitrix    ExportEnvironment = "citrix"
	ExportEnvironmentVmware    ExportEnvironment = "vmware"
	ExportEnvironmentMicrosoft ExportEnvironment = "microsoft"
)

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

type ExportTaskState string

// Enum values for ExportTaskState
const (
	ExportTaskStateActive     ExportTaskState = "active"
	ExportTaskStateCancelling ExportTaskState = "cancelling"
	ExportTaskStateCancelled  ExportTaskState = "cancelled"
	ExportTaskStateCompleted  ExportTaskState = "completed"
)

// Values returns all known values for ExportTaskState. 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 (ExportTaskState) Values() []ExportTaskState {
	return []ExportTaskState{
		"active",
		"cancelling",
		"cancelled",
		"completed",
	}
}

type FastLaunchResourceType string

// Enum values for FastLaunchResourceType
const (
	FastLaunchResourceTypeSnapshot FastLaunchResourceType = "snapshot"
)

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

type FastLaunchStateCode string

// Enum values for FastLaunchStateCode
const (
	FastLaunchStateCodeEnabling        FastLaunchStateCode = "enabling"
	FastLaunchStateCodeEnablingFailed  FastLaunchStateCode = "enabling-failed"
	FastLaunchStateCodeEnabled         FastLaunchStateCode = "enabled"
	FastLaunchStateCodeEnabledFailed   FastLaunchStateCode = "enabled-failed"
	FastLaunchStateCodeDisabling       FastLaunchStateCode = "disabling"
	FastLaunchStateCodeDisablingFailed FastLaunchStateCode = "disabling-failed"
)

// Values returns all known values for FastLaunchStateCode. 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 (FastLaunchStateCode) Values() []FastLaunchStateCode {
	return []FastLaunchStateCode{
		"enabling",
		"enabling-failed",
		"enabled",
		"enabled-failed",
		"disabling",
		"disabling-failed",
	}
}

type FastSnapshotRestoreStateCode string

// Enum values for FastSnapshotRestoreStateCode
const (
	FastSnapshotRestoreStateCodeEnabling   FastSnapshotRestoreStateCode = "enabling"
	FastSnapshotRestoreStateCodeOptimizing FastSnapshotRestoreStateCode = "optimizing"
	FastSnapshotRestoreStateCodeEnabled    FastSnapshotRestoreStateCode = "enabled"
	FastSnapshotRestoreStateCodeDisabling  FastSnapshotRestoreStateCode = "disabling"
	FastSnapshotRestoreStateCodeDisabled   FastSnapshotRestoreStateCode = "disabled"
)

// Values returns all known values for FastSnapshotRestoreStateCode. 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 (FastSnapshotRestoreStateCode) Values() []FastSnapshotRestoreStateCode {
	return []FastSnapshotRestoreStateCode{
		"enabling",
		"optimizing",
		"enabled",
		"disabling",
		"disabled",
	}
}

type FindingsFound string

// Enum values for FindingsFound
const (
	FindingsFoundTrue    FindingsFound = "true"
	FindingsFoundFalse   FindingsFound = "false"
	FindingsFoundUnknown FindingsFound = "unknown"
)

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

type FleetActivityStatus string

// Enum values for FleetActivityStatus
const (
	FleetActivityStatusError              FleetActivityStatus = "error"
	FleetActivityStatusPendingFulfillment FleetActivityStatus = "pending_fulfillment"
	FleetActivityStatusPendingTermination FleetActivityStatus = "pending_termination"
	FleetActivityStatusFulfilled          FleetActivityStatus = "fulfilled"
)

// Values returns all known values for FleetActivityStatus. 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 (FleetActivityStatus) Values() []FleetActivityStatus {
	return []FleetActivityStatus{
		"error",
		"pending_fulfillment",
		"pending_termination",
		"fulfilled",
	}
}

type FleetCapacityReservationTenancy string

// Enum values for FleetCapacityReservationTenancy
const (
	FleetCapacityReservationTenancyDefault FleetCapacityReservationTenancy = "default"
)

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

type FleetCapacityReservationUsageStrategy string

// Enum values for FleetCapacityReservationUsageStrategy
const (
	FleetCapacityReservationUsageStrategyUseCapacityReservationsFirst FleetCapacityReservationUsageStrategy = "use-capacity-reservations-first"
)

// Values returns all known values for FleetCapacityReservationUsageStrategy. 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 (FleetCapacityReservationUsageStrategy) Values() []FleetCapacityReservationUsageStrategy {
	return []FleetCapacityReservationUsageStrategy{
		"use-capacity-reservations-first",
	}
}

type FleetEventType string

// Enum values for FleetEventType
const (
	FleetEventTypeInstanceChange FleetEventType = "instance-change"
	FleetEventTypeFleetChange    FleetEventType = "fleet-change"
	FleetEventTypeServiceError   FleetEventType = "service-error"
)

// Values returns all known values for FleetEventType. 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 (FleetEventType) Values() []FleetEventType {
	return []FleetEventType{
		"instance-change",
		"fleet-change",
		"service-error",
	}
}

type FleetExcessCapacityTerminationPolicy string

// Enum values for FleetExcessCapacityTerminationPolicy
const (
	FleetExcessCapacityTerminationPolicyNoTermination FleetExcessCapacityTerminationPolicy = "no-termination"
	FleetExcessCapacityTerminationPolicyTermination   FleetExcessCapacityTerminationPolicy = "termination"
)

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

type FleetInstanceMatchCriteria string

// Enum values for FleetInstanceMatchCriteria
const (
	FleetInstanceMatchCriteriaOpen FleetInstanceMatchCriteria = "open"
)

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

type FleetOnDemandAllocationStrategy string

// Enum values for FleetOnDemandAllocationStrategy
const (
	FleetOnDemandAllocationStrategyLowestPrice FleetOnDemandAllocationStrategy = "lowest-price"
	FleetOnDemandAllocationStrategyPrioritized FleetOnDemandAllocationStrategy = "prioritized"
)

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

type FleetReplacementStrategy string

// Enum values for FleetReplacementStrategy
const (
	FleetReplacementStrategyLaunch                FleetReplacementStrategy = "launch"
	FleetReplacementStrategyLaunchBeforeTerminate FleetReplacementStrategy = "launch-before-terminate"
)

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

type FleetStateCode string

// Enum values for FleetStateCode
const (
	FleetStateCodeSubmitted                   FleetStateCode = "submitted"
	FleetStateCodeActive                      FleetStateCode = "active"
	FleetStateCodeDeleted                     FleetStateCode = "deleted"
	FleetStateCodeFailed                      FleetStateCode = "failed"
	FleetStateCodeDeletedRunning              FleetStateCode = "deleted_running"
	FleetStateCodeDeletedTerminatingInstances FleetStateCode = "deleted_terminating"
	FleetStateCodeModifying                   FleetStateCode = "modifying"
)

// Values returns all known values for FleetStateCode. 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 (FleetStateCode) Values() []FleetStateCode {
	return []FleetStateCode{
		"submitted",
		"active",
		"deleted",
		"failed",
		"deleted_running",
		"deleted_terminating",
		"modifying",
	}
}

type FleetType string

// Enum values for FleetType
const (
	FleetTypeRequest  FleetType = "request"
	FleetTypeMaintain FleetType = "maintain"
	FleetTypeInstant  FleetType = "instant"
)

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

type FlowLogsResourceType string

// Enum values for FlowLogsResourceType
const (
	FlowLogsResourceTypeVpc                      FlowLogsResourceType = "VPC"
	FlowLogsResourceTypeSubnet                   FlowLogsResourceType = "Subnet"
	FlowLogsResourceTypeNetworkInterface         FlowLogsResourceType = "NetworkInterface"
	FlowLogsResourceTypeTransitGateway           FlowLogsResourceType = "TransitGateway"
	FlowLogsResourceTypeTransitGatewayAttachment FlowLogsResourceType = "TransitGatewayAttachment"
)

// Values returns all known values for FlowLogsResourceType. 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 (FlowLogsResourceType) Values() []FlowLogsResourceType {
	return []FlowLogsResourceType{
		"VPC",
		"Subnet",
		"NetworkInterface",
		"TransitGateway",
		"TransitGatewayAttachment",
	}
}

type FpgaImageAttributeName string

// Enum values for FpgaImageAttributeName
const (
	FpgaImageAttributeNameDescription    FpgaImageAttributeName = "description"
	FpgaImageAttributeNameName           FpgaImageAttributeName = "name"
	FpgaImageAttributeNameLoadPermission FpgaImageAttributeName = "loadPermission"
	FpgaImageAttributeNameProductCodes   FpgaImageAttributeName = "productCodes"
)

// Values returns all known values for FpgaImageAttributeName. 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 (FpgaImageAttributeName) Values() []FpgaImageAttributeName {
	return []FpgaImageAttributeName{
		"description",
		"name",
		"loadPermission",
		"productCodes",
	}
}

type FpgaImageStateCode string

// Enum values for FpgaImageStateCode
const (
	FpgaImageStateCodePending     FpgaImageStateCode = "pending"
	FpgaImageStateCodeFailed      FpgaImageStateCode = "failed"
	FpgaImageStateCodeAvailable   FpgaImageStateCode = "available"
	FpgaImageStateCodeUnavailable FpgaImageStateCode = "unavailable"
)

// Values returns all known values for FpgaImageStateCode. 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 (FpgaImageStateCode) Values() []FpgaImageStateCode {
	return []FpgaImageStateCode{
		"pending",
		"failed",
		"available",
		"unavailable",
	}
}

type GatewayAssociationState string

// Enum values for GatewayAssociationState
const (
	GatewayAssociationStateAssociated     GatewayAssociationState = "associated"
	GatewayAssociationStateNotAssociated  GatewayAssociationState = "not-associated"
	GatewayAssociationStateAssociating    GatewayAssociationState = "associating"
	GatewayAssociationStateDisassociating GatewayAssociationState = "disassociating"
)

// Values returns all known values for GatewayAssociationState. 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 (GatewayAssociationState) Values() []GatewayAssociationState {
	return []GatewayAssociationState{
		"associated",
		"not-associated",
		"associating",
		"disassociating",
	}
}

type GatewayType string

// Enum values for GatewayType
const (
	GatewayTypeIpsec1 GatewayType = "ipsec.1"
)

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

type HostMaintenance string

// Enum values for HostMaintenance
const (
	HostMaintenanceOn  HostMaintenance = "on"
	HostMaintenanceOff HostMaintenance = "off"
)

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

type HostnameType string

// Enum values for HostnameType
const (
	HostnameTypeIpName       HostnameType = "ip-name"
	HostnameTypeResourceName HostnameType = "resource-name"
)

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

type HostRecovery string

// Enum values for HostRecovery
const (
	HostRecoveryOn  HostRecovery = "on"
	HostRecoveryOff HostRecovery = "off"
)

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

type HostTenancy string

// Enum values for HostTenancy
const (
	HostTenancyDefault   HostTenancy = "default"
	HostTenancyDedicated HostTenancy = "dedicated"
	HostTenancyHost      HostTenancy = "host"
)

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

type HttpTokensState string

// Enum values for HttpTokensState
const (
	HttpTokensStateOptional HttpTokensState = "optional"
	HttpTokensStateRequired HttpTokensState = "required"
)

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

type HypervisorType string

// Enum values for HypervisorType
const (
	HypervisorTypeOvm HypervisorType = "ovm"
	HypervisorTypeXen HypervisorType = "xen"
)

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

type IamInstanceProfileAssociationState string

// Enum values for IamInstanceProfileAssociationState
const (
	IamInstanceProfileAssociationStateAssociating    IamInstanceProfileAssociationState = "associating"
	IamInstanceProfileAssociationStateAssociated     IamInstanceProfileAssociationState = "associated"
	IamInstanceProfileAssociationStateDisassociating IamInstanceProfileAssociationState = "disassociating"
	IamInstanceProfileAssociationStateDisassociated  IamInstanceProfileAssociationState = "disassociated"
)

// Values returns all known values for IamInstanceProfileAssociationState. 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 (IamInstanceProfileAssociationState) Values() []IamInstanceProfileAssociationState {
	return []IamInstanceProfileAssociationState{
		"associating",
		"associated",
		"disassociating",
		"disassociated",
	}
}

type Igmpv2SupportValue string

// Enum values for Igmpv2SupportValue
const (
	Igmpv2SupportValueEnable  Igmpv2SupportValue = "enable"
	Igmpv2SupportValueDisable Igmpv2SupportValue = "disable"
)

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

type ImageAttributeName string

// Enum values for ImageAttributeName
const (
	ImageAttributeNameDescription              ImageAttributeName = "description"
	ImageAttributeNameKernel                   ImageAttributeName = "kernel"
	ImageAttributeNameRamdisk                  ImageAttributeName = "ramdisk"
	ImageAttributeNameLaunchPermission         ImageAttributeName = "launchPermission"
	ImageAttributeNameProductCodes             ImageAttributeName = "productCodes"
	ImageAttributeNameBlockDeviceMapping       ImageAttributeName = "blockDeviceMapping"
	ImageAttributeNameSriovNetSupport          ImageAttributeName = "sriovNetSupport"
	ImageAttributeNameBootMode                 ImageAttributeName = "bootMode"
	ImageAttributeNameTpmSupport               ImageAttributeName = "tpmSupport"
	ImageAttributeNameUefiData                 ImageAttributeName = "uefiData"
	ImageAttributeNameLastLaunchedTime         ImageAttributeName = "lastLaunchedTime"
	ImageAttributeNameImdsSupport              ImageAttributeName = "imdsSupport"
	ImageAttributeNameDeregistrationProtection ImageAttributeName = "deregistrationProtection"
)

// Values returns all known values for ImageAttributeName. 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 (ImageAttributeName) Values() []ImageAttributeName {
	return []ImageAttributeName{
		"description",
		"kernel",
		"ramdisk",
		"launchPermission",
		"productCodes",
		"blockDeviceMapping",
		"sriovNetSupport",
		"bootMode",
		"tpmSupport",
		"uefiData",
		"lastLaunchedTime",
		"imdsSupport",
		"deregistrationProtection",
	}
}

type ImageBlockPublicAccessDisabledState string

// Enum values for ImageBlockPublicAccessDisabledState
const (
	ImageBlockPublicAccessDisabledStateUnblocked ImageBlockPublicAccessDisabledState = "unblocked"
)

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

type ImageBlockPublicAccessEnabledState string

// Enum values for ImageBlockPublicAccessEnabledState
const (
	ImageBlockPublicAccessEnabledStateBlockNewSharing ImageBlockPublicAccessEnabledState = "block-new-sharing"
)

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

type ImageState string

// Enum values for ImageState
const (
	ImageStatePending      ImageState = "pending"
	ImageStateAvailable    ImageState = "available"
	ImageStateInvalid      ImageState = "invalid"
	ImageStateDeregistered ImageState = "deregistered"
	ImageStateTransient    ImageState = "transient"
	ImageStateFailed       ImageState = "failed"
	ImageStateError        ImageState = "error"
	ImageStateDisabled     ImageState = "disabled"
)

// Values returns all known values for ImageState. 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 (ImageState) Values() []ImageState {
	return []ImageState{
		"pending",
		"available",
		"invalid",
		"deregistered",
		"transient",
		"failed",
		"error",
		"disabled",
	}
}

type ImageTypeValues string

// Enum values for ImageTypeValues
const (
	ImageTypeValuesMachine ImageTypeValues = "machine"
	ImageTypeValuesKernel  ImageTypeValues = "kernel"
	ImageTypeValuesRamdisk ImageTypeValues = "ramdisk"
)

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

type ImdsSupportValues string

// Enum values for ImdsSupportValues
const (
	ImdsSupportValuesV20 ImdsSupportValues = "v2.0"
)

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

type InstanceAttributeName string

// Enum values for InstanceAttributeName
const (
	InstanceAttributeNameInstanceType                      InstanceAttributeName = "instanceType"
	InstanceAttributeNameKernel                            InstanceAttributeName = "kernel"
	InstanceAttributeNameRamdisk                           InstanceAttributeName = "ramdisk"
	InstanceAttributeNameUserData                          InstanceAttributeName = "userData"
	InstanceAttributeNameDisableApiTermination             InstanceAttributeName = "disableApiTermination"
	InstanceAttributeNameInstanceInitiatedShutdownBehavior InstanceAttributeName = "instanceInitiatedShutdownBehavior"
	InstanceAttributeNameRootDeviceName                    InstanceAttributeName = "rootDeviceName"
	InstanceAttributeNameBlockDeviceMapping                InstanceAttributeName = "blockDeviceMapping"
	InstanceAttributeNameProductCodes                      InstanceAttributeName = "productCodes"
	InstanceAttributeNameSourceDestCheck                   InstanceAttributeName = "sourceDestCheck"
	InstanceAttributeNameGroupSet                          InstanceAttributeName = "groupSet"
	InstanceAttributeNameEbsOptimized                      InstanceAttributeName = "ebsOptimized"
	InstanceAttributeNameSriovNetSupport                   InstanceAttributeName = "sriovNetSupport"
	InstanceAttributeNameEnaSupport                        InstanceAttributeName = "enaSupport"
	InstanceAttributeNameEnclaveOptions                    InstanceAttributeName = "enclaveOptions"
	InstanceAttributeNameDisableApiStop                    InstanceAttributeName = "disableApiStop"
)

// Values returns all known values for InstanceAttributeName. 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 (InstanceAttributeName) Values() []InstanceAttributeName {
	return []InstanceAttributeName{
		"instanceType",
		"kernel",
		"ramdisk",
		"userData",
		"disableApiTermination",
		"instanceInitiatedShutdownBehavior",
		"rootDeviceName",
		"blockDeviceMapping",
		"productCodes",
		"sourceDestCheck",
		"groupSet",
		"ebsOptimized",
		"sriovNetSupport",
		"enaSupport",
		"enclaveOptions",
		"disableApiStop",
	}
}

type InstanceAutoRecoveryState string

// Enum values for InstanceAutoRecoveryState
const (
	InstanceAutoRecoveryStateDisabled InstanceAutoRecoveryState = "disabled"
	InstanceAutoRecoveryStateDefault  InstanceAutoRecoveryState = "default"
)

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

type InstanceBootModeValues string

// Enum values for InstanceBootModeValues
const (
	InstanceBootModeValuesLegacyBios InstanceBootModeValues = "legacy-bios"
	InstanceBootModeValuesUefi       InstanceBootModeValues = "uefi"
)

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

type InstanceEventWindowState string

// Enum values for InstanceEventWindowState
const (
	InstanceEventWindowStateCreating InstanceEventWindowState = "creating"
	InstanceEventWindowStateDeleting InstanceEventWindowState = "deleting"
	InstanceEventWindowStateActive   InstanceEventWindowState = "active"
	InstanceEventWindowStateDeleted  InstanceEventWindowState = "deleted"
)

// Values returns all known values for InstanceEventWindowState. 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 (InstanceEventWindowState) Values() []InstanceEventWindowState {
	return []InstanceEventWindowState{
		"creating",
		"deleting",
		"active",
		"deleted",
	}
}

type InstanceGeneration string

// Enum values for InstanceGeneration
const (
	InstanceGenerationCurrent  InstanceGeneration = "current"
	InstanceGenerationPrevious InstanceGeneration = "previous"
)

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

type InstanceHealthStatus string

// Enum values for InstanceHealthStatus
const (
	InstanceHealthStatusHealthyStatus   InstanceHealthStatus = "healthy"
	InstanceHealthStatusUnhealthyStatus InstanceHealthStatus = "unhealthy"
)

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

type InstanceInterruptionBehavior string

// Enum values for InstanceInterruptionBehavior
const (
	InstanceInterruptionBehaviorHibernate InstanceInterruptionBehavior = "hibernate"
	InstanceInterruptionBehaviorStop      InstanceInterruptionBehavior = "stop"
	InstanceInterruptionBehaviorTerminate InstanceInterruptionBehavior = "terminate"
)

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

type InstanceLifecycle string

// Enum values for InstanceLifecycle
const (
	InstanceLifecycleSpot     InstanceLifecycle = "spot"
	InstanceLifecycleOnDemand InstanceLifecycle = "on-demand"
)

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

type InstanceLifecycleType string

// Enum values for InstanceLifecycleType
const (
	InstanceLifecycleTypeSpot          InstanceLifecycleType = "spot"
	InstanceLifecycleTypeScheduled     InstanceLifecycleType = "scheduled"
	InstanceLifecycleTypeCapacityBlock InstanceLifecycleType = "capacity-block"
)

// Values returns all known values for InstanceLifecycleType. 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 (InstanceLifecycleType) Values() []InstanceLifecycleType {
	return []InstanceLifecycleType{
		"spot",
		"scheduled",
		"capacity-block",
	}
}

type InstanceMatchCriteria string

// Enum values for InstanceMatchCriteria
const (
	InstanceMatchCriteriaOpen     InstanceMatchCriteria = "open"
	InstanceMatchCriteriaTargeted InstanceMatchCriteria = "targeted"
)

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

type InstanceMetadataEndpointState string

// Enum values for InstanceMetadataEndpointState
const (
	InstanceMetadataEndpointStateDisabled InstanceMetadataEndpointState = "disabled"
	InstanceMetadataEndpointStateEnabled  InstanceMetadataEndpointState = "enabled"
)

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

type InstanceMetadataOptionsState string

// Enum values for InstanceMetadataOptionsState
const (
	InstanceMetadataOptionsStatePending InstanceMetadataOptionsState = "pending"
	InstanceMetadataOptionsStateApplied InstanceMetadataOptionsState = "applied"
)

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

type InstanceMetadataProtocolState string

// Enum values for InstanceMetadataProtocolState
const (
	InstanceMetadataProtocolStateDisabled InstanceMetadataProtocolState = "disabled"
	InstanceMetadataProtocolStateEnabled  InstanceMetadataProtocolState = "enabled"
)

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

type InstanceMetadataTagsState string

// Enum values for InstanceMetadataTagsState
const (
	InstanceMetadataTagsStateDisabled InstanceMetadataTagsState = "disabled"
	InstanceMetadataTagsStateEnabled  InstanceMetadataTagsState = "enabled"
)

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

type InstanceStateName string

// Enum values for InstanceStateName
const (
	InstanceStateNamePending      InstanceStateName = "pending"
	InstanceStateNameRunning      InstanceStateName = "running"
	InstanceStateNameShuttingDown InstanceStateName = "shutting-down"
	InstanceStateNameTerminated   InstanceStateName = "terminated"
	InstanceStateNameStopping     InstanceStateName = "stopping"
	InstanceStateNameStopped      InstanceStateName = "stopped"
)

// Values returns all known values for InstanceStateName. 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 (InstanceStateName) Values() []InstanceStateName {
	return []InstanceStateName{
		"pending",
		"running",
		"shutting-down",
		"terminated",
		"stopping",
		"stopped",
	}
}

type InstanceStorageEncryptionSupport string

// Enum values for InstanceStorageEncryptionSupport
const (
	InstanceStorageEncryptionSupportUnsupported InstanceStorageEncryptionSupport = "unsupported"
	InstanceStorageEncryptionSupportRequired    InstanceStorageEncryptionSupport = "required"
)

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

type InstanceType string

// Enum values for InstanceType
const (
	InstanceTypeA1Medium          InstanceType = "a1.medium"
	InstanceTypeA1Large           InstanceType = "a1.large"
	InstanceTypeA1Xlarge          InstanceType = "a1.xlarge"
	InstanceTypeA12xlarge         InstanceType = "a1.2xlarge"
	InstanceTypeA14xlarge         InstanceType = "a1.4xlarge"
	InstanceTypeA1Metal           InstanceType = "a1.metal"
	InstanceTypeC1Medium          InstanceType = "c1.medium"
	InstanceTypeC1Xlarge          InstanceType = "c1.xlarge"
	InstanceTypeC3Large           InstanceType = "c3.large"
	InstanceTypeC3Xlarge          InstanceType = "c3.xlarge"
	InstanceTypeC32xlarge         InstanceType = "c3.2xlarge"
	InstanceTypeC34xlarge         InstanceType = "c3.4xlarge"
	InstanceTypeC38xlarge         InstanceType = "c3.8xlarge"
	InstanceTypeC4Large           InstanceType = "c4.large"
	InstanceTypeC4Xlarge          InstanceType = "c4.xlarge"
	InstanceTypeC42xlarge         InstanceType = "c4.2xlarge"
	InstanceTypeC44xlarge         InstanceType = "c4.4xlarge"
	InstanceTypeC48xlarge         InstanceType = "c4.8xlarge"
	InstanceTypeC5Large           InstanceType = "c5.large"
	InstanceTypeC5Xlarge          InstanceType = "c5.xlarge"
	InstanceTypeC52xlarge         InstanceType = "c5.2xlarge"
	InstanceTypeC54xlarge         InstanceType = "c5.4xlarge"
	InstanceTypeC59xlarge         InstanceType = "c5.9xlarge"
	InstanceTypeC512xlarge        InstanceType = "c5.12xlarge"
	InstanceTypeC518xlarge        InstanceType = "c5.18xlarge"
	InstanceTypeC524xlarge        InstanceType = "c5.24xlarge"
	InstanceTypeC5Metal           InstanceType = "c5.metal"
	InstanceTypeC5aLarge          InstanceType = "c5a.large"
	InstanceTypeC5aXlarge         InstanceType = "c5a.xlarge"
	InstanceTypeC5a2xlarge        InstanceType = "c5a.2xlarge"
	InstanceTypeC5a4xlarge        InstanceType = "c5a.4xlarge"
	InstanceTypeC5a8xlarge        InstanceType = "c5a.8xlarge"
	InstanceTypeC5a12xlarge       InstanceType = "c5a.12xlarge"
	InstanceTypeC5a16xlarge       InstanceType = "c5a.16xlarge"
	InstanceTypeC5a24xlarge       InstanceType = "c5a.24xlarge"
	InstanceTypeC5adLarge         InstanceType = "c5ad.large"
	InstanceTypeC5adXlarge        InstanceType = "c5ad.xlarge"
	InstanceTypeC5ad2xlarge       InstanceType = "c5ad.2xlarge"
	InstanceTypeC5ad4xlarge       InstanceType = "c5ad.4xlarge"
	InstanceTypeC5ad8xlarge       InstanceType = "c5ad.8xlarge"
	InstanceTypeC5ad12xlarge      InstanceType = "c5ad.12xlarge"
	InstanceTypeC5ad16xlarge      InstanceType = "c5ad.16xlarge"
	InstanceTypeC5ad24xlarge      InstanceType = "c5ad.24xlarge"
	InstanceTypeC5dLarge          InstanceType = "c5d.large"
	InstanceTypeC5dXlarge         InstanceType = "c5d.xlarge"
	InstanceTypeC5d2xlarge        InstanceType = "c5d.2xlarge"
	InstanceTypeC5d4xlarge        InstanceType = "c5d.4xlarge"
	InstanceTypeC5d9xlarge        InstanceType = "c5d.9xlarge"
	InstanceTypeC5d12xlarge       InstanceType = "c5d.12xlarge"
	InstanceTypeC5d18xlarge       InstanceType = "c5d.18xlarge"
	InstanceTypeC5d24xlarge       InstanceType = "c5d.24xlarge"
	InstanceTypeC5dMetal          InstanceType = "c5d.metal"
	InstanceTypeC5nLarge          InstanceType = "c5n.large"
	InstanceTypeC5nXlarge         InstanceType = "c5n.xlarge"
	InstanceTypeC5n2xlarge        InstanceType = "c5n.2xlarge"
	InstanceTypeC5n4xlarge        InstanceType = "c5n.4xlarge"
	InstanceTypeC5n9xlarge        InstanceType = "c5n.9xlarge"
	InstanceTypeC5n18xlarge       InstanceType = "c5n.18xlarge"
	InstanceTypeC5nMetal          InstanceType = "c5n.metal"
	InstanceTypeC6gMedium         InstanceType = "c6g.medium"
	InstanceTypeC6gLarge          InstanceType = "c6g.large"
	InstanceTypeC6gXlarge         InstanceType = "c6g.xlarge"
	InstanceTypeC6g2xlarge        InstanceType = "c6g.2xlarge"
	InstanceTypeC6g4xlarge        InstanceType = "c6g.4xlarge"
	InstanceTypeC6g8xlarge        InstanceType = "c6g.8xlarge"
	InstanceTypeC6g12xlarge       InstanceType = "c6g.12xlarge"
	InstanceTypeC6g16xlarge       InstanceType = "c6g.16xlarge"
	InstanceTypeC6gMetal          InstanceType = "c6g.metal"
	InstanceTypeC6gdMedium        InstanceType = "c6gd.medium"
	InstanceTypeC6gdLarge         InstanceType = "c6gd.large"
	InstanceTypeC6gdXlarge        InstanceType = "c6gd.xlarge"
	InstanceTypeC6gd2xlarge       InstanceType = "c6gd.2xlarge"
	InstanceTypeC6gd4xlarge       InstanceType = "c6gd.4xlarge"
	InstanceTypeC6gd8xlarge       InstanceType = "c6gd.8xlarge"
	InstanceTypeC6gd12xlarge      InstanceType = "c6gd.12xlarge"
	InstanceTypeC6gd16xlarge      InstanceType = "c6gd.16xlarge"
	InstanceTypeC6gdMetal         InstanceType = "c6gd.metal"
	InstanceTypeC6gnMedium        InstanceType = "c6gn.medium"
	InstanceTypeC6gnLarge         InstanceType = "c6gn.large"
	InstanceTypeC6gnXlarge        InstanceType = "c6gn.xlarge"
	InstanceTypeC6gn2xlarge       InstanceType = "c6gn.2xlarge"
	InstanceTypeC6gn4xlarge       InstanceType = "c6gn.4xlarge"
	InstanceTypeC6gn8xlarge       InstanceType = "c6gn.8xlarge"
	InstanceTypeC6gn12xlarge      InstanceType = "c6gn.12xlarge"
	InstanceTypeC6gn16xlarge      InstanceType = "c6gn.16xlarge"
	InstanceTypeC6iLarge          InstanceType = "c6i.large"
	InstanceTypeC6iXlarge         InstanceType = "c6i.xlarge"
	InstanceTypeC6i2xlarge        InstanceType = "c6i.2xlarge"
	InstanceTypeC6i4xlarge        InstanceType = "c6i.4xlarge"
	InstanceTypeC6i8xlarge        InstanceType = "c6i.8xlarge"
	InstanceTypeC6i12xlarge       InstanceType = "c6i.12xlarge"
	InstanceTypeC6i16xlarge       InstanceType = "c6i.16xlarge"
	InstanceTypeC6i24xlarge       InstanceType = "c6i.24xlarge"
	InstanceTypeC6i32xlarge       InstanceType = "c6i.32xlarge"
	InstanceTypeC6iMetal          InstanceType = "c6i.metal"
	InstanceTypeCc14xlarge        InstanceType = "cc1.4xlarge"
	InstanceTypeCc28xlarge        InstanceType = "cc2.8xlarge"
	InstanceTypeCg14xlarge        InstanceType = "cg1.4xlarge"
	InstanceTypeCr18xlarge        InstanceType = "cr1.8xlarge"
	InstanceTypeD2Xlarge          InstanceType = "d2.xlarge"
	InstanceTypeD22xlarge         InstanceType = "d2.2xlarge"
	InstanceTypeD24xlarge         InstanceType = "d2.4xlarge"
	InstanceTypeD28xlarge         InstanceType = "d2.8xlarge"
	InstanceTypeD3Xlarge          InstanceType = "d3.xlarge"
	InstanceTypeD32xlarge         InstanceType = "d3.2xlarge"
	InstanceTypeD34xlarge         InstanceType = "d3.4xlarge"
	InstanceTypeD38xlarge         InstanceType = "d3.8xlarge"
	InstanceTypeD3enXlarge        InstanceType = "d3en.xlarge"
	InstanceTypeD3en2xlarge       InstanceType = "d3en.2xlarge"
	InstanceTypeD3en4xlarge       InstanceType = "d3en.4xlarge"
	InstanceTypeD3en6xlarge       InstanceType = "d3en.6xlarge"
	InstanceTypeD3en8xlarge       InstanceType = "d3en.8xlarge"
	InstanceTypeD3en12xlarge      InstanceType = "d3en.12xlarge"
	InstanceTypeDl124xlarge       InstanceType = "dl1.24xlarge"
	InstanceTypeF12xlarge         InstanceType = "f1.2xlarge"
	InstanceTypeF14xlarge         InstanceType = "f1.4xlarge"
	InstanceTypeF116xlarge        InstanceType = "f1.16xlarge"
	InstanceTypeG22xlarge         InstanceType = "g2.2xlarge"
	InstanceTypeG28xlarge         InstanceType = "g2.8xlarge"
	InstanceTypeG34xlarge         InstanceType = "g3.4xlarge"
	InstanceTypeG38xlarge         InstanceType = "g3.8xlarge"
	InstanceTypeG316xlarge        InstanceType = "g3.16xlarge"
	InstanceTypeG3sXlarge         InstanceType = "g3s.xlarge"
	InstanceTypeG4adXlarge        InstanceType = "g4ad.xlarge"
	InstanceTypeG4ad2xlarge       InstanceType = "g4ad.2xlarge"
	InstanceTypeG4ad4xlarge       InstanceType = "g4ad.4xlarge"
	InstanceTypeG4ad8xlarge       InstanceType = "g4ad.8xlarge"
	InstanceTypeG4ad16xlarge      InstanceType = "g4ad.16xlarge"
	InstanceTypeG4dnXlarge        InstanceType = "g4dn.xlarge"
	InstanceTypeG4dn2xlarge       InstanceType = "g4dn.2xlarge"
	InstanceTypeG4dn4xlarge       InstanceType = "g4dn.4xlarge"
	InstanceTypeG4dn8xlarge       InstanceType = "g4dn.8xlarge"
	InstanceTypeG4dn12xlarge      InstanceType = "g4dn.12xlarge"
	InstanceTypeG4dn16xlarge      InstanceType = "g4dn.16xlarge"
	InstanceTypeG4dnMetal         InstanceType = "g4dn.metal"
	InstanceTypeG5Xlarge          InstanceType = "g5.xlarge"
	InstanceTypeG52xlarge         InstanceType = "g5.2xlarge"
	InstanceTypeG54xlarge         InstanceType = "g5.4xlarge"
	InstanceTypeG58xlarge         InstanceType = "g5.8xlarge"
	InstanceTypeG512xlarge        InstanceType = "g5.12xlarge"
	InstanceTypeG516xlarge        InstanceType = "g5.16xlarge"
	InstanceTypeG524xlarge        InstanceType = "g5.24xlarge"
	InstanceTypeG548xlarge        InstanceType = "g5.48xlarge"
	InstanceTypeG5gXlarge         InstanceType = "g5g.xlarge"
	InstanceTypeG5g2xlarge        InstanceType = "g5g.2xlarge"
	InstanceTypeG5g4xlarge        InstanceType = "g5g.4xlarge"
	InstanceTypeG5g8xlarge        InstanceType = "g5g.8xlarge"
	InstanceTypeG5g16xlarge       InstanceType = "g5g.16xlarge"
	InstanceTypeG5gMetal          InstanceType = "g5g.metal"
	InstanceTypeHi14xlarge        InstanceType = "hi1.4xlarge"
	InstanceTypeHpc6a48xlarge     InstanceType = "hpc6a.48xlarge"
	InstanceTypeHs18xlarge        InstanceType = "hs1.8xlarge"
	InstanceTypeH12xlarge         InstanceType = "h1.2xlarge"
	InstanceTypeH14xlarge         InstanceType = "h1.4xlarge"
	InstanceTypeH18xlarge         InstanceType = "h1.8xlarge"
	InstanceTypeH116xlarge        InstanceType = "h1.16xlarge"
	InstanceTypeI2Xlarge          InstanceType = "i2.xlarge"
	InstanceTypeI22xlarge         InstanceType = "i2.2xlarge"
	InstanceTypeI24xlarge         InstanceType = "i2.4xlarge"
	InstanceTypeI28xlarge         InstanceType = "i2.8xlarge"
	InstanceTypeI3Large           InstanceType = "i3.large"
	InstanceTypeI3Xlarge          InstanceType = "i3.xlarge"
	InstanceTypeI32xlarge         InstanceType = "i3.2xlarge"
	InstanceTypeI34xlarge         InstanceType = "i3.4xlarge"
	InstanceTypeI38xlarge         InstanceType = "i3.8xlarge"
	InstanceTypeI316xlarge        InstanceType = "i3.16xlarge"
	InstanceTypeI3Metal           InstanceType = "i3.metal"
	InstanceTypeI3enLarge         InstanceType = "i3en.large"
	InstanceTypeI3enXlarge        InstanceType = "i3en.xlarge"
	InstanceTypeI3en2xlarge       InstanceType = "i3en.2xlarge"
	InstanceTypeI3en3xlarge       InstanceType = "i3en.3xlarge"
	InstanceTypeI3en6xlarge       InstanceType = "i3en.6xlarge"
	InstanceTypeI3en12xlarge      InstanceType = "i3en.12xlarge"
	InstanceTypeI3en24xlarge      InstanceType = "i3en.24xlarge"
	InstanceTypeI3enMetal         InstanceType = "i3en.metal"
	InstanceTypeIm4gnLarge        InstanceType = "im4gn.large"
	InstanceTypeIm4gnXlarge       InstanceType = "im4gn.xlarge"
	InstanceTypeIm4gn2xlarge      InstanceType = "im4gn.2xlarge"
	InstanceTypeIm4gn4xlarge      InstanceType = "im4gn.4xlarge"
	InstanceTypeIm4gn8xlarge      InstanceType = "im4gn.8xlarge"
	InstanceTypeIm4gn16xlarge     InstanceType = "im4gn.16xlarge"
	InstanceTypeInf1Xlarge        InstanceType = "inf1.xlarge"
	InstanceTypeInf12xlarge       InstanceType = "inf1.2xlarge"
	InstanceTypeInf16xlarge       InstanceType = "inf1.6xlarge"
	InstanceTypeInf124xlarge      InstanceType = "inf1.24xlarge"
	InstanceTypeIs4genMedium      InstanceType = "is4gen.medium"
	InstanceTypeIs4genLarge       InstanceType = "is4gen.large"
	InstanceTypeIs4genXlarge      InstanceType = "is4gen.xlarge"
	InstanceTypeIs4gen2xlarge     InstanceType = "is4gen.2xlarge"
	InstanceTypeIs4gen4xlarge     InstanceType = "is4gen.4xlarge"
	InstanceTypeIs4gen8xlarge     InstanceType = "is4gen.8xlarge"
	InstanceTypeM1Small           InstanceType = "m1.small"
	InstanceTypeM1Medium          InstanceType = "m1.medium"
	InstanceTypeM1Large           InstanceType = "m1.large"
	InstanceTypeM1Xlarge          InstanceType = "m1.xlarge"
	InstanceTypeM2Xlarge          InstanceType = "m2.xlarge"
	InstanceTypeM22xlarge         InstanceType = "m2.2xlarge"
	InstanceTypeM24xlarge         InstanceType = "m2.4xlarge"
	InstanceTypeM3Medium          InstanceType = "m3.medium"
	InstanceTypeM3Large           InstanceType = "m3.large"
	InstanceTypeM3Xlarge          InstanceType = "m3.xlarge"
	InstanceTypeM32xlarge         InstanceType = "m3.2xlarge"
	InstanceTypeM4Large           InstanceType = "m4.large"
	InstanceTypeM4Xlarge          InstanceType = "m4.xlarge"
	InstanceTypeM42xlarge         InstanceType = "m4.2xlarge"
	InstanceTypeM44xlarge         InstanceType = "m4.4xlarge"
	InstanceTypeM410xlarge        InstanceType = "m4.10xlarge"
	InstanceTypeM416xlarge        InstanceType = "m4.16xlarge"
	InstanceTypeM5Large           InstanceType = "m5.large"
	InstanceTypeM5Xlarge          InstanceType = "m5.xlarge"
	InstanceTypeM52xlarge         InstanceType = "m5.2xlarge"
	InstanceTypeM54xlarge         InstanceType = "m5.4xlarge"
	InstanceTypeM58xlarge         InstanceType = "m5.8xlarge"
	InstanceTypeM512xlarge        InstanceType = "m5.12xlarge"
	InstanceTypeM516xlarge        InstanceType = "m5.16xlarge"
	InstanceTypeM524xlarge        InstanceType = "m5.24xlarge"
	InstanceTypeM5Metal           InstanceType = "m5.metal"
	InstanceTypeM5aLarge          InstanceType = "m5a.large"
	InstanceTypeM5aXlarge         InstanceType = "m5a.xlarge"
	InstanceTypeM5a2xlarge        InstanceType = "m5a.2xlarge"
	InstanceTypeM5a4xlarge        InstanceType = "m5a.4xlarge"
	InstanceTypeM5a8xlarge        InstanceType = "m5a.8xlarge"
	InstanceTypeM5a12xlarge       InstanceType = "m5a.12xlarge"
	InstanceTypeM5a16xlarge       InstanceType = "m5a.16xlarge"
	InstanceTypeM5a24xlarge       InstanceType = "m5a.24xlarge"
	InstanceTypeM5adLarge         InstanceType = "m5ad.large"
	InstanceTypeM5adXlarge        InstanceType = "m5ad.xlarge"
	InstanceTypeM5ad2xlarge       InstanceType = "m5ad.2xlarge"
	InstanceTypeM5ad4xlarge       InstanceType = "m5ad.4xlarge"
	InstanceTypeM5ad8xlarge       InstanceType = "m5ad.8xlarge"
	InstanceTypeM5ad12xlarge      InstanceType = "m5ad.12xlarge"
	InstanceTypeM5ad16xlarge      InstanceType = "m5ad.16xlarge"
	InstanceTypeM5ad24xlarge      InstanceType = "m5ad.24xlarge"
	InstanceTypeM5dLarge          InstanceType = "m5d.large"
	InstanceTypeM5dXlarge         InstanceType = "m5d.xlarge"
	InstanceTypeM5d2xlarge        InstanceType = "m5d.2xlarge"
	InstanceTypeM5d4xlarge        InstanceType = "m5d.4xlarge"
	InstanceTypeM5d8xlarge        InstanceType = "m5d.8xlarge"
	InstanceTypeM5d12xlarge       InstanceType = "m5d.12xlarge"
	InstanceTypeM5d16xlarge       InstanceType = "m5d.16xlarge"
	InstanceTypeM5d24xlarge       InstanceType = "m5d.24xlarge"
	InstanceTypeM5dMetal          InstanceType = "m5d.metal"
	InstanceTypeM5dnLarge         InstanceType = "m5dn.large"
	InstanceTypeM5dnXlarge        InstanceType = "m5dn.xlarge"
	InstanceTypeM5dn2xlarge       InstanceType = "m5dn.2xlarge"
	InstanceTypeM5dn4xlarge       InstanceType = "m5dn.4xlarge"
	InstanceTypeM5dn8xlarge       InstanceType = "m5dn.8xlarge"
	InstanceTypeM5dn12xlarge      InstanceType = "m5dn.12xlarge"
	InstanceTypeM5dn16xlarge      InstanceType = "m5dn.16xlarge"
	InstanceTypeM5dn24xlarge      InstanceType = "m5dn.24xlarge"
	InstanceTypeM5dnMetal         InstanceType = "m5dn.metal"
	InstanceTypeM5nLarge          InstanceType = "m5n.large"
	InstanceTypeM5nXlarge         InstanceType = "m5n.xlarge"
	InstanceTypeM5n2xlarge        InstanceType = "m5n.2xlarge"
	InstanceTypeM5n4xlarge        InstanceType = "m5n.4xlarge"
	InstanceTypeM5n8xlarge        InstanceType = "m5n.8xlarge"
	InstanceTypeM5n12xlarge       InstanceType = "m5n.12xlarge"
	InstanceTypeM5n16xlarge       InstanceType = "m5n.16xlarge"
	InstanceTypeM5n24xlarge       InstanceType = "m5n.24xlarge"
	InstanceTypeM5nMetal          InstanceType = "m5n.metal"
	InstanceTypeM5znLarge         InstanceType = "m5zn.large"
	InstanceTypeM5znXlarge        InstanceType = "m5zn.xlarge"
	InstanceTypeM5zn2xlarge       InstanceType = "m5zn.2xlarge"
	InstanceTypeM5zn3xlarge       InstanceType = "m5zn.3xlarge"
	InstanceTypeM5zn6xlarge       InstanceType = "m5zn.6xlarge"
	InstanceTypeM5zn12xlarge      InstanceType = "m5zn.12xlarge"
	InstanceTypeM5znMetal         InstanceType = "m5zn.metal"
	InstanceTypeM6aLarge          InstanceType = "m6a.large"
	InstanceTypeM6aXlarge         InstanceType = "m6a.xlarge"
	InstanceTypeM6a2xlarge        InstanceType = "m6a.2xlarge"
	InstanceTypeM6a4xlarge        InstanceType = "m6a.4xlarge"
	InstanceTypeM6a8xlarge        InstanceType = "m6a.8xlarge"
	InstanceTypeM6a12xlarge       InstanceType = "m6a.12xlarge"
	InstanceTypeM6a16xlarge       InstanceType = "m6a.16xlarge"
	InstanceTypeM6a24xlarge       InstanceType = "m6a.24xlarge"
	InstanceTypeM6a32xlarge       InstanceType = "m6a.32xlarge"
	InstanceTypeM6a48xlarge       InstanceType = "m6a.48xlarge"
	InstanceTypeM6gMetal          InstanceType = "m6g.metal"
	InstanceTypeM6gMedium         InstanceType = "m6g.medium"
	InstanceTypeM6gLarge          InstanceType = "m6g.large"
	InstanceTypeM6gXlarge         InstanceType = "m6g.xlarge"
	InstanceTypeM6g2xlarge        InstanceType = "m6g.2xlarge"
	InstanceTypeM6g4xlarge        InstanceType = "m6g.4xlarge"
	InstanceTypeM6g8xlarge        InstanceType = "m6g.8xlarge"
	InstanceTypeM6g12xlarge       InstanceType = "m6g.12xlarge"
	InstanceTypeM6g16xlarge       InstanceType = "m6g.16xlarge"
	InstanceTypeM6gdMetal         InstanceType = "m6gd.metal"
	InstanceTypeM6gdMedium        InstanceType = "m6gd.medium"
	InstanceTypeM6gdLarge         InstanceType = "m6gd.large"
	InstanceTypeM6gdXlarge        InstanceType = "m6gd.xlarge"
	InstanceTypeM6gd2xlarge       InstanceType = "m6gd.2xlarge"
	InstanceTypeM6gd4xlarge       InstanceType = "m6gd.4xlarge"
	InstanceTypeM6gd8xlarge       InstanceType = "m6gd.8xlarge"
	InstanceTypeM6gd12xlarge      InstanceType = "m6gd.12xlarge"
	InstanceTypeM6gd16xlarge      InstanceType = "m6gd.16xlarge"
	InstanceTypeM6iLarge          InstanceType = "m6i.large"
	InstanceTypeM6iXlarge         InstanceType = "m6i.xlarge"
	InstanceTypeM6i2xlarge        InstanceType = "m6i.2xlarge"
	InstanceTypeM6i4xlarge        InstanceType = "m6i.4xlarge"
	InstanceTypeM6i8xlarge        InstanceType = "m6i.8xlarge"
	InstanceTypeM6i12xlarge       InstanceType = "m6i.12xlarge"
	InstanceTypeM6i16xlarge       InstanceType = "m6i.16xlarge"
	InstanceTypeM6i24xlarge       InstanceType = "m6i.24xlarge"
	InstanceTypeM6i32xlarge       InstanceType = "m6i.32xlarge"
	InstanceTypeM6iMetal          InstanceType = "m6i.metal"
	InstanceTypeMac1Metal         InstanceType = "mac1.metal"
	InstanceTypeP2Xlarge          InstanceType = "p2.xlarge"
	InstanceTypeP28xlarge         InstanceType = "p2.8xlarge"
	InstanceTypeP216xlarge        InstanceType = "p2.16xlarge"
	InstanceTypeP32xlarge         InstanceType = "p3.2xlarge"
	InstanceTypeP38xlarge         InstanceType = "p3.8xlarge"
	InstanceTypeP316xlarge        InstanceType = "p3.16xlarge"
	InstanceTypeP3dn24xlarge      InstanceType = "p3dn.24xlarge"
	InstanceTypeP4d24xlarge       InstanceType = "p4d.24xlarge"
	InstanceTypeR3Large           InstanceType = "r3.large"
	InstanceTypeR3Xlarge          InstanceType = "r3.xlarge"
	InstanceTypeR32xlarge         InstanceType = "r3.2xlarge"
	InstanceTypeR34xlarge         InstanceType = "r3.4xlarge"
	InstanceTypeR38xlarge         InstanceType = "r3.8xlarge"
	InstanceTypeR4Large           InstanceType = "r4.large"
	InstanceTypeR4Xlarge          InstanceType = "r4.xlarge"
	InstanceTypeR42xlarge         InstanceType = "r4.2xlarge"
	InstanceTypeR44xlarge         InstanceType = "r4.4xlarge"
	InstanceTypeR48xlarge         InstanceType = "r4.8xlarge"
	InstanceTypeR416xlarge        InstanceType = "r4.16xlarge"
	InstanceTypeR5Large           InstanceType = "r5.large"
	InstanceTypeR5Xlarge          InstanceType = "r5.xlarge"
	InstanceTypeR52xlarge         InstanceType = "r5.2xlarge"
	InstanceTypeR54xlarge         InstanceType = "r5.4xlarge"
	InstanceTypeR58xlarge         InstanceType = "r5.8xlarge"
	InstanceTypeR512xlarge        InstanceType = "r5.12xlarge"
	InstanceTypeR516xlarge        InstanceType = "r5.16xlarge"
	InstanceTypeR524xlarge        InstanceType = "r5.24xlarge"
	InstanceTypeR5Metal           InstanceType = "r5.metal"
	InstanceTypeR5aLarge          InstanceType = "r5a.large"
	InstanceTypeR5aXlarge         InstanceType = "r5a.xlarge"
	InstanceTypeR5a2xlarge        InstanceType = "r5a.2xlarge"
	InstanceTypeR5a4xlarge        InstanceType = "r5a.4xlarge"
	InstanceTypeR5a8xlarge        InstanceType = "r5a.8xlarge"
	InstanceTypeR5a12xlarge       InstanceType = "r5a.12xlarge"
	InstanceTypeR5a16xlarge       InstanceType = "r5a.16xlarge"
	InstanceTypeR5a24xlarge       InstanceType = "r5a.24xlarge"
	InstanceTypeR5adLarge         InstanceType = "r5ad.large"
	InstanceTypeR5adXlarge        InstanceType = "r5ad.xlarge"
	InstanceTypeR5ad2xlarge       InstanceType = "r5ad.2xlarge"
	InstanceTypeR5ad4xlarge       InstanceType = "r5ad.4xlarge"
	InstanceTypeR5ad8xlarge       InstanceType = "r5ad.8xlarge"
	InstanceTypeR5ad12xlarge      InstanceType = "r5ad.12xlarge"
	InstanceTypeR5ad16xlarge      InstanceType = "r5ad.16xlarge"
	InstanceTypeR5ad24xlarge      InstanceType = "r5ad.24xlarge"
	InstanceTypeR5bLarge          InstanceType = "r5b.large"
	InstanceTypeR5bXlarge         InstanceType = "r5b.xlarge"
	InstanceTypeR5b2xlarge        InstanceType = "r5b.2xlarge"
	InstanceTypeR5b4xlarge        InstanceType = "r5b.4xlarge"
	InstanceTypeR5b8xlarge        InstanceType = "r5b.8xlarge"
	InstanceTypeR5b12xlarge       InstanceType = "r5b.12xlarge"
	InstanceTypeR5b16xlarge       InstanceType = "r5b.16xlarge"
	InstanceTypeR5b24xlarge       InstanceType = "r5b.24xlarge"
	InstanceTypeR5bMetal          InstanceType = "r5b.metal"
	InstanceTypeR5dLarge          InstanceType = "r5d.large"
	InstanceTypeR5dXlarge         InstanceType = "r5d.xlarge"
	InstanceTypeR5d2xlarge        InstanceType = "r5d.2xlarge"
	InstanceTypeR5d4xlarge        InstanceType = "r5d.4xlarge"
	InstanceTypeR5d8xlarge        InstanceType = "r5d.8xlarge"
	InstanceTypeR5d12xlarge       InstanceType = "r5d.12xlarge"
	InstanceTypeR5d16xlarge       InstanceType = "r5d.16xlarge"
	InstanceTypeR5d24xlarge       InstanceType = "r5d.24xlarge"
	InstanceTypeR5dMetal          InstanceType = "r5d.metal"
	InstanceTypeR5dnLarge         InstanceType = "r5dn.large"
	InstanceTypeR5dnXlarge        InstanceType = "r5dn.xlarge"
	InstanceTypeR5dn2xlarge       InstanceType = "r5dn.2xlarge"
	InstanceTypeR5dn4xlarge       InstanceType = "r5dn.4xlarge"
	InstanceTypeR5dn8xlarge       InstanceType = "r5dn.8xlarge"
	InstanceTypeR5dn12xlarge      InstanceType = "r5dn.12xlarge"
	InstanceTypeR5dn16xlarge      InstanceType = "r5dn.16xlarge"
	InstanceTypeR5dn24xlarge      InstanceType = "r5dn.24xlarge"
	InstanceTypeR5dnMetal         InstanceType = "r5dn.metal"
	InstanceTypeR5nLarge          InstanceType = "r5n.large"
	InstanceTypeR5nXlarge         InstanceType = "r5n.xlarge"
	InstanceTypeR5n2xlarge        InstanceType = "r5n.2xlarge"
	InstanceTypeR5n4xlarge        InstanceType = "r5n.4xlarge"
	InstanceTypeR5n8xlarge        InstanceType = "r5n.8xlarge"
	InstanceTypeR5n12xlarge       InstanceType = "r5n.12xlarge"
	InstanceTypeR5n16xlarge       InstanceType = "r5n.16xlarge"
	InstanceTypeR5n24xlarge       InstanceType = "r5n.24xlarge"
	InstanceTypeR5nMetal          InstanceType = "r5n.metal"
	InstanceTypeR6gMedium         InstanceType = "r6g.medium"
	InstanceTypeR6gLarge          InstanceType = "r6g.large"
	InstanceTypeR6gXlarge         InstanceType = "r6g.xlarge"
	InstanceTypeR6g2xlarge        InstanceType = "r6g.2xlarge"
	InstanceTypeR6g4xlarge        InstanceType = "r6g.4xlarge"
	InstanceTypeR6g8xlarge        InstanceType = "r6g.8xlarge"
	InstanceTypeR6g12xlarge       InstanceType = "r6g.12xlarge"
	InstanceTypeR6g16xlarge       InstanceType = "r6g.16xlarge"
	InstanceTypeR6gMetal          InstanceType = "r6g.metal"
	InstanceTypeR6gdMedium        InstanceType = "r6gd.medium"
	InstanceTypeR6gdLarge         InstanceType = "r6gd.large"
	InstanceTypeR6gdXlarge        InstanceType = "r6gd.xlarge"
	InstanceTypeR6gd2xlarge       InstanceType = "r6gd.2xlarge"
	InstanceTypeR6gd4xlarge       InstanceType = "r6gd.4xlarge"
	InstanceTypeR6gd8xlarge       InstanceType = "r6gd.8xlarge"
	InstanceTypeR6gd12xlarge      InstanceType = "r6gd.12xlarge"
	InstanceTypeR6gd16xlarge      InstanceType = "r6gd.16xlarge"
	InstanceTypeR6gdMetal         InstanceType = "r6gd.metal"
	InstanceTypeR6iLarge          InstanceType = "r6i.large"
	InstanceTypeR6iXlarge         InstanceType = "r6i.xlarge"
	InstanceTypeR6i2xlarge        InstanceType = "r6i.2xlarge"
	InstanceTypeR6i4xlarge        InstanceType = "r6i.4xlarge"
	InstanceTypeR6i8xlarge        InstanceType = "r6i.8xlarge"
	InstanceTypeR6i12xlarge       InstanceType = "r6i.12xlarge"
	InstanceTypeR6i16xlarge       InstanceType = "r6i.16xlarge"
	InstanceTypeR6i24xlarge       InstanceType = "r6i.24xlarge"
	InstanceTypeR6i32xlarge       InstanceType = "r6i.32xlarge"
	InstanceTypeR6iMetal          InstanceType = "r6i.metal"
	InstanceTypeT1Micro           InstanceType = "t1.micro"
	InstanceTypeT2Nano            InstanceType = "t2.nano"
	InstanceTypeT2Micro           InstanceType = "t2.micro"
	InstanceTypeT2Small           InstanceType = "t2.small"
	InstanceTypeT2Medium          InstanceType = "t2.medium"
	InstanceTypeT2Large           InstanceType = "t2.large"
	InstanceTypeT2Xlarge          InstanceType = "t2.xlarge"
	InstanceTypeT22xlarge         InstanceType = "t2.2xlarge"
	InstanceTypeT3Nano            InstanceType = "t3.nano"
	InstanceTypeT3Micro           InstanceType = "t3.micro"
	InstanceTypeT3Small           InstanceType = "t3.small"
	InstanceTypeT3Medium          InstanceType = "t3.medium"
	InstanceTypeT3Large           InstanceType = "t3.large"
	InstanceTypeT3Xlarge          InstanceType = "t3.xlarge"
	InstanceTypeT32xlarge         InstanceType = "t3.2xlarge"
	InstanceTypeT3aNano           InstanceType = "t3a.nano"
	InstanceTypeT3aMicro          InstanceType = "t3a.micro"
	InstanceTypeT3aSmall          InstanceType = "t3a.small"
	InstanceTypeT3aMedium         InstanceType = "t3a.medium"
	InstanceTypeT3aLarge          InstanceType = "t3a.large"
	InstanceTypeT3aXlarge         InstanceType = "t3a.xlarge"
	InstanceTypeT3a2xlarge        InstanceType = "t3a.2xlarge"
	InstanceTypeT4gNano           InstanceType = "t4g.nano"
	InstanceTypeT4gMicro          InstanceType = "t4g.micro"
	InstanceTypeT4gSmall          InstanceType = "t4g.small"
	InstanceTypeT4gMedium         InstanceType = "t4g.medium"
	InstanceTypeT4gLarge          InstanceType = "t4g.large"
	InstanceTypeT4gXlarge         InstanceType = "t4g.xlarge"
	InstanceTypeT4g2xlarge        InstanceType = "t4g.2xlarge"
	InstanceTypeU6tb156xlarge     InstanceType = "u-6tb1.56xlarge"
	InstanceTypeU6tb1112xlarge    InstanceType = "u-6tb1.112xlarge"
	InstanceTypeU9tb1112xlarge    InstanceType = "u-9tb1.112xlarge"
	InstanceTypeU12tb1112xlarge   InstanceType = "u-12tb1.112xlarge"
	InstanceTypeU6tb1Metal        InstanceType = "u-6tb1.metal"
	InstanceTypeU9tb1Metal        InstanceType = "u-9tb1.metal"
	InstanceTypeU12tb1Metal       InstanceType = "u-12tb1.metal"
	InstanceTypeU18tb1Metal       InstanceType = "u-18tb1.metal"
	InstanceTypeU24tb1Metal       InstanceType = "u-24tb1.metal"
	InstanceTypeVt13xlarge        InstanceType = "vt1.3xlarge"
	InstanceTypeVt16xlarge        InstanceType = "vt1.6xlarge"
	InstanceTypeVt124xlarge       InstanceType = "vt1.24xlarge"
	InstanceTypeX116xlarge        InstanceType = "x1.16xlarge"
	InstanceTypeX132xlarge        InstanceType = "x1.32xlarge"
	InstanceTypeX1eXlarge         InstanceType = "x1e.xlarge"
	InstanceTypeX1e2xlarge        InstanceType = "x1e.2xlarge"
	InstanceTypeX1e4xlarge        InstanceType = "x1e.4xlarge"
	InstanceTypeX1e8xlarge        InstanceType = "x1e.8xlarge"
	InstanceTypeX1e16xlarge       InstanceType = "x1e.16xlarge"
	InstanceTypeX1e32xlarge       InstanceType = "x1e.32xlarge"
	InstanceTypeX2iezn2xlarge     InstanceType = "x2iezn.2xlarge"
	InstanceTypeX2iezn4xlarge     InstanceType = "x2iezn.4xlarge"
	InstanceTypeX2iezn6xlarge     InstanceType = "x2iezn.6xlarge"
	InstanceTypeX2iezn8xlarge     InstanceType = "x2iezn.8xlarge"
	InstanceTypeX2iezn12xlarge    InstanceType = "x2iezn.12xlarge"
	InstanceTypeX2ieznMetal       InstanceType = "x2iezn.metal"
	InstanceTypeX2gdMedium        InstanceType = "x2gd.medium"
	InstanceTypeX2gdLarge         InstanceType = "x2gd.large"
	InstanceTypeX2gdXlarge        InstanceType = "x2gd.xlarge"
	InstanceTypeX2gd2xlarge       InstanceType = "x2gd.2xlarge"
	InstanceTypeX2gd4xlarge       InstanceType = "x2gd.4xlarge"
	InstanceTypeX2gd8xlarge       InstanceType = "x2gd.8xlarge"
	InstanceTypeX2gd12xlarge      InstanceType = "x2gd.12xlarge"
	InstanceTypeX2gd16xlarge      InstanceType = "x2gd.16xlarge"
	InstanceTypeX2gdMetal         InstanceType = "x2gd.metal"
	InstanceTypeZ1dLarge          InstanceType = "z1d.large"
	InstanceTypeZ1dXlarge         InstanceType = "z1d.xlarge"
	InstanceTypeZ1d2xlarge        InstanceType = "z1d.2xlarge"
	InstanceTypeZ1d3xlarge        InstanceType = "z1d.3xlarge"
	InstanceTypeZ1d6xlarge        InstanceType = "z1d.6xlarge"
	InstanceTypeZ1d12xlarge       InstanceType = "z1d.12xlarge"
	InstanceTypeZ1dMetal          InstanceType = "z1d.metal"
	InstanceTypeX2idn16xlarge     InstanceType = "x2idn.16xlarge"
	InstanceTypeX2idn24xlarge     InstanceType = "x2idn.24xlarge"
	InstanceTypeX2idn32xlarge     InstanceType = "x2idn.32xlarge"
	InstanceTypeX2iednXlarge      InstanceType = "x2iedn.xlarge"
	InstanceTypeX2iedn2xlarge     InstanceType = "x2iedn.2xlarge"
	InstanceTypeX2iedn4xlarge     InstanceType = "x2iedn.4xlarge"
	InstanceTypeX2iedn8xlarge     InstanceType = "x2iedn.8xlarge"
	InstanceTypeX2iedn16xlarge    InstanceType = "x2iedn.16xlarge"
	InstanceTypeX2iedn24xlarge    InstanceType = "x2iedn.24xlarge"
	InstanceTypeX2iedn32xlarge    InstanceType = "x2iedn.32xlarge"
	InstanceTypeC6aLarge          InstanceType = "c6a.large"
	InstanceTypeC6aXlarge         InstanceType = "c6a.xlarge"
	InstanceTypeC6a2xlarge        InstanceType = "c6a.2xlarge"
	InstanceTypeC6a4xlarge        InstanceType = "c6a.4xlarge"
	InstanceTypeC6a8xlarge        InstanceType = "c6a.8xlarge"
	InstanceTypeC6a12xlarge       InstanceType = "c6a.12xlarge"
	InstanceTypeC6a16xlarge       InstanceType = "c6a.16xlarge"
	InstanceTypeC6a24xlarge       InstanceType = "c6a.24xlarge"
	InstanceTypeC6a32xlarge       InstanceType = "c6a.32xlarge"
	InstanceTypeC6a48xlarge       InstanceType = "c6a.48xlarge"
	InstanceTypeC6aMetal          InstanceType = "c6a.metal"
	InstanceTypeM6aMetal          InstanceType = "m6a.metal"
	InstanceTypeI4iLarge          InstanceType = "i4i.large"
	InstanceTypeI4iXlarge         InstanceType = "i4i.xlarge"
	InstanceTypeI4i2xlarge        InstanceType = "i4i.2xlarge"
	InstanceTypeI4i4xlarge        InstanceType = "i4i.4xlarge"
	InstanceTypeI4i8xlarge        InstanceType = "i4i.8xlarge"
	InstanceTypeI4i16xlarge       InstanceType = "i4i.16xlarge"
	InstanceTypeI4i32xlarge       InstanceType = "i4i.32xlarge"
	InstanceTypeI4iMetal          InstanceType = "i4i.metal"
	InstanceTypeX2idnMetal        InstanceType = "x2idn.metal"
	InstanceTypeX2iednMetal       InstanceType = "x2iedn.metal"
	InstanceTypeC7gMedium         InstanceType = "c7g.medium"
	InstanceTypeC7gLarge          InstanceType = "c7g.large"
	InstanceTypeC7gXlarge         InstanceType = "c7g.xlarge"
	InstanceTypeC7g2xlarge        InstanceType = "c7g.2xlarge"
	InstanceTypeC7g4xlarge        InstanceType = "c7g.4xlarge"
	InstanceTypeC7g8xlarge        InstanceType = "c7g.8xlarge"
	InstanceTypeC7g12xlarge       InstanceType = "c7g.12xlarge"
	InstanceTypeC7g16xlarge       InstanceType = "c7g.16xlarge"
	InstanceTypeMac2Metal         InstanceType = "mac2.metal"
	InstanceTypeC6idLarge         InstanceType = "c6id.large"
	InstanceTypeC6idXlarge        InstanceType = "c6id.xlarge"
	InstanceTypeC6id2xlarge       InstanceType = "c6id.2xlarge"
	InstanceTypeC6id4xlarge       InstanceType = "c6id.4xlarge"
	InstanceTypeC6id8xlarge       InstanceType = "c6id.8xlarge"
	InstanceTypeC6id12xlarge      InstanceType = "c6id.12xlarge"
	InstanceTypeC6id16xlarge      InstanceType = "c6id.16xlarge"
	InstanceTypeC6id24xlarge      InstanceType = "c6id.24xlarge"
	InstanceTypeC6id32xlarge      InstanceType = "c6id.32xlarge"
	InstanceTypeC6idMetal         InstanceType = "c6id.metal"
	InstanceTypeM6idLarge         InstanceType = "m6id.large"
	InstanceTypeM6idXlarge        InstanceType = "m6id.xlarge"
	InstanceTypeM6id2xlarge       InstanceType = "m6id.2xlarge"
	InstanceTypeM6id4xlarge       InstanceType = "m6id.4xlarge"
	InstanceTypeM6id8xlarge       InstanceType = "m6id.8xlarge"
	InstanceTypeM6id12xlarge      InstanceType = "m6id.12xlarge"
	InstanceTypeM6id16xlarge      InstanceType = "m6id.16xlarge"
	InstanceTypeM6id24xlarge      InstanceType = "m6id.24xlarge"
	InstanceTypeM6id32xlarge      InstanceType = "m6id.32xlarge"
	InstanceTypeM6idMetal         InstanceType = "m6id.metal"
	InstanceTypeR6idLarge         InstanceType = "r6id.large"
	InstanceTypeR6idXlarge        InstanceType = "r6id.xlarge"
	InstanceTypeR6id2xlarge       InstanceType = "r6id.2xlarge"
	InstanceTypeR6id4xlarge       InstanceType = "r6id.4xlarge"
	InstanceTypeR6id8xlarge       InstanceType = "r6id.8xlarge"
	InstanceTypeR6id12xlarge      InstanceType = "r6id.12xlarge"
	InstanceTypeR6id16xlarge      InstanceType = "r6id.16xlarge"
	InstanceTypeR6id24xlarge      InstanceType = "r6id.24xlarge"
	InstanceTypeR6id32xlarge      InstanceType = "r6id.32xlarge"
	InstanceTypeR6idMetal         InstanceType = "r6id.metal"
	InstanceTypeR6aLarge          InstanceType = "r6a.large"
	InstanceTypeR6aXlarge         InstanceType = "r6a.xlarge"
	InstanceTypeR6a2xlarge        InstanceType = "r6a.2xlarge"
	InstanceTypeR6a4xlarge        InstanceType = "r6a.4xlarge"
	InstanceTypeR6a8xlarge        InstanceType = "r6a.8xlarge"
	InstanceTypeR6a12xlarge       InstanceType = "r6a.12xlarge"
	InstanceTypeR6a16xlarge       InstanceType = "r6a.16xlarge"
	InstanceTypeR6a24xlarge       InstanceType = "r6a.24xlarge"
	InstanceTypeR6a32xlarge       InstanceType = "r6a.32xlarge"
	InstanceTypeR6a48xlarge       InstanceType = "r6a.48xlarge"
	InstanceTypeR6aMetal          InstanceType = "r6a.metal"
	InstanceTypeP4de24xlarge      InstanceType = "p4de.24xlarge"
	InstanceTypeU3tb156xlarge     InstanceType = "u-3tb1.56xlarge"
	InstanceTypeU18tb1112xlarge   InstanceType = "u-18tb1.112xlarge"
	InstanceTypeU24tb1112xlarge   InstanceType = "u-24tb1.112xlarge"
	InstanceTypeTrn12xlarge       InstanceType = "trn1.2xlarge"
	InstanceTypeTrn132xlarge      InstanceType = "trn1.32xlarge"
	InstanceTypeHpc6id32xlarge    InstanceType = "hpc6id.32xlarge"
	InstanceTypeC6inLarge         InstanceType = "c6in.large"
	InstanceTypeC6inXlarge        InstanceType = "c6in.xlarge"
	InstanceTypeC6in2xlarge       InstanceType = "c6in.2xlarge"
	InstanceTypeC6in4xlarge       InstanceType = "c6in.4xlarge"
	InstanceTypeC6in8xlarge       InstanceType = "c6in.8xlarge"
	InstanceTypeC6in12xlarge      InstanceType = "c6in.12xlarge"
	InstanceTypeC6in16xlarge      InstanceType = "c6in.16xlarge"
	InstanceTypeC6in24xlarge      InstanceType = "c6in.24xlarge"
	InstanceTypeC6in32xlarge      InstanceType = "c6in.32xlarge"
	InstanceTypeM6inLarge         InstanceType = "m6in.large"
	InstanceTypeM6inXlarge        InstanceType = "m6in.xlarge"
	InstanceTypeM6in2xlarge       InstanceType = "m6in.2xlarge"
	InstanceTypeM6in4xlarge       InstanceType = "m6in.4xlarge"
	InstanceTypeM6in8xlarge       InstanceType = "m6in.8xlarge"
	InstanceTypeM6in12xlarge      InstanceType = "m6in.12xlarge"
	InstanceTypeM6in16xlarge      InstanceType = "m6in.16xlarge"
	InstanceTypeM6in24xlarge      InstanceType = "m6in.24xlarge"
	InstanceTypeM6in32xlarge      InstanceType = "m6in.32xlarge"
	InstanceTypeM6idnLarge        InstanceType = "m6idn.large"
	InstanceTypeM6idnXlarge       InstanceType = "m6idn.xlarge"
	InstanceTypeM6idn2xlarge      InstanceType = "m6idn.2xlarge"
	InstanceTypeM6idn4xlarge      InstanceType = "m6idn.4xlarge"
	InstanceTypeM6idn8xlarge      InstanceType = "m6idn.8xlarge"
	InstanceTypeM6idn12xlarge     InstanceType = "m6idn.12xlarge"
	InstanceTypeM6idn16xlarge     InstanceType = "m6idn.16xlarge"
	InstanceTypeM6idn24xlarge     InstanceType = "m6idn.24xlarge"
	InstanceTypeM6idn32xlarge     InstanceType = "m6idn.32xlarge"
	InstanceTypeR6inLarge         InstanceType = "r6in.large"
	InstanceTypeR6inXlarge        InstanceType = "r6in.xlarge"
	InstanceTypeR6in2xlarge       InstanceType = "r6in.2xlarge"
	InstanceTypeR6in4xlarge       InstanceType = "r6in.4xlarge"
	InstanceTypeR6in8xlarge       InstanceType = "r6in.8xlarge"
	InstanceTypeR6in12xlarge      InstanceType = "r6in.12xlarge"
	InstanceTypeR6in16xlarge      InstanceType = "r6in.16xlarge"
	InstanceTypeR6in24xlarge      InstanceType = "r6in.24xlarge"
	InstanceTypeR6in32xlarge      InstanceType = "r6in.32xlarge"
	InstanceTypeR6idnLarge        InstanceType = "r6idn.large"
	InstanceTypeR6idnXlarge       InstanceType = "r6idn.xlarge"
	InstanceTypeR6idn2xlarge      InstanceType = "r6idn.2xlarge"
	InstanceTypeR6idn4xlarge      InstanceType = "r6idn.4xlarge"
	InstanceTypeR6idn8xlarge      InstanceType = "r6idn.8xlarge"
	InstanceTypeR6idn12xlarge     InstanceType = "r6idn.12xlarge"
	InstanceTypeR6idn16xlarge     InstanceType = "r6idn.16xlarge"
	InstanceTypeR6idn24xlarge     InstanceType = "r6idn.24xlarge"
	InstanceTypeR6idn32xlarge     InstanceType = "r6idn.32xlarge"
	InstanceTypeC7gMetal          InstanceType = "c7g.metal"
	InstanceTypeM7gMedium         InstanceType = "m7g.medium"
	InstanceTypeM7gLarge          InstanceType = "m7g.large"
	InstanceTypeM7gXlarge         InstanceType = "m7g.xlarge"
	InstanceTypeM7g2xlarge        InstanceType = "m7g.2xlarge"
	InstanceTypeM7g4xlarge        InstanceType = "m7g.4xlarge"
	InstanceTypeM7g8xlarge        InstanceType = "m7g.8xlarge"
	InstanceTypeM7g12xlarge       InstanceType = "m7g.12xlarge"
	InstanceTypeM7g16xlarge       InstanceType = "m7g.16xlarge"
	InstanceTypeM7gMetal          InstanceType = "m7g.metal"
	InstanceTypeR7gMedium         InstanceType = "r7g.medium"
	InstanceTypeR7gLarge          InstanceType = "r7g.large"
	InstanceTypeR7gXlarge         InstanceType = "r7g.xlarge"
	InstanceTypeR7g2xlarge        InstanceType = "r7g.2xlarge"
	InstanceTypeR7g4xlarge        InstanceType = "r7g.4xlarge"
	InstanceTypeR7g8xlarge        InstanceType = "r7g.8xlarge"
	InstanceTypeR7g12xlarge       InstanceType = "r7g.12xlarge"
	InstanceTypeR7g16xlarge       InstanceType = "r7g.16xlarge"
	InstanceTypeR7gMetal          InstanceType = "r7g.metal"
	InstanceTypeC6inMetal         InstanceType = "c6in.metal"
	InstanceTypeM6inMetal         InstanceType = "m6in.metal"
	InstanceTypeM6idnMetal        InstanceType = "m6idn.metal"
	InstanceTypeR6inMetal         InstanceType = "r6in.metal"
	InstanceTypeR6idnMetal        InstanceType = "r6idn.metal"
	InstanceTypeInf2Xlarge        InstanceType = "inf2.xlarge"
	InstanceTypeInf28xlarge       InstanceType = "inf2.8xlarge"
	InstanceTypeInf224xlarge      InstanceType = "inf2.24xlarge"
	InstanceTypeInf248xlarge      InstanceType = "inf2.48xlarge"
	InstanceTypeTrn1n32xlarge     InstanceType = "trn1n.32xlarge"
	InstanceTypeI4gLarge          InstanceType = "i4g.large"
	InstanceTypeI4gXlarge         InstanceType = "i4g.xlarge"
	InstanceTypeI4g2xlarge        InstanceType = "i4g.2xlarge"
	InstanceTypeI4g4xlarge        InstanceType = "i4g.4xlarge"
	InstanceTypeI4g8xlarge        InstanceType = "i4g.8xlarge"
	InstanceTypeI4g16xlarge       InstanceType = "i4g.16xlarge"
	InstanceTypeHpc7g4xlarge      InstanceType = "hpc7g.4xlarge"
	InstanceTypeHpc7g8xlarge      InstanceType = "hpc7g.8xlarge"
	InstanceTypeHpc7g16xlarge     InstanceType = "hpc7g.16xlarge"
	InstanceTypeC7gnMedium        InstanceType = "c7gn.medium"
	InstanceTypeC7gnLarge         InstanceType = "c7gn.large"
	InstanceTypeC7gnXlarge        InstanceType = "c7gn.xlarge"
	InstanceTypeC7gn2xlarge       InstanceType = "c7gn.2xlarge"
	InstanceTypeC7gn4xlarge       InstanceType = "c7gn.4xlarge"
	InstanceTypeC7gn8xlarge       InstanceType = "c7gn.8xlarge"
	InstanceTypeC7gn12xlarge      InstanceType = "c7gn.12xlarge"
	InstanceTypeC7gn16xlarge      InstanceType = "c7gn.16xlarge"
	InstanceTypeP548xlarge        InstanceType = "p5.48xlarge"
	InstanceTypeM7iLarge          InstanceType = "m7i.large"
	InstanceTypeM7iXlarge         InstanceType = "m7i.xlarge"
	InstanceTypeM7i2xlarge        InstanceType = "m7i.2xlarge"
	InstanceTypeM7i4xlarge        InstanceType = "m7i.4xlarge"
	InstanceTypeM7i8xlarge        InstanceType = "m7i.8xlarge"
	InstanceTypeM7i12xlarge       InstanceType = "m7i.12xlarge"
	InstanceTypeM7i16xlarge       InstanceType = "m7i.16xlarge"
	InstanceTypeM7i24xlarge       InstanceType = "m7i.24xlarge"
	InstanceTypeM7i48xlarge       InstanceType = "m7i.48xlarge"
	InstanceTypeM7iFlexLarge      InstanceType = "m7i-flex.large"
	InstanceTypeM7iFlexXlarge     InstanceType = "m7i-flex.xlarge"
	InstanceTypeM7iFlex2xlarge    InstanceType = "m7i-flex.2xlarge"
	InstanceTypeM7iFlex4xlarge    InstanceType = "m7i-flex.4xlarge"
	InstanceTypeM7iFlex8xlarge    InstanceType = "m7i-flex.8xlarge"
	InstanceTypeM7aMedium         InstanceType = "m7a.medium"
	InstanceTypeM7aLarge          InstanceType = "m7a.large"
	InstanceTypeM7aXlarge         InstanceType = "m7a.xlarge"
	InstanceTypeM7a2xlarge        InstanceType = "m7a.2xlarge"
	InstanceTypeM7a4xlarge        InstanceType = "m7a.4xlarge"
	InstanceTypeM7a8xlarge        InstanceType = "m7a.8xlarge"
	InstanceTypeM7a12xlarge       InstanceType = "m7a.12xlarge"
	InstanceTypeM7a16xlarge       InstanceType = "m7a.16xlarge"
	InstanceTypeM7a24xlarge       InstanceType = "m7a.24xlarge"
	InstanceTypeM7a32xlarge       InstanceType = "m7a.32xlarge"
	InstanceTypeM7a48xlarge       InstanceType = "m7a.48xlarge"
	InstanceTypeM7aMetal48xl      InstanceType = "m7a.metal-48xl"
	InstanceTypeHpc7a12xlarge     InstanceType = "hpc7a.12xlarge"
	InstanceTypeHpc7a24xlarge     InstanceType = "hpc7a.24xlarge"
	InstanceTypeHpc7a48xlarge     InstanceType = "hpc7a.48xlarge"
	InstanceTypeHpc7a96xlarge     InstanceType = "hpc7a.96xlarge"
	InstanceTypeC7gdMedium        InstanceType = "c7gd.medium"
	InstanceTypeC7gdLarge         InstanceType = "c7gd.large"
	InstanceTypeC7gdXlarge        InstanceType = "c7gd.xlarge"
	InstanceTypeC7gd2xlarge       InstanceType = "c7gd.2xlarge"
	InstanceTypeC7gd4xlarge       InstanceType = "c7gd.4xlarge"
	InstanceTypeC7gd8xlarge       InstanceType = "c7gd.8xlarge"
	InstanceTypeC7gd12xlarge      InstanceType = "c7gd.12xlarge"
	InstanceTypeC7gd16xlarge      InstanceType = "c7gd.16xlarge"
	InstanceTypeM7gdMedium        InstanceType = "m7gd.medium"
	InstanceTypeM7gdLarge         InstanceType = "m7gd.large"
	InstanceTypeM7gdXlarge        InstanceType = "m7gd.xlarge"
	InstanceTypeM7gd2xlarge       InstanceType = "m7gd.2xlarge"
	InstanceTypeM7gd4xlarge       InstanceType = "m7gd.4xlarge"
	InstanceTypeM7gd8xlarge       InstanceType = "m7gd.8xlarge"
	InstanceTypeM7gd12xlarge      InstanceType = "m7gd.12xlarge"
	InstanceTypeM7gd16xlarge      InstanceType = "m7gd.16xlarge"
	InstanceTypeR7gdMedium        InstanceType = "r7gd.medium"
	InstanceTypeR7gdLarge         InstanceType = "r7gd.large"
	InstanceTypeR7gdXlarge        InstanceType = "r7gd.xlarge"
	InstanceTypeR7gd2xlarge       InstanceType = "r7gd.2xlarge"
	InstanceTypeR7gd4xlarge       InstanceType = "r7gd.4xlarge"
	InstanceTypeR7gd8xlarge       InstanceType = "r7gd.8xlarge"
	InstanceTypeR7gd12xlarge      InstanceType = "r7gd.12xlarge"
	InstanceTypeR7gd16xlarge      InstanceType = "r7gd.16xlarge"
	InstanceTypeR7aMedium         InstanceType = "r7a.medium"
	InstanceTypeR7aLarge          InstanceType = "r7a.large"
	InstanceTypeR7aXlarge         InstanceType = "r7a.xlarge"
	InstanceTypeR7a2xlarge        InstanceType = "r7a.2xlarge"
	InstanceTypeR7a4xlarge        InstanceType = "r7a.4xlarge"
	InstanceTypeR7a8xlarge        InstanceType = "r7a.8xlarge"
	InstanceTypeR7a12xlarge       InstanceType = "r7a.12xlarge"
	InstanceTypeR7a16xlarge       InstanceType = "r7a.16xlarge"
	InstanceTypeR7a24xlarge       InstanceType = "r7a.24xlarge"
	InstanceTypeR7a32xlarge       InstanceType = "r7a.32xlarge"
	InstanceTypeR7a48xlarge       InstanceType = "r7a.48xlarge"
	InstanceTypeC7iLarge          InstanceType = "c7i.large"
	InstanceTypeC7iXlarge         InstanceType = "c7i.xlarge"
	InstanceTypeC7i2xlarge        InstanceType = "c7i.2xlarge"
	InstanceTypeC7i4xlarge        InstanceType = "c7i.4xlarge"
	InstanceTypeC7i8xlarge        InstanceType = "c7i.8xlarge"
	InstanceTypeC7i12xlarge       InstanceType = "c7i.12xlarge"
	InstanceTypeC7i16xlarge       InstanceType = "c7i.16xlarge"
	InstanceTypeC7i24xlarge       InstanceType = "c7i.24xlarge"
	InstanceTypeC7i48xlarge       InstanceType = "c7i.48xlarge"
	InstanceTypeMac2M2proMetal    InstanceType = "mac2-m2pro.metal"
	InstanceTypeR7izLarge         InstanceType = "r7iz.large"
	InstanceTypeR7izXlarge        InstanceType = "r7iz.xlarge"
	InstanceTypeR7iz2xlarge       InstanceType = "r7iz.2xlarge"
	InstanceTypeR7iz4xlarge       InstanceType = "r7iz.4xlarge"
	InstanceTypeR7iz8xlarge       InstanceType = "r7iz.8xlarge"
	InstanceTypeR7iz12xlarge      InstanceType = "r7iz.12xlarge"
	InstanceTypeR7iz16xlarge      InstanceType = "r7iz.16xlarge"
	InstanceTypeR7iz32xlarge      InstanceType = "r7iz.32xlarge"
	InstanceTypeC7aMedium         InstanceType = "c7a.medium"
	InstanceTypeC7aLarge          InstanceType = "c7a.large"
	InstanceTypeC7aXlarge         InstanceType = "c7a.xlarge"
	InstanceTypeC7a2xlarge        InstanceType = "c7a.2xlarge"
	InstanceTypeC7a4xlarge        InstanceType = "c7a.4xlarge"
	InstanceTypeC7a8xlarge        InstanceType = "c7a.8xlarge"
	InstanceTypeC7a12xlarge       InstanceType = "c7a.12xlarge"
	InstanceTypeC7a16xlarge       InstanceType = "c7a.16xlarge"
	InstanceTypeC7a24xlarge       InstanceType = "c7a.24xlarge"
	InstanceTypeC7a32xlarge       InstanceType = "c7a.32xlarge"
	InstanceTypeC7a48xlarge       InstanceType = "c7a.48xlarge"
	InstanceTypeC7aMetal48xl      InstanceType = "c7a.metal-48xl"
	InstanceTypeR7aMetal48xl      InstanceType = "r7a.metal-48xl"
	InstanceTypeR7iLarge          InstanceType = "r7i.large"
	InstanceTypeR7iXlarge         InstanceType = "r7i.xlarge"
	InstanceTypeR7i2xlarge        InstanceType = "r7i.2xlarge"
	InstanceTypeR7i4xlarge        InstanceType = "r7i.4xlarge"
	InstanceTypeR7i8xlarge        InstanceType = "r7i.8xlarge"
	InstanceTypeR7i12xlarge       InstanceType = "r7i.12xlarge"
	InstanceTypeR7i16xlarge       InstanceType = "r7i.16xlarge"
	InstanceTypeR7i24xlarge       InstanceType = "r7i.24xlarge"
	InstanceTypeR7i48xlarge       InstanceType = "r7i.48xlarge"
	InstanceTypeDl2q24xlarge      InstanceType = "dl2q.24xlarge"
	InstanceTypeMac2M2Metal       InstanceType = "mac2-m2.metal"
	InstanceTypeI4i12xlarge       InstanceType = "i4i.12xlarge"
	InstanceTypeI4i24xlarge       InstanceType = "i4i.24xlarge"
	InstanceTypeC7iMetal24xl      InstanceType = "c7i.metal-24xl"
	InstanceTypeC7iMetal48xl      InstanceType = "c7i.metal-48xl"
	InstanceTypeM7iMetal24xl      InstanceType = "m7i.metal-24xl"
	InstanceTypeM7iMetal48xl      InstanceType = "m7i.metal-48xl"
	InstanceTypeR7iMetal24xl      InstanceType = "r7i.metal-24xl"
	InstanceTypeR7iMetal48xl      InstanceType = "r7i.metal-48xl"
	InstanceTypeR7izMetal16xl     InstanceType = "r7iz.metal-16xl"
	InstanceTypeR7izMetal32xl     InstanceType = "r7iz.metal-32xl"
	InstanceTypeC7gdMetal         InstanceType = "c7gd.metal"
	InstanceTypeM7gdMetal         InstanceType = "m7gd.metal"
	InstanceTypeR7gdMetal         InstanceType = "r7gd.metal"
	InstanceTypeG6Xlarge          InstanceType = "g6.xlarge"
	InstanceTypeG62xlarge         InstanceType = "g6.2xlarge"
	InstanceTypeG64xlarge         InstanceType = "g6.4xlarge"
	InstanceTypeG68xlarge         InstanceType = "g6.8xlarge"
	InstanceTypeG612xlarge        InstanceType = "g6.12xlarge"
	InstanceTypeG616xlarge        InstanceType = "g6.16xlarge"
	InstanceTypeG624xlarge        InstanceType = "g6.24xlarge"
	InstanceTypeG648xlarge        InstanceType = "g6.48xlarge"
	InstanceTypeGr64xlarge        InstanceType = "gr6.4xlarge"
	InstanceTypeGr68xlarge        InstanceType = "gr6.8xlarge"
	InstanceTypeC7iFlexLarge      InstanceType = "c7i-flex.large"
	InstanceTypeC7iFlexXlarge     InstanceType = "c7i-flex.xlarge"
	InstanceTypeC7iFlex2xlarge    InstanceType = "c7i-flex.2xlarge"
	InstanceTypeC7iFlex4xlarge    InstanceType = "c7i-flex.4xlarge"
	InstanceTypeC7iFlex8xlarge    InstanceType = "c7i-flex.8xlarge"
	InstanceTypeU7i12tb224xlarge  InstanceType = "u7i-12tb.224xlarge"
	InstanceTypeU7in16tb224xlarge InstanceType = "u7in-16tb.224xlarge"
	InstanceTypeU7in24tb224xlarge InstanceType = "u7in-24tb.224xlarge"
	InstanceTypeU7in32tb224xlarge InstanceType = "u7in-32tb.224xlarge"
	InstanceTypeU7ib12tb224xlarge InstanceType = "u7ib-12tb.224xlarge"
	InstanceTypeC7gnMetal         InstanceType = "c7gn.metal"
	InstanceTypeR8gMedium         InstanceType = "r8g.medium"
	InstanceTypeR8gLarge          InstanceType = "r8g.large"
	InstanceTypeR8gXlarge         InstanceType = "r8g.xlarge"
	InstanceTypeR8g2xlarge        InstanceType = "r8g.2xlarge"
	InstanceTypeR8g4xlarge        InstanceType = "r8g.4xlarge"
	InstanceTypeR8g8xlarge        InstanceType = "r8g.8xlarge"
	InstanceTypeR8g12xlarge       InstanceType = "r8g.12xlarge"
	InstanceTypeR8g16xlarge       InstanceType = "r8g.16xlarge"
	InstanceTypeR8g24xlarge       InstanceType = "r8g.24xlarge"
	InstanceTypeR8g48xlarge       InstanceType = "r8g.48xlarge"
	InstanceTypeR8gMetal24xl      InstanceType = "r8g.metal-24xl"
	InstanceTypeR8gMetal48xl      InstanceType = "r8g.metal-48xl"
	InstanceTypeMac2M1ultraMetal  InstanceType = "mac2-m1ultra.metal"
	InstanceTypeG6eXlarge         InstanceType = "g6e.xlarge"
	InstanceTypeG6e2xlarge        InstanceType = "g6e.2xlarge"
	InstanceTypeG6e4xlarge        InstanceType = "g6e.4xlarge"
	InstanceTypeG6e8xlarge        InstanceType = "g6e.8xlarge"
	InstanceTypeG6e12xlarge       InstanceType = "g6e.12xlarge"
	InstanceTypeG6e16xlarge       InstanceType = "g6e.16xlarge"
	InstanceTypeG6e24xlarge       InstanceType = "g6e.24xlarge"
	InstanceTypeG6e48xlarge       InstanceType = "g6e.48xlarge"
	InstanceTypeC8gMedium         InstanceType = "c8g.medium"
	InstanceTypeC8gLarge          InstanceType = "c8g.large"
	InstanceTypeC8gXlarge         InstanceType = "c8g.xlarge"
	InstanceTypeC8g2xlarge        InstanceType = "c8g.2xlarge"
	InstanceTypeC8g4xlarge        InstanceType = "c8g.4xlarge"
	InstanceTypeC8g8xlarge        InstanceType = "c8g.8xlarge"
	InstanceTypeC8g12xlarge       InstanceType = "c8g.12xlarge"
	InstanceTypeC8g16xlarge       InstanceType = "c8g.16xlarge"
	InstanceTypeC8g24xlarge       InstanceType = "c8g.24xlarge"
	InstanceTypeC8g48xlarge       InstanceType = "c8g.48xlarge"
	InstanceTypeC8gMetal24xl      InstanceType = "c8g.metal-24xl"
	InstanceTypeC8gMetal48xl      InstanceType = "c8g.metal-48xl"
	InstanceTypeM8gMedium         InstanceType = "m8g.medium"
	InstanceTypeM8gLarge          InstanceType = "m8g.large"
	InstanceTypeM8gXlarge         InstanceType = "m8g.xlarge"
	InstanceTypeM8g2xlarge        InstanceType = "m8g.2xlarge"
	InstanceTypeM8g4xlarge        InstanceType = "m8g.4xlarge"
	InstanceTypeM8g8xlarge        InstanceType = "m8g.8xlarge"
	InstanceTypeM8g12xlarge       InstanceType = "m8g.12xlarge"
	InstanceTypeM8g16xlarge       InstanceType = "m8g.16xlarge"
	InstanceTypeM8g24xlarge       InstanceType = "m8g.24xlarge"
	InstanceTypeM8g48xlarge       InstanceType = "m8g.48xlarge"
	InstanceTypeM8gMetal24xl      InstanceType = "m8g.metal-24xl"
	InstanceTypeM8gMetal48xl      InstanceType = "m8g.metal-48xl"
	InstanceTypeX8gMedium         InstanceType = "x8g.medium"
	InstanceTypeX8gLarge          InstanceType = "x8g.large"
	InstanceTypeX8gXlarge         InstanceType = "x8g.xlarge"
	InstanceTypeX8g2xlarge        InstanceType = "x8g.2xlarge"
	InstanceTypeX8g4xlarge        InstanceType = "x8g.4xlarge"
	InstanceTypeX8g8xlarge        InstanceType = "x8g.8xlarge"
	InstanceTypeX8g12xlarge       InstanceType = "x8g.12xlarge"
	InstanceTypeX8g16xlarge       InstanceType = "x8g.16xlarge"
	InstanceTypeX8g24xlarge       InstanceType = "x8g.24xlarge"
	InstanceTypeX8g48xlarge       InstanceType = "x8g.48xlarge"
	InstanceTypeX8gMetal24xl      InstanceType = "x8g.metal-24xl"
	InstanceTypeX8gMetal48xl      InstanceType = "x8g.metal-48xl"
)

// Values returns all known values for InstanceType. 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 (InstanceType) Values() []InstanceType {
	return []InstanceType{
		"a1.medium",
		"a1.large",
		"a1.xlarge",
		"a1.2xlarge",
		"a1.4xlarge",
		"a1.metal",
		"c1.medium",
		"c1.xlarge",
		"c3.large",
		"c3.xlarge",
		"c3.2xlarge",
		"c3.4xlarge",
		"c3.8xlarge",
		"c4.large",
		"c4.xlarge",
		"c4.2xlarge",
		"c4.4xlarge",
		"c4.8xlarge",
		"c5.large",
		"c5.xlarge",
		"c5.2xlarge",
		"c5.4xlarge",
		"c5.9xlarge",
		"c5.12xlarge",
		"c5.18xlarge",
		"c5.24xlarge",
		"c5.metal",
		"c5a.large",
		"c5a.xlarge",
		"c5a.2xlarge",
		"c5a.4xlarge",
		"c5a.8xlarge",
		"c5a.12xlarge",
		"c5a.16xlarge",
		"c5a.24xlarge",
		"c5ad.large",
		"c5ad.xlarge",
		"c5ad.2xlarge",
		"c5ad.4xlarge",
		"c5ad.8xlarge",
		"c5ad.12xlarge",
		"c5ad.16xlarge",
		"c5ad.24xlarge",
		"c5d.large",
		"c5d.xlarge",
		"c5d.2xlarge",
		"c5d.4xlarge",
		"c5d.9xlarge",
		"c5d.12xlarge",
		"c5d.18xlarge",
		"c5d.24xlarge",
		"c5d.metal",
		"c5n.large",
		"c5n.xlarge",
		"c5n.2xlarge",
		"c5n.4xlarge",
		"c5n.9xlarge",
		"c5n.18xlarge",
		"c5n.metal",
		"c6g.medium",
		"c6g.large",
		"c6g.xlarge",
		"c6g.2xlarge",
		"c6g.4xlarge",
		"c6g.8xlarge",
		"c6g.12xlarge",
		"c6g.16xlarge",
		"c6g.metal",
		"c6gd.medium",
		"c6gd.large",
		"c6gd.xlarge",
		"c6gd.2xlarge",
		"c6gd.4xlarge",
		"c6gd.8xlarge",
		"c6gd.12xlarge",
		"c6gd.16xlarge",
		"c6gd.metal",
		"c6gn.medium",
		"c6gn.large",
		"c6gn.xlarge",
		"c6gn.2xlarge",
		"c6gn.4xlarge",
		"c6gn.8xlarge",
		"c6gn.12xlarge",
		"c6gn.16xlarge",
		"c6i.large",
		"c6i.xlarge",
		"c6i.2xlarge",
		"c6i.4xlarge",
		"c6i.8xlarge",
		"c6i.12xlarge",
		"c6i.16xlarge",
		"c6i.24xlarge",
		"c6i.32xlarge",
		"c6i.metal",
		"cc1.4xlarge",
		"cc2.8xlarge",
		"cg1.4xlarge",
		"cr1.8xlarge",
		"d2.xlarge",
		"d2.2xlarge",
		"d2.4xlarge",
		"d2.8xlarge",
		"d3.xlarge",
		"d3.2xlarge",
		"d3.4xlarge",
		"d3.8xlarge",
		"d3en.xlarge",
		"d3en.2xlarge",
		"d3en.4xlarge",
		"d3en.6xlarge",
		"d3en.8xlarge",
		"d3en.12xlarge",
		"dl1.24xlarge",
		"f1.2xlarge",
		"f1.4xlarge",
		"f1.16xlarge",
		"g2.2xlarge",
		"g2.8xlarge",
		"g3.4xlarge",
		"g3.8xlarge",
		"g3.16xlarge",
		"g3s.xlarge",
		"g4ad.xlarge",
		"g4ad.2xlarge",
		"g4ad.4xlarge",
		"g4ad.8xlarge",
		"g4ad.16xlarge",
		"g4dn.xlarge",
		"g4dn.2xlarge",
		"g4dn.4xlarge",
		"g4dn.8xlarge",
		"g4dn.12xlarge",
		"g4dn.16xlarge",
		"g4dn.metal",
		"g5.xlarge",
		"g5.2xlarge",
		"g5.4xlarge",
		"g5.8xlarge",
		"g5.12xlarge",
		"g5.16xlarge",
		"g5.24xlarge",
		"g5.48xlarge",
		"g5g.xlarge",
		"g5g.2xlarge",
		"g5g.4xlarge",
		"g5g.8xlarge",
		"g5g.16xlarge",
		"g5g.metal",
		"hi1.4xlarge",
		"hpc6a.48xlarge",
		"hs1.8xlarge",
		"h1.2xlarge",
		"h1.4xlarge",
		"h1.8xlarge",
		"h1.16xlarge",
		"i2.xlarge",
		"i2.2xlarge",
		"i2.4xlarge",
		"i2.8xlarge",
		"i3.large",
		"i3.xlarge",
		"i3.2xlarge",
		"i3.4xlarge",
		"i3.8xlarge",
		"i3.16xlarge",
		"i3.metal",
		"i3en.large",
		"i3en.xlarge",
		"i3en.2xlarge",
		"i3en.3xlarge",
		"i3en.6xlarge",
		"i3en.12xlarge",
		"i3en.24xlarge",
		"i3en.metal",
		"im4gn.large",
		"im4gn.xlarge",
		"im4gn.2xlarge",
		"im4gn.4xlarge",
		"im4gn.8xlarge",
		"im4gn.16xlarge",
		"inf1.xlarge",
		"inf1.2xlarge",
		"inf1.6xlarge",
		"inf1.24xlarge",
		"is4gen.medium",
		"is4gen.large",
		"is4gen.xlarge",
		"is4gen.2xlarge",
		"is4gen.4xlarge",
		"is4gen.8xlarge",
		"m1.small",
		"m1.medium",
		"m1.large",
		"m1.xlarge",
		"m2.xlarge",
		"m2.2xlarge",
		"m2.4xlarge",
		"m3.medium",
		"m3.large",
		"m3.xlarge",
		"m3.2xlarge",
		"m4.large",
		"m4.xlarge",
		"m4.2xlarge",
		"m4.4xlarge",
		"m4.10xlarge",
		"m4.16xlarge",
		"m5.large",
		"m5.xlarge",
		"m5.2xlarge",
		"m5.4xlarge",
		"m5.8xlarge",
		"m5.12xlarge",
		"m5.16xlarge",
		"m5.24xlarge",
		"m5.metal",
		"m5a.large",
		"m5a.xlarge",
		"m5a.2xlarge",
		"m5a.4xlarge",
		"m5a.8xlarge",
		"m5a.12xlarge",
		"m5a.16xlarge",
		"m5a.24xlarge",
		"m5ad.large",
		"m5ad.xlarge",
		"m5ad.2xlarge",
		"m5ad.4xlarge",
		"m5ad.8xlarge",
		"m5ad.12xlarge",
		"m5ad.16xlarge",
		"m5ad.24xlarge",
		"m5d.large",
		"m5d.xlarge",
		"m5d.2xlarge",
		"m5d.4xlarge",
		"m5d.8xlarge",
		"m5d.12xlarge",
		"m5d.16xlarge",
		"m5d.24xlarge",
		"m5d.metal",
		"m5dn.large",
		"m5dn.xlarge",
		"m5dn.2xlarge",
		"m5dn.4xlarge",
		"m5dn.8xlarge",
		"m5dn.12xlarge",
		"m5dn.16xlarge",
		"m5dn.24xlarge",
		"m5dn.metal",
		"m5n.large",
		"m5n.xlarge",
		"m5n.2xlarge",
		"m5n.4xlarge",
		"m5n.8xlarge",
		"m5n.12xlarge",
		"m5n.16xlarge",
		"m5n.24xlarge",
		"m5n.metal",
		"m5zn.large",
		"m5zn.xlarge",
		"m5zn.2xlarge",
		"m5zn.3xlarge",
		"m5zn.6xlarge",
		"m5zn.12xlarge",
		"m5zn.metal",
		"m6a.large",
		"m6a.xlarge",
		"m6a.2xlarge",
		"m6a.4xlarge",
		"m6a.8xlarge",
		"m6a.12xlarge",
		"m6a.16xlarge",
		"m6a.24xlarge",
		"m6a.32xlarge",
		"m6a.48xlarge",
		"m6g.metal",
		"m6g.medium",
		"m6g.large",
		"m6g.xlarge",
		"m6g.2xlarge",
		"m6g.4xlarge",
		"m6g.8xlarge",
		"m6g.12xlarge",
		"m6g.16xlarge",
		"m6gd.metal",
		"m6gd.medium",
		"m6gd.large",
		"m6gd.xlarge",
		"m6gd.2xlarge",
		"m6gd.4xlarge",
		"m6gd.8xlarge",
		"m6gd.12xlarge",
		"m6gd.16xlarge",
		"m6i.large",
		"m6i.xlarge",
		"m6i.2xlarge",
		"m6i.4xlarge",
		"m6i.8xlarge",
		"m6i.12xlarge",
		"m6i.16xlarge",
		"m6i.24xlarge",
		"m6i.32xlarge",
		"m6i.metal",
		"mac1.metal",
		"p2.xlarge",
		"p2.8xlarge",
		"p2.16xlarge",
		"p3.2xlarge",
		"p3.8xlarge",
		"p3.16xlarge",
		"p3dn.24xlarge",
		"p4d.24xlarge",
		"r3.large",
		"r3.xlarge",
		"r3.2xlarge",
		"r3.4xlarge",
		"r3.8xlarge",
		"r4.large",
		"r4.xlarge",
		"r4.2xlarge",
		"r4.4xlarge",
		"r4.8xlarge",
		"r4.16xlarge",
		"r5.large",
		"r5.xlarge",
		"r5.2xlarge",
		"r5.4xlarge",
		"r5.8xlarge",
		"r5.12xlarge",
		"r5.16xlarge",
		"r5.24xlarge",
		"r5.metal",
		"r5a.large",
		"r5a.xlarge",
		"r5a.2xlarge",
		"r5a.4xlarge",
		"r5a.8xlarge",
		"r5a.12xlarge",
		"r5a.16xlarge",
		"r5a.24xlarge",
		"r5ad.large",
		"r5ad.xlarge",
		"r5ad.2xlarge",
		"r5ad.4xlarge",
		"r5ad.8xlarge",
		"r5ad.12xlarge",
		"r5ad.16xlarge",
		"r5ad.24xlarge",
		"r5b.large",
		"r5b.xlarge",
		"r5b.2xlarge",
		"r5b.4xlarge",
		"r5b.8xlarge",
		"r5b.12xlarge",
		"r5b.16xlarge",
		"r5b.24xlarge",
		"r5b.metal",
		"r5d.large",
		"r5d.xlarge",
		"r5d.2xlarge",
		"r5d.4xlarge",
		"r5d.8xlarge",
		"r5d.12xlarge",
		"r5d.16xlarge",
		"r5d.24xlarge",
		"r5d.metal",
		"r5dn.large",
		"r5dn.xlarge",
		"r5dn.2xlarge",
		"r5dn.4xlarge",
		"r5dn.8xlarge",
		"r5dn.12xlarge",
		"r5dn.16xlarge",
		"r5dn.24xlarge",
		"r5dn.metal",
		"r5n.large",
		"r5n.xlarge",
		"r5n.2xlarge",
		"r5n.4xlarge",
		"r5n.8xlarge",
		"r5n.12xlarge",
		"r5n.16xlarge",
		"r5n.24xlarge",
		"r5n.metal",
		"r6g.medium",
		"r6g.large",
		"r6g.xlarge",
		"r6g.2xlarge",
		"r6g.4xlarge",
		"r6g.8xlarge",
		"r6g.12xlarge",
		"r6g.16xlarge",
		"r6g.metal",
		"r6gd.medium",
		"r6gd.large",
		"r6gd.xlarge",
		"r6gd.2xlarge",
		"r6gd.4xlarge",
		"r6gd.8xlarge",
		"r6gd.12xlarge",
		"r6gd.16xlarge",
		"r6gd.metal",
		"r6i.large",
		"r6i.xlarge",
		"r6i.2xlarge",
		"r6i.4xlarge",
		"r6i.8xlarge",
		"r6i.12xlarge",
		"r6i.16xlarge",
		"r6i.24xlarge",
		"r6i.32xlarge",
		"r6i.metal",
		"t1.micro",
		"t2.nano",
		"t2.micro",
		"t2.small",
		"t2.medium",
		"t2.large",
		"t2.xlarge",
		"t2.2xlarge",
		"t3.nano",
		"t3.micro",
		"t3.small",
		"t3.medium",
		"t3.large",
		"t3.xlarge",
		"t3.2xlarge",
		"t3a.nano",
		"t3a.micro",
		"t3a.small",
		"t3a.medium",
		"t3a.large",
		"t3a.xlarge",
		"t3a.2xlarge",
		"t4g.nano",
		"t4g.micro",
		"t4g.small",
		"t4g.medium",
		"t4g.large",
		"t4g.xlarge",
		"t4g.2xlarge",
		"u-6tb1.56xlarge",
		"u-6tb1.112xlarge",
		"u-9tb1.112xlarge",
		"u-12tb1.112xlarge",
		"u-6tb1.metal",
		"u-9tb1.metal",
		"u-12tb1.metal",
		"u-18tb1.metal",
		"u-24tb1.metal",
		"vt1.3xlarge",
		"vt1.6xlarge",
		"vt1.24xlarge",
		"x1.16xlarge",
		"x1.32xlarge",
		"x1e.xlarge",
		"x1e.2xlarge",
		"x1e.4xlarge",
		"x1e.8xlarge",
		"x1e.16xlarge",
		"x1e.32xlarge",
		"x2iezn.2xlarge",
		"x2iezn.4xlarge",
		"x2iezn.6xlarge",
		"x2iezn.8xlarge",
		"x2iezn.12xlarge",
		"x2iezn.metal",
		"x2gd.medium",
		"x2gd.large",
		"x2gd.xlarge",
		"x2gd.2xlarge",
		"x2gd.4xlarge",
		"x2gd.8xlarge",
		"x2gd.12xlarge",
		"x2gd.16xlarge",
		"x2gd.metal",
		"z1d.large",
		"z1d.xlarge",
		"z1d.2xlarge",
		"z1d.3xlarge",
		"z1d.6xlarge",
		"z1d.12xlarge",
		"z1d.metal",
		"x2idn.16xlarge",
		"x2idn.24xlarge",
		"x2idn.32xlarge",
		"x2iedn.xlarge",
		"x2iedn.2xlarge",
		"x2iedn.4xlarge",
		"x2iedn.8xlarge",
		"x2iedn.16xlarge",
		"x2iedn.24xlarge",
		"x2iedn.32xlarge",
		"c6a.large",
		"c6a.xlarge",
		"c6a.2xlarge",
		"c6a.4xlarge",
		"c6a.8xlarge",
		"c6a.12xlarge",
		"c6a.16xlarge",
		"c6a.24xlarge",
		"c6a.32xlarge",
		"c6a.48xlarge",
		"c6a.metal",
		"m6a.metal",
		"i4i.large",
		"i4i.xlarge",
		"i4i.2xlarge",
		"i4i.4xlarge",
		"i4i.8xlarge",
		"i4i.16xlarge",
		"i4i.32xlarge",
		"i4i.metal",
		"x2idn.metal",
		"x2iedn.metal",
		"c7g.medium",
		"c7g.large",
		"c7g.xlarge",
		"c7g.2xlarge",
		"c7g.4xlarge",
		"c7g.8xlarge",
		"c7g.12xlarge",
		"c7g.16xlarge",
		"mac2.metal",
		"c6id.large",
		"c6id.xlarge",
		"c6id.2xlarge",
		"c6id.4xlarge",
		"c6id.8xlarge",
		"c6id.12xlarge",
		"c6id.16xlarge",
		"c6id.24xlarge",
		"c6id.32xlarge",
		"c6id.metal",
		"m6id.large",
		"m6id.xlarge",
		"m6id.2xlarge",
		"m6id.4xlarge",
		"m6id.8xlarge",
		"m6id.12xlarge",
		"m6id.16xlarge",
		"m6id.24xlarge",
		"m6id.32xlarge",
		"m6id.metal",
		"r6id.large",
		"r6id.xlarge",
		"r6id.2xlarge",
		"r6id.4xlarge",
		"r6id.8xlarge",
		"r6id.12xlarge",
		"r6id.16xlarge",
		"r6id.24xlarge",
		"r6id.32xlarge",
		"r6id.metal",
		"r6a.large",
		"r6a.xlarge",
		"r6a.2xlarge",
		"r6a.4xlarge",
		"r6a.8xlarge",
		"r6a.12xlarge",
		"r6a.16xlarge",
		"r6a.24xlarge",
		"r6a.32xlarge",
		"r6a.48xlarge",
		"r6a.metal",
		"p4de.24xlarge",
		"u-3tb1.56xlarge",
		"u-18tb1.112xlarge",
		"u-24tb1.112xlarge",
		"trn1.2xlarge",
		"trn1.32xlarge",
		"hpc6id.32xlarge",
		"c6in.large",
		"c6in.xlarge",
		"c6in.2xlarge",
		"c6in.4xlarge",
		"c6in.8xlarge",
		"c6in.12xlarge",
		"c6in.16xlarge",
		"c6in.24xlarge",
		"c6in.32xlarge",
		"m6in.large",
		"m6in.xlarge",
		"m6in.2xlarge",
		"m6in.4xlarge",
		"m6in.8xlarge",
		"m6in.12xlarge",
		"m6in.16xlarge",
		"m6in.24xlarge",
		"m6in.32xlarge",
		"m6idn.large",
		"m6idn.xlarge",
		"m6idn.2xlarge",
		"m6idn.4xlarge",
		"m6idn.8xlarge",
		"m6idn.12xlarge",
		"m6idn.16xlarge",
		"m6idn.24xlarge",
		"m6idn.32xlarge",
		"r6in.large",
		"r6in.xlarge",
		"r6in.2xlarge",
		"r6in.4xlarge",
		"r6in.8xlarge",
		"r6in.12xlarge",
		"r6in.16xlarge",
		"r6in.24xlarge",
		"r6in.32xlarge",
		"r6idn.large",
		"r6idn.xlarge",
		"r6idn.2xlarge",
		"r6idn.4xlarge",
		"r6idn.8xlarge",
		"r6idn.12xlarge",
		"r6idn.16xlarge",
		"r6idn.24xlarge",
		"r6idn.32xlarge",
		"c7g.metal",
		"m7g.medium",
		"m7g.large",
		"m7g.xlarge",
		"m7g.2xlarge",
		"m7g.4xlarge",
		"m7g.8xlarge",
		"m7g.12xlarge",
		"m7g.16xlarge",
		"m7g.metal",
		"r7g.medium",
		"r7g.large",
		"r7g.xlarge",
		"r7g.2xlarge",
		"r7g.4xlarge",
		"r7g.8xlarge",
		"r7g.12xlarge",
		"r7g.16xlarge",
		"r7g.metal",
		"c6in.metal",
		"m6in.metal",
		"m6idn.metal",
		"r6in.metal",
		"r6idn.metal",
		"inf2.xlarge",
		"inf2.8xlarge",
		"inf2.24xlarge",
		"inf2.48xlarge",
		"trn1n.32xlarge",
		"i4g.large",
		"i4g.xlarge",
		"i4g.2xlarge",
		"i4g.4xlarge",
		"i4g.8xlarge",
		"i4g.16xlarge",
		"hpc7g.4xlarge",
		"hpc7g.8xlarge",
		"hpc7g.16xlarge",
		"c7gn.medium",
		"c7gn.large",
		"c7gn.xlarge",
		"c7gn.2xlarge",
		"c7gn.4xlarge",
		"c7gn.8xlarge",
		"c7gn.12xlarge",
		"c7gn.16xlarge",
		"p5.48xlarge",
		"m7i.large",
		"m7i.xlarge",
		"m7i.2xlarge",
		"m7i.4xlarge",
		"m7i.8xlarge",
		"m7i.12xlarge",
		"m7i.16xlarge",
		"m7i.24xlarge",
		"m7i.48xlarge",
		"m7i-flex.large",
		"m7i-flex.xlarge",
		"m7i-flex.2xlarge",
		"m7i-flex.4xlarge",
		"m7i-flex.8xlarge",
		"m7a.medium",
		"m7a.large",
		"m7a.xlarge",
		"m7a.2xlarge",
		"m7a.4xlarge",
		"m7a.8xlarge",
		"m7a.12xlarge",
		"m7a.16xlarge",
		"m7a.24xlarge",
		"m7a.32xlarge",
		"m7a.48xlarge",
		"m7a.metal-48xl",
		"hpc7a.12xlarge",
		"hpc7a.24xlarge",
		"hpc7a.48xlarge",
		"hpc7a.96xlarge",
		"c7gd.medium",
		"c7gd.large",
		"c7gd.xlarge",
		"c7gd.2xlarge",
		"c7gd.4xlarge",
		"c7gd.8xlarge",
		"c7gd.12xlarge",
		"c7gd.16xlarge",
		"m7gd.medium",
		"m7gd.large",
		"m7gd.xlarge",
		"m7gd.2xlarge",
		"m7gd.4xlarge",
		"m7gd.8xlarge",
		"m7gd.12xlarge",
		"m7gd.16xlarge",
		"r7gd.medium",
		"r7gd.large",
		"r7gd.xlarge",
		"r7gd.2xlarge",
		"r7gd.4xlarge",
		"r7gd.8xlarge",
		"r7gd.12xlarge",
		"r7gd.16xlarge",
		"r7a.medium",
		"r7a.large",
		"r7a.xlarge",
		"r7a.2xlarge",
		"r7a.4xlarge",
		"r7a.8xlarge",
		"r7a.12xlarge",
		"r7a.16xlarge",
		"r7a.24xlarge",
		"r7a.32xlarge",
		"r7a.48xlarge",
		"c7i.large",
		"c7i.xlarge",
		"c7i.2xlarge",
		"c7i.4xlarge",
		"c7i.8xlarge",
		"c7i.12xlarge",
		"c7i.16xlarge",
		"c7i.24xlarge",
		"c7i.48xlarge",
		"mac2-m2pro.metal",
		"r7iz.large",
		"r7iz.xlarge",
		"r7iz.2xlarge",
		"r7iz.4xlarge",
		"r7iz.8xlarge",
		"r7iz.12xlarge",
		"r7iz.16xlarge",
		"r7iz.32xlarge",
		"c7a.medium",
		"c7a.large",
		"c7a.xlarge",
		"c7a.2xlarge",
		"c7a.4xlarge",
		"c7a.8xlarge",
		"c7a.12xlarge",
		"c7a.16xlarge",
		"c7a.24xlarge",
		"c7a.32xlarge",
		"c7a.48xlarge",
		"c7a.metal-48xl",
		"r7a.metal-48xl",
		"r7i.large",
		"r7i.xlarge",
		"r7i.2xlarge",
		"r7i.4xlarge",
		"r7i.8xlarge",
		"r7i.12xlarge",
		"r7i.16xlarge",
		"r7i.24xlarge",
		"r7i.48xlarge",
		"dl2q.24xlarge",
		"mac2-m2.metal",
		"i4i.12xlarge",
		"i4i.24xlarge",
		"c7i.metal-24xl",
		"c7i.metal-48xl",
		"m7i.metal-24xl",
		"m7i.metal-48xl",
		"r7i.metal-24xl",
		"r7i.metal-48xl",
		"r7iz.metal-16xl",
		"r7iz.metal-32xl",
		"c7gd.metal",
		"m7gd.metal",
		"r7gd.metal",
		"g6.xlarge",
		"g6.2xlarge",
		"g6.4xlarge",
		"g6.8xlarge",
		"g6.12xlarge",
		"g6.16xlarge",
		"g6.24xlarge",
		"g6.48xlarge",
		"gr6.4xlarge",
		"gr6.8xlarge",
		"c7i-flex.large",
		"c7i-flex.xlarge",
		"c7i-flex.2xlarge",
		"c7i-flex.4xlarge",
		"c7i-flex.8xlarge",
		"u7i-12tb.224xlarge",
		"u7in-16tb.224xlarge",
		"u7in-24tb.224xlarge",
		"u7in-32tb.224xlarge",
		"u7ib-12tb.224xlarge",
		"c7gn.metal",
		"r8g.medium",
		"r8g.large",
		"r8g.xlarge",
		"r8g.2xlarge",
		"r8g.4xlarge",
		"r8g.8xlarge",
		"r8g.12xlarge",
		"r8g.16xlarge",
		"r8g.24xlarge",
		"r8g.48xlarge",
		"r8g.metal-24xl",
		"r8g.metal-48xl",
		"mac2-m1ultra.metal",
		"g6e.xlarge",
		"g6e.2xlarge",
		"g6e.4xlarge",
		"g6e.8xlarge",
		"g6e.12xlarge",
		"g6e.16xlarge",
		"g6e.24xlarge",
		"g6e.48xlarge",
		"c8g.medium",
		"c8g.large",
		"c8g.xlarge",
		"c8g.2xlarge",
		"c8g.4xlarge",
		"c8g.8xlarge",
		"c8g.12xlarge",
		"c8g.16xlarge",
		"c8g.24xlarge",
		"c8g.48xlarge",
		"c8g.metal-24xl",
		"c8g.metal-48xl",
		"m8g.medium",
		"m8g.large",
		"m8g.xlarge",
		"m8g.2xlarge",
		"m8g.4xlarge",
		"m8g.8xlarge",
		"m8g.12xlarge",
		"m8g.16xlarge",
		"m8g.24xlarge",
		"m8g.48xlarge",
		"m8g.metal-24xl",
		"m8g.metal-48xl",
		"x8g.medium",
		"x8g.large",
		"x8g.xlarge",
		"x8g.2xlarge",
		"x8g.4xlarge",
		"x8g.8xlarge",
		"x8g.12xlarge",
		"x8g.16xlarge",
		"x8g.24xlarge",
		"x8g.48xlarge",
		"x8g.metal-24xl",
		"x8g.metal-48xl",
	}
}

type InstanceTypeHypervisor string

// Enum values for InstanceTypeHypervisor
const (
	InstanceTypeHypervisorNitro InstanceTypeHypervisor = "nitro"
	InstanceTypeHypervisorXen   InstanceTypeHypervisor = "xen"
)

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

type InterfacePermissionType string

// Enum values for InterfacePermissionType
const (
	InterfacePermissionTypeInstanceAttach InterfacePermissionType = "INSTANCE-ATTACH"
	InterfacePermissionTypeEipAssociate   InterfacePermissionType = "EIP-ASSOCIATE"
)

// Values returns all known values for InterfacePermissionType. 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 (InterfacePermissionType) Values() []InterfacePermissionType {
	return []InterfacePermissionType{
		"INSTANCE-ATTACH",
		"EIP-ASSOCIATE",
	}
}

type InterfaceProtocolType string

// Enum values for InterfaceProtocolType
const (
	InterfaceProtocolTypeVlan InterfaceProtocolType = "VLAN"
	InterfaceProtocolTypeGre  InterfaceProtocolType = "GRE"
)

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

type InternetGatewayBlockMode string

// Enum values for InternetGatewayBlockMode
const (
	InternetGatewayBlockModeOff                InternetGatewayBlockMode = "off"
	InternetGatewayBlockModeBlockBidirectional InternetGatewayBlockMode = "block-bidirectional"
	InternetGatewayBlockModeBlockIngress       InternetGatewayBlockMode = "block-ingress"
)

// Values returns all known values for InternetGatewayBlockMode. 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 (InternetGatewayBlockMode) Values() []InternetGatewayBlockMode {
	return []InternetGatewayBlockMode{
		"off",
		"block-bidirectional",
		"block-ingress",
	}
}

type InternetGatewayExclusionMode string

// Enum values for InternetGatewayExclusionMode
const (
	InternetGatewayExclusionModeAllowBidirectional InternetGatewayExclusionMode = "allow-bidirectional"
	InternetGatewayExclusionModeAllowEgress        InternetGatewayExclusionMode = "allow-egress"
)

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

type IpAddressType string

// Enum values for IpAddressType
const (
	IpAddressTypeIpv4      IpAddressType = "ipv4"
	IpAddressTypeDualstack IpAddressType = "dualstack"
	IpAddressTypeIpv6      IpAddressType = "ipv6"
)

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

type IpamAddressHistoryResourceType string

// Enum values for IpamAddressHistoryResourceType
const (
	IpamAddressHistoryResourceTypeEip              IpamAddressHistoryResourceType = "eip"
	IpamAddressHistoryResourceTypeVpc              IpamAddressHistoryResourceType = "vpc"
	IpamAddressHistoryResourceTypeSubnet           IpamAddressHistoryResourceType = "subnet"
	IpamAddressHistoryResourceTypeNetworkInterface IpamAddressHistoryResourceType = "network-interface"
	IpamAddressHistoryResourceTypeInstance         IpamAddressHistoryResourceType = "instance"
)

// Values returns all known values for IpamAddressHistoryResourceType. 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 (IpamAddressHistoryResourceType) Values() []IpamAddressHistoryResourceType {
	return []IpamAddressHistoryResourceType{
		"eip",
		"vpc",
		"subnet",
		"network-interface",
		"instance",
	}
}

type IpamAssociatedResourceDiscoveryStatus string

// Enum values for IpamAssociatedResourceDiscoveryStatus
const (
	IpamAssociatedResourceDiscoveryStatusActive   IpamAssociatedResourceDiscoveryStatus = "active"
	IpamAssociatedResourceDiscoveryStatusNotFound IpamAssociatedResourceDiscoveryStatus = "not-found"
)

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

type IpamComplianceStatus string

// Enum values for IpamComplianceStatus
const (
	IpamComplianceStatusCompliant    IpamComplianceStatus = "compliant"
	IpamComplianceStatusNoncompliant IpamComplianceStatus = "noncompliant"
	IpamComplianceStatusUnmanaged    IpamComplianceStatus = "unmanaged"
	IpamComplianceStatusIgnored      IpamComplianceStatus = "ignored"
)

// Values returns all known values for IpamComplianceStatus. 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 (IpamComplianceStatus) Values() []IpamComplianceStatus {
	return []IpamComplianceStatus{
		"compliant",
		"noncompliant",
		"unmanaged",
		"ignored",
	}
}

type IpamDiscoveryFailureCode string

// Enum values for IpamDiscoveryFailureCode
const (
	IpamDiscoveryFailureCodeAssumeRoleFailure   IpamDiscoveryFailureCode = "assume-role-failure"
	IpamDiscoveryFailureCodeThrottlingFailure   IpamDiscoveryFailureCode = "throttling-failure"
	IpamDiscoveryFailureCodeUnauthorizedFailure IpamDiscoveryFailureCode = "unauthorized-failure"
)

// Values returns all known values for IpamDiscoveryFailureCode. 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 (IpamDiscoveryFailureCode) Values() []IpamDiscoveryFailureCode {
	return []IpamDiscoveryFailureCode{
		"assume-role-failure",
		"throttling-failure",
		"unauthorized-failure",
	}
}

type IpamExternalResourceVerificationTokenState string

// Enum values for IpamExternalResourceVerificationTokenState
const (
	IpamExternalResourceVerificationTokenStateCreateInProgress IpamExternalResourceVerificationTokenState = "create-in-progress"
	IpamExternalResourceVerificationTokenStateCreateComplete   IpamExternalResourceVerificationTokenState = "create-complete"
	IpamExternalResourceVerificationTokenStateCreateFailed     IpamExternalResourceVerificationTokenState = "create-failed"
	IpamExternalResourceVerificationTokenStateDeleteInProgress IpamExternalResourceVerificationTokenState = "delete-in-progress"
	IpamExternalResourceVerificationTokenStateDeleteComplete   IpamExternalResourceVerificationTokenState = "delete-complete"
	IpamExternalResourceVerificationTokenStateDeleteFailed     IpamExternalResourceVerificationTokenState = "delete-failed"
)

// Values returns all known values for IpamExternalResourceVerificationTokenState.
// 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 (IpamExternalResourceVerificationTokenState) Values() []IpamExternalResourceVerificationTokenState {
	return []IpamExternalResourceVerificationTokenState{
		"create-in-progress",
		"create-complete",
		"create-failed",
		"delete-in-progress",
		"delete-complete",
		"delete-failed",
	}
}

type IpamManagementState string

// Enum values for IpamManagementState
const (
	IpamManagementStateManaged   IpamManagementState = "managed"
	IpamManagementStateUnmanaged IpamManagementState = "unmanaged"
	IpamManagementStateIgnored   IpamManagementState = "ignored"
)

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

type IpamNetworkInterfaceAttachmentStatus string

// Enum values for IpamNetworkInterfaceAttachmentStatus
const (
	IpamNetworkInterfaceAttachmentStatusAvailable IpamNetworkInterfaceAttachmentStatus = "available"
	IpamNetworkInterfaceAttachmentStatusInUse     IpamNetworkInterfaceAttachmentStatus = "in-use"
)

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

type IpamOverlapStatus string

// Enum values for IpamOverlapStatus
const (
	IpamOverlapStatusOverlapping    IpamOverlapStatus = "overlapping"
	IpamOverlapStatusNonoverlapping IpamOverlapStatus = "nonoverlapping"
	IpamOverlapStatusIgnored        IpamOverlapStatus = "ignored"
)

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

type IpamPoolAllocationResourceType string

// Enum values for IpamPoolAllocationResourceType
const (
	IpamPoolAllocationResourceTypeIpamPool          IpamPoolAllocationResourceType = "ipam-pool"
	IpamPoolAllocationResourceTypeVpc               IpamPoolAllocationResourceType = "vpc"
	IpamPoolAllocationResourceTypeEc2PublicIpv4Pool IpamPoolAllocationResourceType = "ec2-public-ipv4-pool"
	IpamPoolAllocationResourceTypeCustom            IpamPoolAllocationResourceType = "custom"
	IpamPoolAllocationResourceTypeSubnet            IpamPoolAllocationResourceType = "subnet"
	IpamPoolAllocationResourceTypeEip               IpamPoolAllocationResourceType = "eip"
)

// Values returns all known values for IpamPoolAllocationResourceType. 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 (IpamPoolAllocationResourceType) Values() []IpamPoolAllocationResourceType {
	return []IpamPoolAllocationResourceType{
		"ipam-pool",
		"vpc",
		"ec2-public-ipv4-pool",
		"custom",
		"subnet",
		"eip",
	}
}

type IpamPoolAwsService string

// Enum values for IpamPoolAwsService
const (
	IpamPoolAwsServiceEc2 IpamPoolAwsService = "ec2"
)

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

type IpamPoolCidrFailureCode string

// Enum values for IpamPoolCidrFailureCode
const (
	IpamPoolCidrFailureCodeCidrNotAvailable IpamPoolCidrFailureCode = "cidr-not-available"
	IpamPoolCidrFailureCodeLimitExceeded    IpamPoolCidrFailureCode = "limit-exceeded"
)

// Values returns all known values for IpamPoolCidrFailureCode. 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 (IpamPoolCidrFailureCode) Values() []IpamPoolCidrFailureCode {
	return []IpamPoolCidrFailureCode{
		"cidr-not-available",
		"limit-exceeded",
	}
}

type IpamPoolCidrState string

// Enum values for IpamPoolCidrState
const (
	IpamPoolCidrStatePendingProvision   IpamPoolCidrState = "pending-provision"
	IpamPoolCidrStateProvisioned        IpamPoolCidrState = "provisioned"
	IpamPoolCidrStateFailedProvision    IpamPoolCidrState = "failed-provision"
	IpamPoolCidrStatePendingDeprovision IpamPoolCidrState = "pending-deprovision"
	IpamPoolCidrStateDeprovisioned      IpamPoolCidrState = "deprovisioned"
	IpamPoolCidrStateFailedDeprovision  IpamPoolCidrState = "failed-deprovision"
	IpamPoolCidrStatePendingImport      IpamPoolCidrState = "pending-import"
	IpamPoolCidrStateFailedImport       IpamPoolCidrState = "failed-import"
)

// Values returns all known values for IpamPoolCidrState. 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 (IpamPoolCidrState) Values() []IpamPoolCidrState {
	return []IpamPoolCidrState{
		"pending-provision",
		"provisioned",
		"failed-provision",
		"pending-deprovision",
		"deprovisioned",
		"failed-deprovision",
		"pending-import",
		"failed-import",
	}
}

type IpamPoolPublicIpSource string

// Enum values for IpamPoolPublicIpSource
const (
	IpamPoolPublicIpSourceAmazon IpamPoolPublicIpSource = "amazon"
	IpamPoolPublicIpSourceByoip  IpamPoolPublicIpSource = "byoip"
)

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

type IpamPoolSourceResourceType string

// Enum values for IpamPoolSourceResourceType
const (
	IpamPoolSourceResourceTypeVpc IpamPoolSourceResourceType = "vpc"
)

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

type IpamPoolState string

// Enum values for IpamPoolState
const (
	IpamPoolStateCreateInProgress  IpamPoolState = "create-in-progress"
	IpamPoolStateCreateComplete    IpamPoolState = "create-complete"
	IpamPoolStateCreateFailed      IpamPoolState = "create-failed"
	IpamPoolStateModifyInProgress  IpamPoolState = "modify-in-progress"
	IpamPoolStateModifyComplete    IpamPoolState = "modify-complete"
	IpamPoolStateModifyFailed      IpamPoolState = "modify-failed"
	IpamPoolStateDeleteInProgress  IpamPoolState = "delete-in-progress"
	IpamPoolStateDeleteComplete    IpamPoolState = "delete-complete"
	IpamPoolStateDeleteFailed      IpamPoolState = "delete-failed"
	IpamPoolStateIsolateInProgress IpamPoolState = "isolate-in-progress"
	IpamPoolStateIsolateComplete   IpamPoolState = "isolate-complete"
	IpamPoolStateRestoreInProgress IpamPoolState = "restore-in-progress"
)

// Values returns all known values for IpamPoolState. 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 (IpamPoolState) Values() []IpamPoolState {
	return []IpamPoolState{
		"create-in-progress",
		"create-complete",
		"create-failed",
		"modify-in-progress",
		"modify-complete",
		"modify-failed",
		"delete-in-progress",
		"delete-complete",
		"delete-failed",
		"isolate-in-progress",
		"isolate-complete",
		"restore-in-progress",
	}
}

type IpamPublicAddressAssociationStatus string

// Enum values for IpamPublicAddressAssociationStatus
const (
	IpamPublicAddressAssociationStatusAssociated    IpamPublicAddressAssociationStatus = "associated"
	IpamPublicAddressAssociationStatusDisassociated IpamPublicAddressAssociationStatus = "disassociated"
)

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

type IpamPublicAddressAwsService string

// Enum values for IpamPublicAddressAwsService
const (
	IpamPublicAddressAwsServiceNatGateway IpamPublicAddressAwsService = "nat-gateway"
	IpamPublicAddressAwsServiceDms        IpamPublicAddressAwsService = "database-migration-service"
	IpamPublicAddressAwsServiceRedshift   IpamPublicAddressAwsService = "redshift"
	IpamPublicAddressAwsServiceEcs        IpamPublicAddressAwsService = "elastic-container-service"
	IpamPublicAddressAwsServiceRds        IpamPublicAddressAwsService = "relational-database-service"
	IpamPublicAddressAwsServiceS2sVpn     IpamPublicAddressAwsService = "site-to-site-vpn"
	IpamPublicAddressAwsServiceEc2Lb      IpamPublicAddressAwsService = "load-balancer"
	IpamPublicAddressAwsServiceAga        IpamPublicAddressAwsService = "global-accelerator"
	IpamPublicAddressAwsServiceOther      IpamPublicAddressAwsService = "other"
)

// Values returns all known values for IpamPublicAddressAwsService. 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 (IpamPublicAddressAwsService) Values() []IpamPublicAddressAwsService {
	return []IpamPublicAddressAwsService{
		"nat-gateway",
		"database-migration-service",
		"redshift",
		"elastic-container-service",
		"relational-database-service",
		"site-to-site-vpn",
		"load-balancer",
		"global-accelerator",
		"other",
	}
}

type IpamPublicAddressType string

// Enum values for IpamPublicAddressType
const (
	IpamPublicAddressTypeServiceManagedIp    IpamPublicAddressType = "service-managed-ip"
	IpamPublicAddressTypeServiceManagedByoip IpamPublicAddressType = "service-managed-byoip"
	IpamPublicAddressTypeAmazonOwnedEip      IpamPublicAddressType = "amazon-owned-eip"
	IpamPublicAddressTypeAmazonOwnedContig   IpamPublicAddressType = "amazon-owned-contig"
	IpamPublicAddressTypeByoip               IpamPublicAddressType = "byoip"
	IpamPublicAddressTypeEc2PublicIp         IpamPublicAddressType = "ec2-public-ip"
)

// Values returns all known values for IpamPublicAddressType. 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 (IpamPublicAddressType) Values() []IpamPublicAddressType {
	return []IpamPublicAddressType{
		"service-managed-ip",
		"service-managed-byoip",
		"amazon-owned-eip",
		"amazon-owned-contig",
		"byoip",
		"ec2-public-ip",
	}
}

type IpamResourceCidrIpSource string

// Enum values for IpamResourceCidrIpSource
const (
	IpamResourceCidrIpSourceAmazon IpamResourceCidrIpSource = "amazon"
	IpamResourceCidrIpSourceByoip  IpamResourceCidrIpSource = "byoip"
	IpamResourceCidrIpSourceNone   IpamResourceCidrIpSource = "none"
)

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

type IpamResourceDiscoveryAssociationState string

// Enum values for IpamResourceDiscoveryAssociationState
const (
	IpamResourceDiscoveryAssociationStateAssociateInProgress    IpamResourceDiscoveryAssociationState = "associate-in-progress"
	IpamResourceDiscoveryAssociationStateAssociateComplete      IpamResourceDiscoveryAssociationState = "associate-complete"
	IpamResourceDiscoveryAssociationStateAssociateFailed        IpamResourceDiscoveryAssociationState = "associate-failed"
	IpamResourceDiscoveryAssociationStateDisassociateInProgress IpamResourceDiscoveryAssociationState = "disassociate-in-progress"
	IpamResourceDiscoveryAssociationStateDisassociateComplete   IpamResourceDiscoveryAssociationState = "disassociate-complete"
	IpamResourceDiscoveryAssociationStateDisassociateFailed     IpamResourceDiscoveryAssociationState = "disassociate-failed"
	IpamResourceDiscoveryAssociationStateIsolateInProgress      IpamResourceDiscoveryAssociationState = "isolate-in-progress"
	IpamResourceDiscoveryAssociationStateIsolateComplete        IpamResourceDiscoveryAssociationState = "isolate-complete"
	IpamResourceDiscoveryAssociationStateRestoreInProgress      IpamResourceDiscoveryAssociationState = "restore-in-progress"
)

// Values returns all known values for IpamResourceDiscoveryAssociationState. 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 (IpamResourceDiscoveryAssociationState) Values() []IpamResourceDiscoveryAssociationState {
	return []IpamResourceDiscoveryAssociationState{
		"associate-in-progress",
		"associate-complete",
		"associate-failed",
		"disassociate-in-progress",
		"disassociate-complete",
		"disassociate-failed",
		"isolate-in-progress",
		"isolate-complete",
		"restore-in-progress",
	}
}

type IpamResourceDiscoveryState string

// Enum values for IpamResourceDiscoveryState
const (
	IpamResourceDiscoveryStateCreateInProgress  IpamResourceDiscoveryState = "create-in-progress"
	IpamResourceDiscoveryStateCreateComplete    IpamResourceDiscoveryState = "create-complete"
	IpamResourceDiscoveryStateCreateFailed      IpamResourceDiscoveryState = "create-failed"
	IpamResourceDiscoveryStateModifyInProgress  IpamResourceDiscoveryState = "modify-in-progress"
	IpamResourceDiscoveryStateModifyComplete    IpamResourceDiscoveryState = "modify-complete"
	IpamResourceDiscoveryStateModifyFailed      IpamResourceDiscoveryState = "modify-failed"
	IpamResourceDiscoveryStateDeleteInProgress  IpamResourceDiscoveryState = "delete-in-progress"
	IpamResourceDiscoveryStateDeleteComplete    IpamResourceDiscoveryState = "delete-complete"
	IpamResourceDiscoveryStateDeleteFailed      IpamResourceDiscoveryState = "delete-failed"
	IpamResourceDiscoveryStateIsolateInProgress IpamResourceDiscoveryState = "isolate-in-progress"
	IpamResourceDiscoveryStateIsolateComplete   IpamResourceDiscoveryState = "isolate-complete"
	IpamResourceDiscoveryStateRestoreInProgress IpamResourceDiscoveryState = "restore-in-progress"
)

// Values returns all known values for IpamResourceDiscoveryState. 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 (IpamResourceDiscoveryState) Values() []IpamResourceDiscoveryState {
	return []IpamResourceDiscoveryState{
		"create-in-progress",
		"create-complete",
		"create-failed",
		"modify-in-progress",
		"modify-complete",
		"modify-failed",
		"delete-in-progress",
		"delete-complete",
		"delete-failed",
		"isolate-in-progress",
		"isolate-complete",
		"restore-in-progress",
	}
}

type IpamResourceType string

// Enum values for IpamResourceType
const (
	IpamResourceTypeVpc            IpamResourceType = "vpc"
	IpamResourceTypeSubnet         IpamResourceType = "subnet"
	IpamResourceTypeEip            IpamResourceType = "eip"
	IpamResourceTypePublicIpv4Pool IpamResourceType = "public-ipv4-pool"
	IpamResourceTypeIpv6Pool       IpamResourceType = "ipv6-pool"
	IpamResourceTypeEni            IpamResourceType = "eni"
)

// Values returns all known values for IpamResourceType. 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 (IpamResourceType) Values() []IpamResourceType {
	return []IpamResourceType{
		"vpc",
		"subnet",
		"eip",
		"public-ipv4-pool",
		"ipv6-pool",
		"eni",
	}
}

type IpamScopeState string

// Enum values for IpamScopeState
const (
	IpamScopeStateCreateInProgress  IpamScopeState = "create-in-progress"
	IpamScopeStateCreateComplete    IpamScopeState = "create-complete"
	IpamScopeStateCreateFailed      IpamScopeState = "create-failed"
	IpamScopeStateModifyInProgress  IpamScopeState = "modify-in-progress"
	IpamScopeStateModifyComplete    IpamScopeState = "modify-complete"
	IpamScopeStateModifyFailed      IpamScopeState = "modify-failed"
	IpamScopeStateDeleteInProgress  IpamScopeState = "delete-in-progress"
	IpamScopeStateDeleteComplete    IpamScopeState = "delete-complete"
	IpamScopeStateDeleteFailed      IpamScopeState = "delete-failed"
	IpamScopeStateIsolateInProgress IpamScopeState = "isolate-in-progress"
	IpamScopeStateIsolateComplete   IpamScopeState = "isolate-complete"
	IpamScopeStateRestoreInProgress IpamScopeState = "restore-in-progress"
)

// Values returns all known values for IpamScopeState. 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 (IpamScopeState) Values() []IpamScopeState {
	return []IpamScopeState{
		"create-in-progress",
		"create-complete",
		"create-failed",
		"modify-in-progress",
		"modify-complete",
		"modify-failed",
		"delete-in-progress",
		"delete-complete",
		"delete-failed",
		"isolate-in-progress",
		"isolate-complete",
		"restore-in-progress",
	}
}

type IpamScopeType string

// Enum values for IpamScopeType
const (
	IpamScopeTypePublic  IpamScopeType = "public"
	IpamScopeTypePrivate IpamScopeType = "private"
)

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

type IpamState string

// Enum values for IpamState
const (
	IpamStateCreateInProgress  IpamState = "create-in-progress"
	IpamStateCreateComplete    IpamState = "create-complete"
	IpamStateCreateFailed      IpamState = "create-failed"
	IpamStateModifyInProgress  IpamState = "modify-in-progress"
	IpamStateModifyComplete    IpamState = "modify-complete"
	IpamStateModifyFailed      IpamState = "modify-failed"
	IpamStateDeleteInProgress  IpamState = "delete-in-progress"
	IpamStateDeleteComplete    IpamState = "delete-complete"
	IpamStateDeleteFailed      IpamState = "delete-failed"
	IpamStateIsolateInProgress IpamState = "isolate-in-progress"
	IpamStateIsolateComplete   IpamState = "isolate-complete"
	IpamStateRestoreInProgress IpamState = "restore-in-progress"
)

// Values returns all known values for IpamState. 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 (IpamState) Values() []IpamState {
	return []IpamState{
		"create-in-progress",
		"create-complete",
		"create-failed",
		"modify-in-progress",
		"modify-complete",
		"modify-failed",
		"delete-in-progress",
		"delete-complete",
		"delete-failed",
		"isolate-in-progress",
		"isolate-complete",
		"restore-in-progress",
	}
}

type IpamTier string

// Enum values for IpamTier
const (
	IpamTierFree     IpamTier = "free"
	IpamTierAdvanced IpamTier = "advanced"
)

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

type IpSource string

// Enum values for IpSource
const (
	IpSourceAmazon IpSource = "amazon"
	IpSourceByoip  IpSource = "byoip"
	IpSourceNone   IpSource = "none"
)

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

type Ipv6AddressAttribute string

// Enum values for Ipv6AddressAttribute
const (
	Ipv6AddressAttributePublic  Ipv6AddressAttribute = "public"
	Ipv6AddressAttributePrivate Ipv6AddressAttribute = "private"
)

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

type Ipv6SupportValue string

// Enum values for Ipv6SupportValue
const (
	Ipv6SupportValueEnable  Ipv6SupportValue = "enable"
	Ipv6SupportValueDisable Ipv6SupportValue = "disable"
)

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

type KeyFormat string

// Enum values for KeyFormat
const (
	KeyFormatPem KeyFormat = "pem"
	KeyFormatPpk KeyFormat = "ppk"
)

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

type KeyType string

// Enum values for KeyType
const (
	KeyTypeRsa     KeyType = "rsa"
	KeyTypeEd25519 KeyType = "ed25519"
)

// 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{
		"rsa",
		"ed25519",
	}
}

type LaunchTemplateAutoRecoveryState string

// Enum values for LaunchTemplateAutoRecoveryState
const (
	LaunchTemplateAutoRecoveryStateDefault  LaunchTemplateAutoRecoveryState = "default"
	LaunchTemplateAutoRecoveryStateDisabled LaunchTemplateAutoRecoveryState = "disabled"
)

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

type LaunchTemplateErrorCode string

// Enum values for LaunchTemplateErrorCode
const (
	LaunchTemplateErrorCodeLaunchTemplateIdDoesNotExist      LaunchTemplateErrorCode = "launchTemplateIdDoesNotExist"
	LaunchTemplateErrorCodeLaunchTemplateIdMalformed         LaunchTemplateErrorCode = "launchTemplateIdMalformed"
	LaunchTemplateErrorCodeLaunchTemplateNameDoesNotExist    LaunchTemplateErrorCode = "launchTemplateNameDoesNotExist"
	LaunchTemplateErrorCodeLaunchTemplateNameMalformed       LaunchTemplateErrorCode = "launchTemplateNameMalformed"
	LaunchTemplateErrorCodeLaunchTemplateVersionDoesNotExist LaunchTemplateErrorCode = "launchTemplateVersionDoesNotExist"
	LaunchTemplateErrorCodeUnexpectedError                   LaunchTemplateErrorCode = "unexpectedError"
)

// Values returns all known values for LaunchTemplateErrorCode. 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 (LaunchTemplateErrorCode) Values() []LaunchTemplateErrorCode {
	return []LaunchTemplateErrorCode{
		"launchTemplateIdDoesNotExist",
		"launchTemplateIdMalformed",
		"launchTemplateNameDoesNotExist",
		"launchTemplateNameMalformed",
		"launchTemplateVersionDoesNotExist",
		"unexpectedError",
	}
}

type LaunchTemplateHttpTokensState string

// Enum values for LaunchTemplateHttpTokensState
const (
	LaunchTemplateHttpTokensStateOptional LaunchTemplateHttpTokensState = "optional"
	LaunchTemplateHttpTokensStateRequired LaunchTemplateHttpTokensState = "required"
)

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

type LaunchTemplateInstanceMetadataEndpointState string

// Enum values for LaunchTemplateInstanceMetadataEndpointState
const (
	LaunchTemplateInstanceMetadataEndpointStateDisabled LaunchTemplateInstanceMetadataEndpointState = "disabled"
	LaunchTemplateInstanceMetadataEndpointStateEnabled  LaunchTemplateInstanceMetadataEndpointState = "enabled"
)

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

type LaunchTemplateInstanceMetadataOptionsState string

// Enum values for LaunchTemplateInstanceMetadataOptionsState
const (
	LaunchTemplateInstanceMetadataOptionsStatePending LaunchTemplateInstanceMetadataOptionsState = "pending"
	LaunchTemplateInstanceMetadataOptionsStateApplied LaunchTemplateInstanceMetadataOptionsState = "applied"
)

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

type LaunchTemplateInstanceMetadataProtocolIpv6 string

// Enum values for LaunchTemplateInstanceMetadataProtocolIpv6
const (
	LaunchTemplateInstanceMetadataProtocolIpv6Disabled LaunchTemplateInstanceMetadataProtocolIpv6 = "disabled"
	LaunchTemplateInstanceMetadataProtocolIpv6Enabled  LaunchTemplateInstanceMetadataProtocolIpv6 = "enabled"
)

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

type LaunchTemplateInstanceMetadataTagsState string

// Enum values for LaunchTemplateInstanceMetadataTagsState
const (
	LaunchTemplateInstanceMetadataTagsStateDisabled LaunchTemplateInstanceMetadataTagsState = "disabled"
	LaunchTemplateInstanceMetadataTagsStateEnabled  LaunchTemplateInstanceMetadataTagsState = "enabled"
)

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

type ListingState string

// Enum values for ListingState
const (
	ListingStateAvailable ListingState = "available"
	ListingStateSold      ListingState = "sold"
	ListingStateCancelled ListingState = "cancelled"
	ListingStatePending   ListingState = "pending"
)

// Values returns all known values for ListingState. 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 (ListingState) Values() []ListingState {
	return []ListingState{
		"available",
		"sold",
		"cancelled",
		"pending",
	}
}

type ListingStatus string

// Enum values for ListingStatus
const (
	ListingStatusActive    ListingStatus = "active"
	ListingStatusPending   ListingStatus = "pending"
	ListingStatusCancelled ListingStatus = "cancelled"
	ListingStatusClosed    ListingStatus = "closed"
)

// Values returns all known values for ListingStatus. 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 (ListingStatus) Values() []ListingStatus {
	return []ListingStatus{
		"active",
		"pending",
		"cancelled",
		"closed",
	}
}

type LocalGatewayRouteState string

// Enum values for LocalGatewayRouteState
const (
	LocalGatewayRouteStatePending   LocalGatewayRouteState = "pending"
	LocalGatewayRouteStateActive    LocalGatewayRouteState = "active"
	LocalGatewayRouteStateBlackhole LocalGatewayRouteState = "blackhole"
	LocalGatewayRouteStateDeleting  LocalGatewayRouteState = "deleting"
	LocalGatewayRouteStateDeleted   LocalGatewayRouteState = "deleted"
)

// Values returns all known values for LocalGatewayRouteState. 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 (LocalGatewayRouteState) Values() []LocalGatewayRouteState {
	return []LocalGatewayRouteState{
		"pending",
		"active",
		"blackhole",
		"deleting",
		"deleted",
	}
}

type LocalGatewayRouteTableMode string

// Enum values for LocalGatewayRouteTableMode
const (
	LocalGatewayRouteTableModeDirectVpcRouting LocalGatewayRouteTableMode = "direct-vpc-routing"
	LocalGatewayRouteTableModeCoip             LocalGatewayRouteTableMode = "coip"
)

// Values returns all known values for LocalGatewayRouteTableMode. 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 (LocalGatewayRouteTableMode) Values() []LocalGatewayRouteTableMode {
	return []LocalGatewayRouteTableMode{
		"direct-vpc-routing",
		"coip",
	}
}

type LocalGatewayRouteType string

// Enum values for LocalGatewayRouteType
const (
	LocalGatewayRouteTypeStatic     LocalGatewayRouteType = "static"
	LocalGatewayRouteTypePropagated LocalGatewayRouteType = "propagated"
)

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

type LocalStorage string

// Enum values for LocalStorage
const (
	LocalStorageIncluded LocalStorage = "included"
	LocalStorageRequired LocalStorage = "required"
	LocalStorageExcluded LocalStorage = "excluded"
)

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

type LocalStorageType string

// Enum values for LocalStorageType
const (
	LocalStorageTypeHdd LocalStorageType = "hdd"
	LocalStorageTypeSsd LocalStorageType = "ssd"
)

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

type LocationType string

// Enum values for LocationType
const (
	LocationTypeRegion             LocationType = "region"
	LocationTypeAvailabilityZone   LocationType = "availability-zone"
	LocationTypeAvailabilityZoneId LocationType = "availability-zone-id"
	LocationTypeOutpost            LocationType = "outpost"
)

// Values returns all known values for LocationType. 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 (LocationType) Values() []LocationType {
	return []LocationType{
		"region",
		"availability-zone",
		"availability-zone-id",
		"outpost",
	}
}

type LockMode string

// Enum values for LockMode
const (
	LockModeCompliance LockMode = "compliance"
	LockModeGovernance LockMode = "governance"
)

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

type LockState string

// Enum values for LockState
const (
	LockStateCompliance        LockState = "compliance"
	LockStateGovernance        LockState = "governance"
	LockStateComplianceCooloff LockState = "compliance-cooloff"
	LockStateExpired           LockState = "expired"
)

// Values returns all known values for LockState. 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 (LockState) Values() []LockState {
	return []LockState{
		"compliance",
		"governance",
		"compliance-cooloff",
		"expired",
	}
}

type LogDestinationType string

// Enum values for LogDestinationType
const (
	LogDestinationTypeCloudWatchLogs      LogDestinationType = "cloud-watch-logs"
	LogDestinationTypeS3                  LogDestinationType = "s3"
	LogDestinationTypeKinesisDataFirehose LogDestinationType = "kinesis-data-firehose"
)

// Values returns all known values for LogDestinationType. 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 (LogDestinationType) Values() []LogDestinationType {
	return []LogDestinationType{
		"cloud-watch-logs",
		"s3",
		"kinesis-data-firehose",
	}
}

type MarketType string

// Enum values for MarketType
const (
	MarketTypeSpot          MarketType = "spot"
	MarketTypeCapacityBlock MarketType = "capacity-block"
)

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

type MembershipType string

// Enum values for MembershipType
const (
	MembershipTypeStatic MembershipType = "static"
	MembershipTypeIgmp   MembershipType = "igmp"
)

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

type MetadataDefaultHttpTokensState string

// Enum values for MetadataDefaultHttpTokensState
const (
	MetadataDefaultHttpTokensStateOptional     MetadataDefaultHttpTokensState = "optional"
	MetadataDefaultHttpTokensStateRequired     MetadataDefaultHttpTokensState = "required"
	MetadataDefaultHttpTokensStateNoPreference MetadataDefaultHttpTokensState = "no-preference"
)

// Values returns all known values for MetadataDefaultHttpTokensState. 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 (MetadataDefaultHttpTokensState) Values() []MetadataDefaultHttpTokensState {
	return []MetadataDefaultHttpTokensState{
		"optional",
		"required",
		"no-preference",
	}
}

type MetricType string

// Enum values for MetricType
const (
	MetricTypeAggregateLatency MetricType = "aggregate-latency"
)

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

type ModifyAvailabilityZoneOptInStatus string

// Enum values for ModifyAvailabilityZoneOptInStatus
const (
	ModifyAvailabilityZoneOptInStatusOptedIn    ModifyAvailabilityZoneOptInStatus = "opted-in"
	ModifyAvailabilityZoneOptInStatusNotOptedIn ModifyAvailabilityZoneOptInStatus = "not-opted-in"
)

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

type MonitoringState string

// Enum values for MonitoringState
const (
	MonitoringStateDisabled  MonitoringState = "disabled"
	MonitoringStateDisabling MonitoringState = "disabling"
	MonitoringStateEnabled   MonitoringState = "enabled"
	MonitoringStatePending   MonitoringState = "pending"
)

// Values returns all known values for MonitoringState. 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 (MonitoringState) Values() []MonitoringState {
	return []MonitoringState{
		"disabled",
		"disabling",
		"enabled",
		"pending",
	}
}

type MoveStatus string

// Enum values for MoveStatus
const (
	MoveStatusMovingToVpc        MoveStatus = "movingToVpc"
	MoveStatusRestoringToClassic MoveStatus = "restoringToClassic"
)

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

type MulticastSupportValue string

// Enum values for MulticastSupportValue
const (
	MulticastSupportValueEnable  MulticastSupportValue = "enable"
	MulticastSupportValueDisable MulticastSupportValue = "disable"
)

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

type NatGatewayAddressStatus string

// Enum values for NatGatewayAddressStatus
const (
	NatGatewayAddressStatusAssigning      NatGatewayAddressStatus = "assigning"
	NatGatewayAddressStatusUnassigning    NatGatewayAddressStatus = "unassigning"
	NatGatewayAddressStatusAssociating    NatGatewayAddressStatus = "associating"
	NatGatewayAddressStatusDisassociating NatGatewayAddressStatus = "disassociating"
	NatGatewayAddressStatusSucceeded      NatGatewayAddressStatus = "succeeded"
	NatGatewayAddressStatusFailed         NatGatewayAddressStatus = "failed"
)

// Values returns all known values for NatGatewayAddressStatus. 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 (NatGatewayAddressStatus) Values() []NatGatewayAddressStatus {
	return []NatGatewayAddressStatus{
		"assigning",
		"unassigning",
		"associating",
		"disassociating",
		"succeeded",
		"failed",
	}
}

type NatGatewayState string

// Enum values for NatGatewayState
const (
	NatGatewayStatePending   NatGatewayState = "pending"
	NatGatewayStateFailed    NatGatewayState = "failed"
	NatGatewayStateAvailable NatGatewayState = "available"
	NatGatewayStateDeleting  NatGatewayState = "deleting"
	NatGatewayStateDeleted   NatGatewayState = "deleted"
)

// Values returns all known values for NatGatewayState. 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 (NatGatewayState) Values() []NatGatewayState {
	return []NatGatewayState{
		"pending",
		"failed",
		"available",
		"deleting",
		"deleted",
	}
}

type NetworkInterfaceAttribute string

// Enum values for NetworkInterfaceAttribute
const (
	NetworkInterfaceAttributeDescription              NetworkInterfaceAttribute = "description"
	NetworkInterfaceAttributeGroupSet                 NetworkInterfaceAttribute = "groupSet"
	NetworkInterfaceAttributeSourceDestCheck          NetworkInterfaceAttribute = "sourceDestCheck"
	NetworkInterfaceAttributeAttachment               NetworkInterfaceAttribute = "attachment"
	NetworkInterfaceAttributeAssociatePublicIpAddress NetworkInterfaceAttribute = "associatePublicIpAddress"
)

// Values returns all known values for NetworkInterfaceAttribute. 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 (NetworkInterfaceAttribute) Values() []NetworkInterfaceAttribute {
	return []NetworkInterfaceAttribute{
		"description",
		"groupSet",
		"sourceDestCheck",
		"attachment",
		"associatePublicIpAddress",
	}
}

type NetworkInterfaceCreationType string

// Enum values for NetworkInterfaceCreationType
const (
	NetworkInterfaceCreationTypeEfa     NetworkInterfaceCreationType = "efa"
	NetworkInterfaceCreationTypeEfaOnly NetworkInterfaceCreationType = "efa-only"
	NetworkInterfaceCreationTypeBranch  NetworkInterfaceCreationType = "branch"
	NetworkInterfaceCreationTypeTrunk   NetworkInterfaceCreationType = "trunk"
)

// Values returns all known values for NetworkInterfaceCreationType. 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 (NetworkInterfaceCreationType) Values() []NetworkInterfaceCreationType {
	return []NetworkInterfaceCreationType{
		"efa",
		"efa-only",
		"branch",
		"trunk",
	}
}

type NetworkInterfacePermissionStateCode string

// Enum values for NetworkInterfacePermissionStateCode
const (
	NetworkInterfacePermissionStateCodePending  NetworkInterfacePermissionStateCode = "pending"
	NetworkInterfacePermissionStateCodeGranted  NetworkInterfacePermissionStateCode = "granted"
	NetworkInterfacePermissionStateCodeRevoking NetworkInterfacePermissionStateCode = "revoking"
	NetworkInterfacePermissionStateCodeRevoked  NetworkInterfacePermissionStateCode = "revoked"
)

// Values returns all known values for NetworkInterfacePermissionStateCode. 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 (NetworkInterfacePermissionStateCode) Values() []NetworkInterfacePermissionStateCode {
	return []NetworkInterfacePermissionStateCode{
		"pending",
		"granted",
		"revoking",
		"revoked",
	}
}

type NetworkInterfaceStatus string

// Enum values for NetworkInterfaceStatus
const (
	NetworkInterfaceStatusAvailable  NetworkInterfaceStatus = "available"
	NetworkInterfaceStatusAssociated NetworkInterfaceStatus = "associated"
	NetworkInterfaceStatusAttaching  NetworkInterfaceStatus = "attaching"
	NetworkInterfaceStatusInUse      NetworkInterfaceStatus = "in-use"
	NetworkInterfaceStatusDetaching  NetworkInterfaceStatus = "detaching"
)

// Values returns all known values for NetworkInterfaceStatus. 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 (NetworkInterfaceStatus) Values() []NetworkInterfaceStatus {
	return []NetworkInterfaceStatus{
		"available",
		"associated",
		"attaching",
		"in-use",
		"detaching",
	}
}

type NetworkInterfaceType string

// Enum values for NetworkInterfaceType
const (
	NetworkInterfaceTypeInterface                     NetworkInterfaceType = "interface"
	NetworkInterfaceTypeNatGateway                    NetworkInterfaceType = "natGateway"
	NetworkInterfaceTypeEfa                           NetworkInterfaceType = "efa"
	NetworkInterfaceTypeEfaOnly                       NetworkInterfaceType = "efa-only"
	NetworkInterfaceTypeTrunk                         NetworkInterfaceType = "trunk"
	NetworkInterfaceTypeLoadBalancer                  NetworkInterfaceType = "load_balancer"
	NetworkInterfaceTypeNetworkLoadBalancer           NetworkInterfaceType = "network_load_balancer"
	NetworkInterfaceTypeVpcEndpoint                   NetworkInterfaceType = "vpc_endpoint"
	NetworkInterfaceTypeBranch                        NetworkInterfaceType = "branch"
	NetworkInterfaceTypeTransitGateway                NetworkInterfaceType = "transit_gateway"
	NetworkInterfaceTypeLambda                        NetworkInterfaceType = "lambda"
	NetworkInterfaceTypeQuicksight                    NetworkInterfaceType = "quicksight"
	NetworkInterfaceTypeGlobalAcceleratorManaged      NetworkInterfaceType = "global_accelerator_managed"
	NetworkInterfaceTypeApiGatewayManaged             NetworkInterfaceType = "api_gateway_managed"
	NetworkInterfaceTypeGatewayLoadBalancer           NetworkInterfaceType = "gateway_load_balancer"
	NetworkInterfaceTypeGatewayLoadBalancerEndpoint   NetworkInterfaceType = "gateway_load_balancer_endpoint"
	NetworkInterfaceTypeIotRulesManaged               NetworkInterfaceType = "iot_rules_managed"
	NetworkInterfaceTypeAwsCodestarConnectionsManaged NetworkInterfaceType = "aws_codestar_connections_managed"
)

// Values returns all known values for NetworkInterfaceType. 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 (NetworkInterfaceType) Values() []NetworkInterfaceType {
	return []NetworkInterfaceType{
		"interface",
		"natGateway",
		"efa",
		"efa-only",
		"trunk",
		"load_balancer",
		"network_load_balancer",
		"vpc_endpoint",
		"branch",
		"transit_gateway",
		"lambda",
		"quicksight",
		"global_accelerator_managed",
		"api_gateway_managed",
		"gateway_load_balancer",
		"gateway_load_balancer_endpoint",
		"iot_rules_managed",
		"aws_codestar_connections_managed",
	}
}

type NitroEnclavesSupport string

// Enum values for NitroEnclavesSupport
const (
	NitroEnclavesSupportUnsupported NitroEnclavesSupport = "unsupported"
	NitroEnclavesSupportSupported   NitroEnclavesSupport = "supported"
)

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

type NitroTpmSupport string

// Enum values for NitroTpmSupport
const (
	NitroTpmSupportUnsupported NitroTpmSupport = "unsupported"
	NitroTpmSupportSupported   NitroTpmSupport = "supported"
)

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

type OfferingClassType string

// Enum values for OfferingClassType
const (
	OfferingClassTypeStandard    OfferingClassType = "standard"
	OfferingClassTypeConvertible OfferingClassType = "convertible"
)

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

type OfferingTypeValues string

// Enum values for OfferingTypeValues
const (
	OfferingTypeValuesHeavyUtilization  OfferingTypeValues = "Heavy Utilization"
	OfferingTypeValuesMediumUtilization OfferingTypeValues = "Medium Utilization"
	OfferingTypeValuesLightUtilization  OfferingTypeValues = "Light Utilization"
	OfferingTypeValuesNoUpfront         OfferingTypeValues = "No Upfront"
	OfferingTypeValuesPartialUpfront    OfferingTypeValues = "Partial Upfront"
	OfferingTypeValuesAllUpfront        OfferingTypeValues = "All Upfront"
)

// Values returns all known values for OfferingTypeValues. 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 (OfferingTypeValues) Values() []OfferingTypeValues {
	return []OfferingTypeValues{
		"Heavy Utilization",
		"Medium Utilization",
		"Light Utilization",
		"No Upfront",
		"Partial Upfront",
		"All Upfront",
	}
}

type OnDemandAllocationStrategy string

// Enum values for OnDemandAllocationStrategy
const (
	OnDemandAllocationStrategyLowestPrice OnDemandAllocationStrategy = "lowestPrice"
	OnDemandAllocationStrategyPrioritized OnDemandAllocationStrategy = "prioritized"
)

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

type OperationType string

// Enum values for OperationType
const (
	OperationTypeAdd    OperationType = "add"
	OperationTypeRemove OperationType = "remove"
)

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

type PartitionLoadFrequency string

// Enum values for PartitionLoadFrequency
const (
	PartitionLoadFrequencyNone    PartitionLoadFrequency = "none"
	PartitionLoadFrequencyDaily   PartitionLoadFrequency = "daily"
	PartitionLoadFrequencyWeekly  PartitionLoadFrequency = "weekly"
	PartitionLoadFrequencyMonthly PartitionLoadFrequency = "monthly"
)

// Values returns all known values for PartitionLoadFrequency. 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 (PartitionLoadFrequency) Values() []PartitionLoadFrequency {
	return []PartitionLoadFrequency{
		"none",
		"daily",
		"weekly",
		"monthly",
	}
}

type PayerResponsibility string

// Enum values for PayerResponsibility
const (
	PayerResponsibilityServiceOwner PayerResponsibility = "ServiceOwner"
)

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

type PaymentOption string

// Enum values for PaymentOption
const (
	PaymentOptionAllUpfront     PaymentOption = "AllUpfront"
	PaymentOptionPartialUpfront PaymentOption = "PartialUpfront"
	PaymentOptionNoUpfront      PaymentOption = "NoUpfront"
)

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

type PeriodType string

// Enum values for PeriodType
const (
	PeriodTypeFiveMinutes    PeriodType = "five-minutes"
	PeriodTypeFifteenMinutes PeriodType = "fifteen-minutes"
	PeriodTypeOneHour        PeriodType = "one-hour"
	PeriodTypeThreeHours     PeriodType = "three-hours"
	PeriodTypeOneDay         PeriodType = "one-day"
	PeriodTypeOneWeek        PeriodType = "one-week"
)

// Values returns all known values for PeriodType. 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 (PeriodType) Values() []PeriodType {
	return []PeriodType{
		"five-minutes",
		"fifteen-minutes",
		"one-hour",
		"three-hours",
		"one-day",
		"one-week",
	}
}

type PermissionGroup string

// Enum values for PermissionGroup
const (
	PermissionGroupAll PermissionGroup = "all"
)

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

type PhcSupport string

// Enum values for PhcSupport
const (
	PhcSupportUnsupported PhcSupport = "unsupported"
	PhcSupportSupported   PhcSupport = "supported"
)

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

type PlacementGroupState string

// Enum values for PlacementGroupState
const (
	PlacementGroupStatePending   PlacementGroupState = "pending"
	PlacementGroupStateAvailable PlacementGroupState = "available"
	PlacementGroupStateDeleting  PlacementGroupState = "deleting"
	PlacementGroupStateDeleted   PlacementGroupState = "deleted"
)

// Values returns all known values for PlacementGroupState. 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 (PlacementGroupState) Values() []PlacementGroupState {
	return []PlacementGroupState{
		"pending",
		"available",
		"deleting",
		"deleted",
	}
}

type PlacementGroupStrategy string

// Enum values for PlacementGroupStrategy
const (
	PlacementGroupStrategyCluster   PlacementGroupStrategy = "cluster"
	PlacementGroupStrategyPartition PlacementGroupStrategy = "partition"
	PlacementGroupStrategySpread    PlacementGroupStrategy = "spread"
)

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

type PlacementStrategy string

// Enum values for PlacementStrategy
const (
	PlacementStrategyCluster   PlacementStrategy = "cluster"
	PlacementStrategySpread    PlacementStrategy = "spread"
	PlacementStrategyPartition PlacementStrategy = "partition"
)

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

type PlatformValues string

// Enum values for PlatformValues
const (
	PlatformValuesWindows PlatformValues = "Windows"
)

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

type PrefixListState string

// Enum values for PrefixListState
const (
	PrefixListStateCreateInProgress  PrefixListState = "create-in-progress"
	PrefixListStateCreateComplete    PrefixListState = "create-complete"
	PrefixListStateCreateFailed      PrefixListState = "create-failed"
	PrefixListStateModifyInProgress  PrefixListState = "modify-in-progress"
	PrefixListStateModifyComplete    PrefixListState = "modify-complete"
	PrefixListStateModifyFailed      PrefixListState = "modify-failed"
	PrefixListStateRestoreInProgress PrefixListState = "restore-in-progress"
	PrefixListStateRestoreComplete   PrefixListState = "restore-complete"
	PrefixListStateRestoreFailed     PrefixListState = "restore-failed"
	PrefixListStateDeleteInProgress  PrefixListState = "delete-in-progress"
	PrefixListStateDeleteComplete    PrefixListState = "delete-complete"
	PrefixListStateDeleteFailed      PrefixListState = "delete-failed"
)

// Values returns all known values for PrefixListState. 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 (PrefixListState) Values() []PrefixListState {
	return []PrefixListState{
		"create-in-progress",
		"create-complete",
		"create-failed",
		"modify-in-progress",
		"modify-complete",
		"modify-failed",
		"restore-in-progress",
		"restore-complete",
		"restore-failed",
		"delete-in-progress",
		"delete-complete",
		"delete-failed",
	}
}

type PrincipalType string

// Enum values for PrincipalType
const (
	PrincipalTypeAll              PrincipalType = "All"
	PrincipalTypeService          PrincipalType = "Service"
	PrincipalTypeOrganizationUnit PrincipalType = "OrganizationUnit"
	PrincipalTypeAccount          PrincipalType = "Account"
	PrincipalTypeUser             PrincipalType = "User"
	PrincipalTypeRole             PrincipalType = "Role"
)

// Values returns all known values for PrincipalType. 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 (PrincipalType) Values() []PrincipalType {
	return []PrincipalType{
		"All",
		"Service",
		"OrganizationUnit",
		"Account",
		"User",
		"Role",
	}
}

type ProductCodeValues string

// Enum values for ProductCodeValues
const (
	ProductCodeValuesDevpay      ProductCodeValues = "devpay"
	ProductCodeValuesMarketplace ProductCodeValues = "marketplace"
)

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

type Protocol string

// Enum values for Protocol
const (
	ProtocolTcp Protocol = "tcp"
	ProtocolUdp Protocol = "udp"
)

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

type ProtocolValue string

// Enum values for ProtocolValue
const (
	ProtocolValueGre ProtocolValue = "gre"
)

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

type RecurringChargeFrequency string

// Enum values for RecurringChargeFrequency
const (
	RecurringChargeFrequencyHourly RecurringChargeFrequency = "Hourly"
)

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

type ReplacementStrategy string

// Enum values for ReplacementStrategy
const (
	ReplacementStrategyLaunch                ReplacementStrategy = "launch"
	ReplacementStrategyLaunchBeforeTerminate ReplacementStrategy = "launch-before-terminate"
)

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

type ReplaceRootVolumeTaskState string

// Enum values for ReplaceRootVolumeTaskState
const (
	ReplaceRootVolumeTaskStatePending        ReplaceRootVolumeTaskState = "pending"
	ReplaceRootVolumeTaskStateInProgress     ReplaceRootVolumeTaskState = "in-progress"
	ReplaceRootVolumeTaskStateFailing        ReplaceRootVolumeTaskState = "failing"
	ReplaceRootVolumeTaskStateSucceeded      ReplaceRootVolumeTaskState = "succeeded"
	ReplaceRootVolumeTaskStateFailed         ReplaceRootVolumeTaskState = "failed"
	ReplaceRootVolumeTaskStateFailedDetached ReplaceRootVolumeTaskState = "failed-detached"
)

// Values returns all known values for ReplaceRootVolumeTaskState. 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 (ReplaceRootVolumeTaskState) Values() []ReplaceRootVolumeTaskState {
	return []ReplaceRootVolumeTaskState{
		"pending",
		"in-progress",
		"failing",
		"succeeded",
		"failed",
		"failed-detached",
	}
}

type ReportInstanceReasonCodes string

// Enum values for ReportInstanceReasonCodes
const (
	ReportInstanceReasonCodesInstanceStuckInState     ReportInstanceReasonCodes = "instance-stuck-in-state"
	ReportInstanceReasonCodesUnresponsive             ReportInstanceReasonCodes = "unresponsive"
	ReportInstanceReasonCodesNotAcceptingCredentials  ReportInstanceReasonCodes = "not-accepting-credentials"
	ReportInstanceReasonCodesPasswordNotAvailable     ReportInstanceReasonCodes = "password-not-available"
	ReportInstanceReasonCodesPerformanceNetwork       ReportInstanceReasonCodes = "performance-network"
	ReportInstanceReasonCodesPerformanceInstanceStore ReportInstanceReasonCodes = "performance-instance-store"
	ReportInstanceReasonCodesPerformanceEbsVolume     ReportInstanceReasonCodes = "performance-ebs-volume"
	ReportInstanceReasonCodesPerformanceOther         ReportInstanceReasonCodes = "performance-other"
	ReportInstanceReasonCodesOther                    ReportInstanceReasonCodes = "other"
)

// Values returns all known values for ReportInstanceReasonCodes. 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 (ReportInstanceReasonCodes) Values() []ReportInstanceReasonCodes {
	return []ReportInstanceReasonCodes{
		"instance-stuck-in-state",
		"unresponsive",
		"not-accepting-credentials",
		"password-not-available",
		"performance-network",
		"performance-instance-store",
		"performance-ebs-volume",
		"performance-other",
		"other",
	}
}

type ReportStatusType string

// Enum values for ReportStatusType
const (
	ReportStatusTypeOk       ReportStatusType = "ok"
	ReportStatusTypeImpaired ReportStatusType = "impaired"
)

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

type ReservationState string

// Enum values for ReservationState
const (
	ReservationStatePaymentPending ReservationState = "payment-pending"
	ReservationStatePaymentFailed  ReservationState = "payment-failed"
	ReservationStateActive         ReservationState = "active"
	ReservationStateRetired        ReservationState = "retired"
)

// Values returns all known values for ReservationState. 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 (ReservationState) Values() []ReservationState {
	return []ReservationState{
		"payment-pending",
		"payment-failed",
		"active",
		"retired",
	}
}

type ReservedInstanceState string

// Enum values for ReservedInstanceState
const (
	ReservedInstanceStatePaymentPending ReservedInstanceState = "payment-pending"
	ReservedInstanceStateActive         ReservedInstanceState = "active"
	ReservedInstanceStatePaymentFailed  ReservedInstanceState = "payment-failed"
	ReservedInstanceStateRetired        ReservedInstanceState = "retired"
	ReservedInstanceStateQueued         ReservedInstanceState = "queued"
	ReservedInstanceStateQueuedDeleted  ReservedInstanceState = "queued-deleted"
)

// Values returns all known values for ReservedInstanceState. 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 (ReservedInstanceState) Values() []ReservedInstanceState {
	return []ReservedInstanceState{
		"payment-pending",
		"active",
		"payment-failed",
		"retired",
		"queued",
		"queued-deleted",
	}
}

type ResetFpgaImageAttributeName string

// Enum values for ResetFpgaImageAttributeName
const (
	ResetFpgaImageAttributeNameLoadPermission ResetFpgaImageAttributeName = "loadPermission"
)

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

type ResetImageAttributeName string

// Enum values for ResetImageAttributeName
const (
	ResetImageAttributeNameLaunchPermission ResetImageAttributeName = "launchPermission"
)

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

type ResourceType string

// Enum values for ResourceType
const (
	ResourceTypeCapacityReservation                                    ResourceType = "capacity-reservation"
	ResourceTypeClientVpnEndpoint                                      ResourceType = "client-vpn-endpoint"
	ResourceTypeCustomerGateway                                        ResourceType = "customer-gateway"
	ResourceTypeCarrierGateway                                         ResourceType = "carrier-gateway"
	ResourceTypeCoipPool                                               ResourceType = "coip-pool"
	ResourceTypeDedicatedHost                                          ResourceType = "dedicated-host"
	ResourceTypeDhcpOptions                                            ResourceType = "dhcp-options"
	ResourceTypeEgressOnlyInternetGateway                              ResourceType = "egress-only-internet-gateway"
	ResourceTypeElasticIp                                              ResourceType = "elastic-ip"
	ResourceTypeElasticGpu                                             ResourceType = "elastic-gpu"
	ResourceTypeExportImageTask                                        ResourceType = "export-image-task"
	ResourceTypeExportInstanceTask                                     ResourceType = "export-instance-task"
	ResourceTypeFleet                                                  ResourceType = "fleet"
	ResourceTypeFpgaImage                                              ResourceType = "fpga-image"
	ResourceTypeHostReservation                                        ResourceType = "host-reservation"
	ResourceTypeImage                                                  ResourceType = "image"
	ResourceTypeImportImageTask                                        ResourceType = "import-image-task"
	ResourceTypeImportSnapshotTask                                     ResourceType = "import-snapshot-task"
	ResourceTypeInstance                                               ResourceType = "instance"
	ResourceTypeInstanceEventWindow                                    ResourceType = "instance-event-window"
	ResourceTypeInternetGateway                                        ResourceType = "internet-gateway"
	ResourceTypeIpam                                                   ResourceType = "ipam"
	ResourceTypeIpamPool                                               ResourceType = "ipam-pool"
	ResourceTypeIpamScope                                              ResourceType = "ipam-scope"
	ResourceTypeIpv4poolEc2                                            ResourceType = "ipv4pool-ec2"
	ResourceTypeIpv6poolEc2                                            ResourceType = "ipv6pool-ec2"
	ResourceTypeKeyPair                                                ResourceType = "key-pair"
	ResourceTypeLaunchTemplate                                         ResourceType = "launch-template"
	ResourceTypeLocalGateway                                           ResourceType = "local-gateway"
	ResourceTypeLocalGatewayRouteTable                                 ResourceType = "local-gateway-route-table"
	ResourceTypeLocalGatewayVirtualInterface                           ResourceType = "local-gateway-virtual-interface"
	ResourceTypeLocalGatewayVirtualInterfaceGroup                      ResourceType = "local-gateway-virtual-interface-group"
	ResourceTypeLocalGatewayRouteTableVpcAssociation                   ResourceType = "local-gateway-route-table-vpc-association"
	ResourceTypeLocalGatewayRouteTableVirtualInterfaceGroupAssociation ResourceType = "local-gateway-route-table-virtual-interface-group-association"
	ResourceTypeNatgateway                                             ResourceType = "natgateway"
	ResourceTypeNetworkAcl                                             ResourceType = "network-acl"
	ResourceTypeNetworkInterface                                       ResourceType = "network-interface"
	ResourceTypeNetworkInsightsAnalysis                                ResourceType = "network-insights-analysis"
	ResourceTypeNetworkInsightsPath                                    ResourceType = "network-insights-path"
	ResourceTypeNetworkInsightsAccessScope                             ResourceType = "network-insights-access-scope"
	ResourceTypeNetworkInsightsAccessScopeAnalysis                     ResourceType = "network-insights-access-scope-analysis"
	ResourceTypePlacementGroup                                         ResourceType = "placement-group"
	ResourceTypePrefixList                                             ResourceType = "prefix-list"
	ResourceTypeReplaceRootVolumeTask                                  ResourceType = "replace-root-volume-task"
	ResourceTypeReservedInstances                                      ResourceType = "reserved-instances"
	ResourceTypeRouteTable                                             ResourceType = "route-table"
	ResourceTypeSecurityGroup                                          ResourceType = "security-group"
	ResourceTypeSecurityGroupRule                                      ResourceType = "security-group-rule"
	ResourceTypeSnapshot                                               ResourceType = "snapshot"
	ResourceTypeSpotFleetRequest                                       ResourceType = "spot-fleet-request"
	ResourceTypeSpotInstancesRequest                                   ResourceType = "spot-instances-request"
	ResourceTypeSubnet                                                 ResourceType = "subnet"
	ResourceTypeSubnetCidrReservation                                  ResourceType = "subnet-cidr-reservation"
	ResourceTypeTrafficMirrorFilter                                    ResourceType = "traffic-mirror-filter"
	ResourceTypeTrafficMirrorSession                                   ResourceType = "traffic-mirror-session"
	ResourceTypeTrafficMirrorTarget                                    ResourceType = "traffic-mirror-target"
	ResourceTypeTransitGateway                                         ResourceType = "transit-gateway"
	ResourceTypeTransitGatewayAttachment                               ResourceType = "transit-gateway-attachment"
	ResourceTypeTransitGatewayConnectPeer                              ResourceType = "transit-gateway-connect-peer"
	ResourceTypeTransitGatewayMulticastDomain                          ResourceType = "transit-gateway-multicast-domain"
	ResourceTypeTransitGatewayPolicyTable                              ResourceType = "transit-gateway-policy-table"
	ResourceTypeTransitGatewayRouteTable                               ResourceType = "transit-gateway-route-table"
	ResourceTypeTransitGatewayRouteTableAnnouncement                   ResourceType = "transit-gateway-route-table-announcement"
	ResourceTypeVolume                                                 ResourceType = "volume"
	ResourceTypeVpc                                                    ResourceType = "vpc"
	ResourceTypeVpcEndpoint                                            ResourceType = "vpc-endpoint"
	ResourceTypeVpcEndpointConnection                                  ResourceType = "vpc-endpoint-connection"
	ResourceTypeVpcEndpointService                                     ResourceType = "vpc-endpoint-service"
	ResourceTypeVpcEndpointServicePermission                           ResourceType = "vpc-endpoint-service-permission"
	ResourceTypeVpcPeeringConnection                                   ResourceType = "vpc-peering-connection"
	ResourceTypeVpnConnection                                          ResourceType = "vpn-connection"
	ResourceTypeVpnGateway                                             ResourceType = "vpn-gateway"
	ResourceTypeVpcFlowLog                                             ResourceType = "vpc-flow-log"
	ResourceTypeCapacityReservationFleet                               ResourceType = "capacity-reservation-fleet"
	ResourceTypeTrafficMirrorFilterRule                                ResourceType = "traffic-mirror-filter-rule"
	ResourceTypeVpcEndpointConnectionDeviceType                        ResourceType = "vpc-endpoint-connection-device-type"
	ResourceTypeVerifiedAccessInstance                                 ResourceType = "verified-access-instance"
	ResourceTypeVerifiedAccessGroup                                    ResourceType = "verified-access-group"
	ResourceTypeVerifiedAccessEndpoint                                 ResourceType = "verified-access-endpoint"
	ResourceTypeVerifiedAccessPolicy                                   ResourceType = "verified-access-policy"
	ResourceTypeVerifiedAccessTrustProvider                            ResourceType = "verified-access-trust-provider"
	ResourceTypeVpnConnectionDeviceType                                ResourceType = "vpn-connection-device-type"
	ResourceTypeVpcBlockPublicAccessExclusion                          ResourceType = "vpc-block-public-access-exclusion"
	ResourceTypeIpamResourceDiscovery                                  ResourceType = "ipam-resource-discovery"
	ResourceTypeIpamResourceDiscoveryAssociation                       ResourceType = "ipam-resource-discovery-association"
	ResourceTypeInstanceConnectEndpoint                                ResourceType = "instance-connect-endpoint"
	ResourceTypeIpamExternalResourceVerificationToken                  ResourceType = "ipam-external-resource-verification-token"
)

// Values returns all known values for ResourceType. 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 (ResourceType) Values() []ResourceType {
	return []ResourceType{
		"capacity-reservation",
		"client-vpn-endpoint",
		"customer-gateway",
		"carrier-gateway",
		"coip-pool",
		"dedicated-host",
		"dhcp-options",
		"egress-only-internet-gateway",
		"elastic-ip",
		"elastic-gpu",
		"export-image-task",
		"export-instance-task",
		"fleet",
		"fpga-image",
		"host-reservation",
		"image",
		"import-image-task",
		"import-snapshot-task",
		"instance",
		"instance-event-window",
		"internet-gateway",
		"ipam",
		"ipam-pool",
		"ipam-scope",
		"ipv4pool-ec2",
		"ipv6pool-ec2",
		"key-pair",
		"launch-template",
		"local-gateway",
		"local-gateway-route-table",
		"local-gateway-virtual-interface",
		"local-gateway-virtual-interface-group",
		"local-gateway-route-table-vpc-association",
		"local-gateway-route-table-virtual-interface-group-association",
		"natgateway",
		"network-acl",
		"network-interface",
		"network-insights-analysis",
		"network-insights-path",
		"network-insights-access-scope",
		"network-insights-access-scope-analysis",
		"placement-group",
		"prefix-list",
		"replace-root-volume-task",
		"reserved-instances",
		"route-table",
		"security-group",
		"security-group-rule",
		"snapshot",
		"spot-fleet-request",
		"spot-instances-request",
		"subnet",
		"subnet-cidr-reservation",
		"traffic-mirror-filter",
		"traffic-mirror-session",
		"traffic-mirror-target",
		"transit-gateway",
		"transit-gateway-attachment",
		"transit-gateway-connect-peer",
		"transit-gateway-multicast-domain",
		"transit-gateway-policy-table",
		"transit-gateway-route-table",
		"transit-gateway-route-table-announcement",
		"volume",
		"vpc",
		"vpc-endpoint",
		"vpc-endpoint-connection",
		"vpc-endpoint-service",
		"vpc-endpoint-service-permission",
		"vpc-peering-connection",
		"vpn-connection",
		"vpn-gateway",
		"vpc-flow-log",
		"capacity-reservation-fleet",
		"traffic-mirror-filter-rule",
		"vpc-endpoint-connection-device-type",
		"verified-access-instance",
		"verified-access-group",
		"verified-access-endpoint",
		"verified-access-policy",
		"verified-access-trust-provider",
		"vpn-connection-device-type",
		"vpc-block-public-access-exclusion",
		"ipam-resource-discovery",
		"ipam-resource-discovery-association",
		"instance-connect-endpoint",
		"ipam-external-resource-verification-token",
	}
}

type RIProductDescription string

// Enum values for RIProductDescription
const (
	RIProductDescriptionLinuxUnix          RIProductDescription = "Linux/UNIX"
	RIProductDescriptionLinuxUnixAmazonVpc RIProductDescription = "Linux/UNIX (Amazon VPC)"
	RIProductDescriptionWindows            RIProductDescription = "Windows"
	RIProductDescriptionWindowsAmazonVpc   RIProductDescription = "Windows (Amazon VPC)"
)

// Values returns all known values for RIProductDescription. 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 (RIProductDescription) Values() []RIProductDescription {
	return []RIProductDescription{
		"Linux/UNIX",
		"Linux/UNIX (Amazon VPC)",
		"Windows",
		"Windows (Amazon VPC)",
	}
}

type RootDeviceType string

// Enum values for RootDeviceType
const (
	RootDeviceTypeEbs           RootDeviceType = "ebs"
	RootDeviceTypeInstanceStore RootDeviceType = "instance-store"
)

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

type RouteOrigin string

// Enum values for RouteOrigin
const (
	RouteOriginCreateRouteTable          RouteOrigin = "CreateRouteTable"
	RouteOriginCreateRoute               RouteOrigin = "CreateRoute"
	RouteOriginEnableVgwRoutePropagation RouteOrigin = "EnableVgwRoutePropagation"
)

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

type RouteState string

// Enum values for RouteState
const (
	RouteStateActive    RouteState = "active"
	RouteStateBlackhole RouteState = "blackhole"
)

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

type RouteTableAssociationStateCode string

// Enum values for RouteTableAssociationStateCode
const (
	RouteTableAssociationStateCodeAssociating    RouteTableAssociationStateCode = "associating"
	RouteTableAssociationStateCodeAssociated     RouteTableAssociationStateCode = "associated"
	RouteTableAssociationStateCodeDisassociating RouteTableAssociationStateCode = "disassociating"
	RouteTableAssociationStateCodeDisassociated  RouteTableAssociationStateCode = "disassociated"
	RouteTableAssociationStateCodeFailed         RouteTableAssociationStateCode = "failed"
)

// Values returns all known values for RouteTableAssociationStateCode. 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 (RouteTableAssociationStateCode) Values() []RouteTableAssociationStateCode {
	return []RouteTableAssociationStateCode{
		"associating",
		"associated",
		"disassociating",
		"disassociated",
		"failed",
	}
}

type RuleAction string

// Enum values for RuleAction
const (
	RuleActionAllow RuleAction = "allow"
	RuleActionDeny  RuleAction = "deny"
)

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

type Scope string

// Enum values for Scope
const (
	ScopeAvailabilityZone Scope = "Availability Zone"
	ScopeRegional         Scope = "Region"
)

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

type SecurityGroupReferencingSupportValue string

// Enum values for SecurityGroupReferencingSupportValue
const (
	SecurityGroupReferencingSupportValueEnable  SecurityGroupReferencingSupportValue = "enable"
	SecurityGroupReferencingSupportValueDisable SecurityGroupReferencingSupportValue = "disable"
)

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

type SecurityGroupVpcAssociationState string

// Enum values for SecurityGroupVpcAssociationState
const (
	SecurityGroupVpcAssociationStateAssociating          SecurityGroupVpcAssociationState = "associating"
	SecurityGroupVpcAssociationStateAssociated           SecurityGroupVpcAssociationState = "associated"
	SecurityGroupVpcAssociationStateAssociationFailed    SecurityGroupVpcAssociationState = "association-failed"
	SecurityGroupVpcAssociationStateDisassociating       SecurityGroupVpcAssociationState = "disassociating"
	SecurityGroupVpcAssociationStateDisassociated        SecurityGroupVpcAssociationState = "disassociated"
	SecurityGroupVpcAssociationStateDisassociationFailed SecurityGroupVpcAssociationState = "disassociation-failed"
)

// Values returns all known values for SecurityGroupVpcAssociationState. 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 (SecurityGroupVpcAssociationState) Values() []SecurityGroupVpcAssociationState {
	return []SecurityGroupVpcAssociationState{
		"associating",
		"associated",
		"association-failed",
		"disassociating",
		"disassociated",
		"disassociation-failed",
	}
}

type SelfServicePortal string

// Enum values for SelfServicePortal
const (
	SelfServicePortalEnabled  SelfServicePortal = "enabled"
	SelfServicePortalDisabled SelfServicePortal = "disabled"
)

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

type ServiceConnectivityType string

// Enum values for ServiceConnectivityType
const (
	ServiceConnectivityTypeIpv4 ServiceConnectivityType = "ipv4"
	ServiceConnectivityTypeIpv6 ServiceConnectivityType = "ipv6"
)

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

type ServiceState string

// Enum values for ServiceState
const (
	ServiceStatePending   ServiceState = "Pending"
	ServiceStateAvailable ServiceState = "Available"
	ServiceStateDeleting  ServiceState = "Deleting"
	ServiceStateDeleted   ServiceState = "Deleted"
	ServiceStateFailed    ServiceState = "Failed"
)

// Values returns all known values for ServiceState. 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 (ServiceState) Values() []ServiceState {
	return []ServiceState{
		"Pending",
		"Available",
		"Deleting",
		"Deleted",
		"Failed",
	}
}

type ServiceType string

// Enum values for ServiceType
const (
	ServiceTypeInterface           ServiceType = "Interface"
	ServiceTypeGateway             ServiceType = "Gateway"
	ServiceTypeGatewayLoadBalancer ServiceType = "GatewayLoadBalancer"
)

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

type ShutdownBehavior string

// Enum values for ShutdownBehavior
const (
	ShutdownBehaviorStop      ShutdownBehavior = "stop"
	ShutdownBehaviorTerminate ShutdownBehavior = "terminate"
)

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

type SnapshotAttributeName string

// Enum values for SnapshotAttributeName
const (
	SnapshotAttributeNameProductCodes           SnapshotAttributeName = "productCodes"
	SnapshotAttributeNameCreateVolumePermission SnapshotAttributeName = "createVolumePermission"
)

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

type SnapshotBlockPublicAccessState string

// Enum values for SnapshotBlockPublicAccessState
const (
	SnapshotBlockPublicAccessStateBlockAllSharing SnapshotBlockPublicAccessState = "block-all-sharing"
	SnapshotBlockPublicAccessStateBlockNewSharing SnapshotBlockPublicAccessState = "block-new-sharing"
	SnapshotBlockPublicAccessStateUnblocked       SnapshotBlockPublicAccessState = "unblocked"
)

// Values returns all known values for SnapshotBlockPublicAccessState. 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 (SnapshotBlockPublicAccessState) Values() []SnapshotBlockPublicAccessState {
	return []SnapshotBlockPublicAccessState{
		"block-all-sharing",
		"block-new-sharing",
		"unblocked",
	}
}

type SnapshotState string

// Enum values for SnapshotState
const (
	SnapshotStatePending     SnapshotState = "pending"
	SnapshotStateCompleted   SnapshotState = "completed"
	SnapshotStateError       SnapshotState = "error"
	SnapshotStateRecoverable SnapshotState = "recoverable"
	SnapshotStateRecovering  SnapshotState = "recovering"
)

// Values returns all known values for SnapshotState. 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 (SnapshotState) Values() []SnapshotState {
	return []SnapshotState{
		"pending",
		"completed",
		"error",
		"recoverable",
		"recovering",
	}
}

type SpotAllocationStrategy string

// Enum values for SpotAllocationStrategy
const (
	SpotAllocationStrategyLowestPrice                  SpotAllocationStrategy = "lowest-price"
	SpotAllocationStrategyDiversified                  SpotAllocationStrategy = "diversified"
	SpotAllocationStrategyCapacityOptimized            SpotAllocationStrategy = "capacity-optimized"
	SpotAllocationStrategyCapacityOptimizedPrioritized SpotAllocationStrategy = "capacity-optimized-prioritized"
	SpotAllocationStrategyPriceCapacityOptimized       SpotAllocationStrategy = "price-capacity-optimized"
)

// Values returns all known values for SpotAllocationStrategy. 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 (SpotAllocationStrategy) Values() []SpotAllocationStrategy {
	return []SpotAllocationStrategy{
		"lowest-price",
		"diversified",
		"capacity-optimized",
		"capacity-optimized-prioritized",
		"price-capacity-optimized",
	}
}

type SpotInstanceInterruptionBehavior string

// Enum values for SpotInstanceInterruptionBehavior
const (
	SpotInstanceInterruptionBehaviorHibernate SpotInstanceInterruptionBehavior = "hibernate"
	SpotInstanceInterruptionBehaviorStop      SpotInstanceInterruptionBehavior = "stop"
	SpotInstanceInterruptionBehaviorTerminate SpotInstanceInterruptionBehavior = "terminate"
)

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

type SpotInstanceState string

// Enum values for SpotInstanceState
const (
	SpotInstanceStateOpen      SpotInstanceState = "open"
	SpotInstanceStateActive    SpotInstanceState = "active"
	SpotInstanceStateClosed    SpotInstanceState = "closed"
	SpotInstanceStateCancelled SpotInstanceState = "cancelled"
	SpotInstanceStateFailed    SpotInstanceState = "failed"
	SpotInstanceStateDisabled  SpotInstanceState = "disabled"
)

// Values returns all known values for SpotInstanceState. 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 (SpotInstanceState) Values() []SpotInstanceState {
	return []SpotInstanceState{
		"open",
		"active",
		"closed",
		"cancelled",
		"failed",
		"disabled",
	}
}

type SpotInstanceType string

// Enum values for SpotInstanceType
const (
	SpotInstanceTypeOneTime    SpotInstanceType = "one-time"
	SpotInstanceTypePersistent SpotInstanceType = "persistent"
)

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

type SpreadLevel string

// Enum values for SpreadLevel
const (
	SpreadLevelHost SpreadLevel = "host"
	SpreadLevelRack SpreadLevel = "rack"
)

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

type SSEType string

// Enum values for SSEType
const (
	SSETypeSseEbs SSEType = "sse-ebs"
	SSETypeSseKms SSEType = "sse-kms"
	SSETypeNone   SSEType = "none"
)

// 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{
		"sse-ebs",
		"sse-kms",
		"none",
	}
}

type State string

// Enum values for State
const (
	StatePendingAcceptance State = "PendingAcceptance"
	StatePending           State = "Pending"
	StateAvailable         State = "Available"
	StateDeleting          State = "Deleting"
	StateDeleted           State = "Deleted"
	StateRejected          State = "Rejected"
	StateFailed            State = "Failed"
	StateExpired           State = "Expired"
)

// Values returns all known values for State. 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 (State) Values() []State {
	return []State{
		"PendingAcceptance",
		"Pending",
		"Available",
		"Deleting",
		"Deleted",
		"Rejected",
		"Failed",
		"Expired",
	}
}

type StaticSourcesSupportValue string

// Enum values for StaticSourcesSupportValue
const (
	StaticSourcesSupportValueEnable  StaticSourcesSupportValue = "enable"
	StaticSourcesSupportValueDisable StaticSourcesSupportValue = "disable"
)

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

type StatisticType string

// Enum values for StatisticType
const (
	StatisticTypeP50 StatisticType = "p50"
)

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

type Status string

// Enum values for Status
const (
	StatusMoveInProgress Status = "MoveInProgress"
	StatusInVpc          Status = "InVpc"
	StatusInClassic      Status = "InClassic"
)

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

type StatusName string

// Enum values for StatusName
const (
	StatusNameReachability StatusName = "reachability"
)

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

type StatusType string

// Enum values for StatusType
const (
	StatusTypePassed           StatusType = "passed"
	StatusTypeFailed           StatusType = "failed"
	StatusTypeInsufficientData StatusType = "insufficient-data"
	StatusTypeInitializing     StatusType = "initializing"
)

// Values returns all known values for StatusType. 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 (StatusType) Values() []StatusType {
	return []StatusType{
		"passed",
		"failed",
		"insufficient-data",
		"initializing",
	}
}

type StorageTier string

// Enum values for StorageTier
const (
	StorageTierArchive  StorageTier = "archive"
	StorageTierStandard StorageTier = "standard"
)

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

type SubnetCidrBlockStateCode string

// Enum values for SubnetCidrBlockStateCode
const (
	SubnetCidrBlockStateCodeAssociating    SubnetCidrBlockStateCode = "associating"
	SubnetCidrBlockStateCodeAssociated     SubnetCidrBlockStateCode = "associated"
	SubnetCidrBlockStateCodeDisassociating SubnetCidrBlockStateCode = "disassociating"
	SubnetCidrBlockStateCodeDisassociated  SubnetCidrBlockStateCode = "disassociated"
	SubnetCidrBlockStateCodeFailing        SubnetCidrBlockStateCode = "failing"
	SubnetCidrBlockStateCodeFailed         SubnetCidrBlockStateCode = "failed"
)

// Values returns all known values for SubnetCidrBlockStateCode. 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 (SubnetCidrBlockStateCode) Values() []SubnetCidrBlockStateCode {
	return []SubnetCidrBlockStateCode{
		"associating",
		"associated",
		"disassociating",
		"disassociated",
		"failing",
		"failed",
	}
}

type SubnetCidrReservationType string

// Enum values for SubnetCidrReservationType
const (
	SubnetCidrReservationTypePrefix   SubnetCidrReservationType = "prefix"
	SubnetCidrReservationTypeExplicit SubnetCidrReservationType = "explicit"
)

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

type SubnetState string

// Enum values for SubnetState
const (
	SubnetStatePending     SubnetState = "pending"
	SubnetStateAvailable   SubnetState = "available"
	SubnetStateUnavailable SubnetState = "unavailable"
)

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

type SummaryStatus string

// Enum values for SummaryStatus
const (
	SummaryStatusOk               SummaryStatus = "ok"
	SummaryStatusImpaired         SummaryStatus = "impaired"
	SummaryStatusInsufficientData SummaryStatus = "insufficient-data"
	SummaryStatusNotApplicable    SummaryStatus = "not-applicable"
	SummaryStatusInitializing     SummaryStatus = "initializing"
)

// Values returns all known values for SummaryStatus. 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 (SummaryStatus) Values() []SummaryStatus {
	return []SummaryStatus{
		"ok",
		"impaired",
		"insufficient-data",
		"not-applicable",
		"initializing",
	}
}

type SupportedAdditionalProcessorFeature string

// Enum values for SupportedAdditionalProcessorFeature
const (
	SupportedAdditionalProcessorFeatureAmdSevSnp SupportedAdditionalProcessorFeature = "amd-sev-snp"
)

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

type TargetCapacityUnitType string

// Enum values for TargetCapacityUnitType
const (
	TargetCapacityUnitTypeVcpu      TargetCapacityUnitType = "vcpu"
	TargetCapacityUnitTypeMemoryMib TargetCapacityUnitType = "memory-mib"
	TargetCapacityUnitTypeUnits     TargetCapacityUnitType = "units"
)

// Values returns all known values for TargetCapacityUnitType. 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 (TargetCapacityUnitType) Values() []TargetCapacityUnitType {
	return []TargetCapacityUnitType{
		"vcpu",
		"memory-mib",
		"units",
	}
}

type TargetStorageTier string

// Enum values for TargetStorageTier
const (
	TargetStorageTierArchive TargetStorageTier = "archive"
)

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

type TelemetryStatus string

// Enum values for TelemetryStatus
const (
	TelemetryStatusUp   TelemetryStatus = "UP"
	TelemetryStatusDown TelemetryStatus = "DOWN"
)

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

type Tenancy string

// Enum values for Tenancy
const (
	TenancyDefault   Tenancy = "default"
	TenancyDedicated Tenancy = "dedicated"
	TenancyHost      Tenancy = "host"
)

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

type TieringOperationStatus string

// Enum values for TieringOperationStatus
const (
	TieringOperationStatusArchivalInProgress         TieringOperationStatus = "archival-in-progress"
	TieringOperationStatusArchivalCompleted          TieringOperationStatus = "archival-completed"
	TieringOperationStatusArchivalFailed             TieringOperationStatus = "archival-failed"
	TieringOperationStatusTemporaryRestoreInProgress TieringOperationStatus = "temporary-restore-in-progress"
	TieringOperationStatusTemporaryRestoreCompleted  TieringOperationStatus = "temporary-restore-completed"
	TieringOperationStatusTemporaryRestoreFailed     TieringOperationStatus = "temporary-restore-failed"
	TieringOperationStatusPermanentRestoreInProgress TieringOperationStatus = "permanent-restore-in-progress"
	TieringOperationStatusPermanentRestoreCompleted  TieringOperationStatus = "permanent-restore-completed"
	TieringOperationStatusPermanentRestoreFailed     TieringOperationStatus = "permanent-restore-failed"
)

// Values returns all known values for TieringOperationStatus. 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 (TieringOperationStatus) Values() []TieringOperationStatus {
	return []TieringOperationStatus{
		"archival-in-progress",
		"archival-completed",
		"archival-failed",
		"temporary-restore-in-progress",
		"temporary-restore-completed",
		"temporary-restore-failed",
		"permanent-restore-in-progress",
		"permanent-restore-completed",
		"permanent-restore-failed",
	}
}

type TokenState string

// Enum values for TokenState
const (
	TokenStateValid   TokenState = "valid"
	TokenStateExpired TokenState = "expired"
)

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

type TpmSupportValues string

// Enum values for TpmSupportValues
const (
	TpmSupportValuesV20 TpmSupportValues = "v2.0"
)

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

type TrafficDirection string

// Enum values for TrafficDirection
const (
	TrafficDirectionIngress TrafficDirection = "ingress"
	TrafficDirectionEgress  TrafficDirection = "egress"
)

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

type TrafficMirrorFilterRuleField string

// Enum values for TrafficMirrorFilterRuleField
const (
	TrafficMirrorFilterRuleFieldDestinationPortRange TrafficMirrorFilterRuleField = "destination-port-range"
	TrafficMirrorFilterRuleFieldSourcePortRange      TrafficMirrorFilterRuleField = "source-port-range"
	TrafficMirrorFilterRuleFieldProtocol             TrafficMirrorFilterRuleField = "protocol"
	TrafficMirrorFilterRuleFieldDescription          TrafficMirrorFilterRuleField = "description"
)

// Values returns all known values for TrafficMirrorFilterRuleField. 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 (TrafficMirrorFilterRuleField) Values() []TrafficMirrorFilterRuleField {
	return []TrafficMirrorFilterRuleField{
		"destination-port-range",
		"source-port-range",
		"protocol",
		"description",
	}
}

type TrafficMirrorNetworkService string

// Enum values for TrafficMirrorNetworkService
const (
	TrafficMirrorNetworkServiceAmazonDns TrafficMirrorNetworkService = "amazon-dns"
)

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

type TrafficMirrorRuleAction string

// Enum values for TrafficMirrorRuleAction
const (
	TrafficMirrorRuleActionAccept TrafficMirrorRuleAction = "accept"
	TrafficMirrorRuleActionReject TrafficMirrorRuleAction = "reject"
)

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

type TrafficMirrorSessionField string

// Enum values for TrafficMirrorSessionField
const (
	TrafficMirrorSessionFieldPacketLength     TrafficMirrorSessionField = "packet-length"
	TrafficMirrorSessionFieldDescription      TrafficMirrorSessionField = "description"
	TrafficMirrorSessionFieldVirtualNetworkId TrafficMirrorSessionField = "virtual-network-id"
)

// Values returns all known values for TrafficMirrorSessionField. 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 (TrafficMirrorSessionField) Values() []TrafficMirrorSessionField {
	return []TrafficMirrorSessionField{
		"packet-length",
		"description",
		"virtual-network-id",
	}
}

type TrafficMirrorTargetType string

// Enum values for TrafficMirrorTargetType
const (
	TrafficMirrorTargetTypeNetworkInterface            TrafficMirrorTargetType = "network-interface"
	TrafficMirrorTargetTypeNetworkLoadBalancer         TrafficMirrorTargetType = "network-load-balancer"
	TrafficMirrorTargetTypeGatewayLoadBalancerEndpoint TrafficMirrorTargetType = "gateway-load-balancer-endpoint"
)

// Values returns all known values for TrafficMirrorTargetType. 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 (TrafficMirrorTargetType) Values() []TrafficMirrorTargetType {
	return []TrafficMirrorTargetType{
		"network-interface",
		"network-load-balancer",
		"gateway-load-balancer-endpoint",
	}
}

type TrafficType string

// Enum values for TrafficType
const (
	TrafficTypeAccept TrafficType = "ACCEPT"
	TrafficTypeReject TrafficType = "REJECT"
	TrafficTypeAll    TrafficType = "ALL"
)

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

type TransitGatewayAssociationState string

// Enum values for TransitGatewayAssociationState
const (
	TransitGatewayAssociationStateAssociating    TransitGatewayAssociationState = "associating"
	TransitGatewayAssociationStateAssociated     TransitGatewayAssociationState = "associated"
	TransitGatewayAssociationStateDisassociating TransitGatewayAssociationState = "disassociating"
	TransitGatewayAssociationStateDisassociated  TransitGatewayAssociationState = "disassociated"
)

// Values returns all known values for TransitGatewayAssociationState. 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 (TransitGatewayAssociationState) Values() []TransitGatewayAssociationState {
	return []TransitGatewayAssociationState{
		"associating",
		"associated",
		"disassociating",
		"disassociated",
	}
}

type TransitGatewayAttachmentResourceType string

// Enum values for TransitGatewayAttachmentResourceType
const (
	TransitGatewayAttachmentResourceTypeVpc                  TransitGatewayAttachmentResourceType = "vpc"
	TransitGatewayAttachmentResourceTypeVpn                  TransitGatewayAttachmentResourceType = "vpn"
	TransitGatewayAttachmentResourceTypeDirectConnectGateway TransitGatewayAttachmentResourceType = "direct-connect-gateway"
	TransitGatewayAttachmentResourceTypeConnect              TransitGatewayAttachmentResourceType = "connect"
	TransitGatewayAttachmentResourceTypePeering              TransitGatewayAttachmentResourceType = "peering"
	TransitGatewayAttachmentResourceTypeTgwPeering           TransitGatewayAttachmentResourceType = "tgw-peering"
)

// Values returns all known values for TransitGatewayAttachmentResourceType. 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 (TransitGatewayAttachmentResourceType) Values() []TransitGatewayAttachmentResourceType {
	return []TransitGatewayAttachmentResourceType{
		"vpc",
		"vpn",
		"direct-connect-gateway",
		"connect",
		"peering",
		"tgw-peering",
	}
}

type TransitGatewayAttachmentState string

// Enum values for TransitGatewayAttachmentState
const (
	TransitGatewayAttachmentStateInitiating        TransitGatewayAttachmentState = "initiating"
	TransitGatewayAttachmentStateInitiatingRequest TransitGatewayAttachmentState = "initiatingRequest"
	TransitGatewayAttachmentStatePendingAcceptance TransitGatewayAttachmentState = "pendingAcceptance"
	TransitGatewayAttachmentStateRollingBack       TransitGatewayAttachmentState = "rollingBack"
	TransitGatewayAttachmentStatePending           TransitGatewayAttachmentState = "pending"
	TransitGatewayAttachmentStateAvailable         TransitGatewayAttachmentState = "available"
	TransitGatewayAttachmentStateModifying         TransitGatewayAttachmentState = "modifying"
	TransitGatewayAttachmentStateDeleting          TransitGatewayAttachmentState = "deleting"
	TransitGatewayAttachmentStateDeleted           TransitGatewayAttachmentState = "deleted"
	TransitGatewayAttachmentStateFailed            TransitGatewayAttachmentState = "failed"
	TransitGatewayAttachmentStateRejected          TransitGatewayAttachmentState = "rejected"
	TransitGatewayAttachmentStateRejecting         TransitGatewayAttachmentState = "rejecting"
	TransitGatewayAttachmentStateFailing           TransitGatewayAttachmentState = "failing"
)

// Values returns all known values for TransitGatewayAttachmentState. 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 (TransitGatewayAttachmentState) Values() []TransitGatewayAttachmentState {
	return []TransitGatewayAttachmentState{
		"initiating",
		"initiatingRequest",
		"pendingAcceptance",
		"rollingBack",
		"pending",
		"available",
		"modifying",
		"deleting",
		"deleted",
		"failed",
		"rejected",
		"rejecting",
		"failing",
	}
}

type TransitGatewayConnectPeerState string

// Enum values for TransitGatewayConnectPeerState
const (
	TransitGatewayConnectPeerStatePending   TransitGatewayConnectPeerState = "pending"
	TransitGatewayConnectPeerStateAvailable TransitGatewayConnectPeerState = "available"
	TransitGatewayConnectPeerStateDeleting  TransitGatewayConnectPeerState = "deleting"
	TransitGatewayConnectPeerStateDeleted   TransitGatewayConnectPeerState = "deleted"
)

// Values returns all known values for TransitGatewayConnectPeerState. 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 (TransitGatewayConnectPeerState) Values() []TransitGatewayConnectPeerState {
	return []TransitGatewayConnectPeerState{
		"pending",
		"available",
		"deleting",
		"deleted",
	}
}

type TransitGatewayMulitcastDomainAssociationState string

// Enum values for TransitGatewayMulitcastDomainAssociationState
const (
	TransitGatewayMulitcastDomainAssociationStatePendingAcceptance TransitGatewayMulitcastDomainAssociationState = "pendingAcceptance"
	TransitGatewayMulitcastDomainAssociationStateAssociating       TransitGatewayMulitcastDomainAssociationState = "associating"
	TransitGatewayMulitcastDomainAssociationStateAssociated        TransitGatewayMulitcastDomainAssociationState = "associated"
	TransitGatewayMulitcastDomainAssociationStateDisassociating    TransitGatewayMulitcastDomainAssociationState = "disassociating"
	TransitGatewayMulitcastDomainAssociationStateDisassociated     TransitGatewayMulitcastDomainAssociationState = "disassociated"
	TransitGatewayMulitcastDomainAssociationStateRejected          TransitGatewayMulitcastDomainAssociationState = "rejected"
	TransitGatewayMulitcastDomainAssociationStateFailed            TransitGatewayMulitcastDomainAssociationState = "failed"
)

// Values returns all known values for
// TransitGatewayMulitcastDomainAssociationState. 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 (TransitGatewayMulitcastDomainAssociationState) Values() []TransitGatewayMulitcastDomainAssociationState {
	return []TransitGatewayMulitcastDomainAssociationState{
		"pendingAcceptance",
		"associating",
		"associated",
		"disassociating",
		"disassociated",
		"rejected",
		"failed",
	}
}

type TransitGatewayMulticastDomainState string

// Enum values for TransitGatewayMulticastDomainState
const (
	TransitGatewayMulticastDomainStatePending   TransitGatewayMulticastDomainState = "pending"
	TransitGatewayMulticastDomainStateAvailable TransitGatewayMulticastDomainState = "available"
	TransitGatewayMulticastDomainStateDeleting  TransitGatewayMulticastDomainState = "deleting"
	TransitGatewayMulticastDomainStateDeleted   TransitGatewayMulticastDomainState = "deleted"
)

// Values returns all known values for TransitGatewayMulticastDomainState. 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 (TransitGatewayMulticastDomainState) Values() []TransitGatewayMulticastDomainState {
	return []TransitGatewayMulticastDomainState{
		"pending",
		"available",
		"deleting",
		"deleted",
	}
}

type TransitGatewayPolicyTableState string

// Enum values for TransitGatewayPolicyTableState
const (
	TransitGatewayPolicyTableStatePending   TransitGatewayPolicyTableState = "pending"
	TransitGatewayPolicyTableStateAvailable TransitGatewayPolicyTableState = "available"
	TransitGatewayPolicyTableStateDeleting  TransitGatewayPolicyTableState = "deleting"
	TransitGatewayPolicyTableStateDeleted   TransitGatewayPolicyTableState = "deleted"
)

// Values returns all known values for TransitGatewayPolicyTableState. 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 (TransitGatewayPolicyTableState) Values() []TransitGatewayPolicyTableState {
	return []TransitGatewayPolicyTableState{
		"pending",
		"available",
		"deleting",
		"deleted",
	}
}

type TransitGatewayPrefixListReferenceState string

// Enum values for TransitGatewayPrefixListReferenceState
const (
	TransitGatewayPrefixListReferenceStatePending   TransitGatewayPrefixListReferenceState = "pending"
	TransitGatewayPrefixListReferenceStateAvailable TransitGatewayPrefixListReferenceState = "available"
	TransitGatewayPrefixListReferenceStateModifying TransitGatewayPrefixListReferenceState = "modifying"
	TransitGatewayPrefixListReferenceStateDeleting  TransitGatewayPrefixListReferenceState = "deleting"
)

// Values returns all known values for TransitGatewayPrefixListReferenceState.
// 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 (TransitGatewayPrefixListReferenceState) Values() []TransitGatewayPrefixListReferenceState {
	return []TransitGatewayPrefixListReferenceState{
		"pending",
		"available",
		"modifying",
		"deleting",
	}
}

type TransitGatewayPropagationState string

// Enum values for TransitGatewayPropagationState
const (
	TransitGatewayPropagationStateEnabling  TransitGatewayPropagationState = "enabling"
	TransitGatewayPropagationStateEnabled   TransitGatewayPropagationState = "enabled"
	TransitGatewayPropagationStateDisabling TransitGatewayPropagationState = "disabling"
	TransitGatewayPropagationStateDisabled  TransitGatewayPropagationState = "disabled"
)

// Values returns all known values for TransitGatewayPropagationState. 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 (TransitGatewayPropagationState) Values() []TransitGatewayPropagationState {
	return []TransitGatewayPropagationState{
		"enabling",
		"enabled",
		"disabling",
		"disabled",
	}
}

type TransitGatewayRouteState string

// Enum values for TransitGatewayRouteState
const (
	TransitGatewayRouteStatePending   TransitGatewayRouteState = "pending"
	TransitGatewayRouteStateActive    TransitGatewayRouteState = "active"
	TransitGatewayRouteStateBlackhole TransitGatewayRouteState = "blackhole"
	TransitGatewayRouteStateDeleting  TransitGatewayRouteState = "deleting"
	TransitGatewayRouteStateDeleted   TransitGatewayRouteState = "deleted"
)

// Values returns all known values for TransitGatewayRouteState. 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 (TransitGatewayRouteState) Values() []TransitGatewayRouteState {
	return []TransitGatewayRouteState{
		"pending",
		"active",
		"blackhole",
		"deleting",
		"deleted",
	}
}

type TransitGatewayRouteTableAnnouncementDirection string

// Enum values for TransitGatewayRouteTableAnnouncementDirection
const (
	TransitGatewayRouteTableAnnouncementDirectionOutgoing TransitGatewayRouteTableAnnouncementDirection = "outgoing"
	TransitGatewayRouteTableAnnouncementDirectionIncoming TransitGatewayRouteTableAnnouncementDirection = "incoming"
)

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

type TransitGatewayRouteTableAnnouncementState string

// Enum values for TransitGatewayRouteTableAnnouncementState
const (
	TransitGatewayRouteTableAnnouncementStateAvailable TransitGatewayRouteTableAnnouncementState = "available"
	TransitGatewayRouteTableAnnouncementStatePending   TransitGatewayRouteTableAnnouncementState = "pending"
	TransitGatewayRouteTableAnnouncementStateFailing   TransitGatewayRouteTableAnnouncementState = "failing"
	TransitGatewayRouteTableAnnouncementStateFailed    TransitGatewayRouteTableAnnouncementState = "failed"
	TransitGatewayRouteTableAnnouncementStateDeleting  TransitGatewayRouteTableAnnouncementState = "deleting"
	TransitGatewayRouteTableAnnouncementStateDeleted   TransitGatewayRouteTableAnnouncementState = "deleted"
)

// Values returns all known values for TransitGatewayRouteTableAnnouncementState.
// 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 (TransitGatewayRouteTableAnnouncementState) Values() []TransitGatewayRouteTableAnnouncementState {
	return []TransitGatewayRouteTableAnnouncementState{
		"available",
		"pending",
		"failing",
		"failed",
		"deleting",
		"deleted",
	}
}

type TransitGatewayRouteTableState string

// Enum values for TransitGatewayRouteTableState
const (
	TransitGatewayRouteTableStatePending   TransitGatewayRouteTableState = "pending"
	TransitGatewayRouteTableStateAvailable TransitGatewayRouteTableState = "available"
	TransitGatewayRouteTableStateDeleting  TransitGatewayRouteTableState = "deleting"
	TransitGatewayRouteTableStateDeleted   TransitGatewayRouteTableState = "deleted"
)

// Values returns all known values for TransitGatewayRouteTableState. 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 (TransitGatewayRouteTableState) Values() []TransitGatewayRouteTableState {
	return []TransitGatewayRouteTableState{
		"pending",
		"available",
		"deleting",
		"deleted",
	}
}

type TransitGatewayRouteType string

// Enum values for TransitGatewayRouteType
const (
	TransitGatewayRouteTypeStatic     TransitGatewayRouteType = "static"
	TransitGatewayRouteTypePropagated TransitGatewayRouteType = "propagated"
)

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

type TransitGatewayState string

// Enum values for TransitGatewayState
const (
	TransitGatewayStatePending   TransitGatewayState = "pending"
	TransitGatewayStateAvailable TransitGatewayState = "available"
	TransitGatewayStateModifying TransitGatewayState = "modifying"
	TransitGatewayStateDeleting  TransitGatewayState = "deleting"
	TransitGatewayStateDeleted   TransitGatewayState = "deleted"
)

// Values returns all known values for TransitGatewayState. 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 (TransitGatewayState) Values() []TransitGatewayState {
	return []TransitGatewayState{
		"pending",
		"available",
		"modifying",
		"deleting",
		"deleted",
	}
}

type TransportProtocol string

// Enum values for TransportProtocol
const (
	TransportProtocolTcp TransportProtocol = "tcp"
	TransportProtocolUdp TransportProtocol = "udp"
)

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

type TrustProviderType string

// Enum values for TrustProviderType
const (
	TrustProviderTypeUser   TrustProviderType = "user"
	TrustProviderTypeDevice TrustProviderType = "device"
)

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

type TunnelInsideIpVersion string

// Enum values for TunnelInsideIpVersion
const (
	TunnelInsideIpVersionIpv4 TunnelInsideIpVersion = "ipv4"
	TunnelInsideIpVersionIpv6 TunnelInsideIpVersion = "ipv6"
)

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

type UnlimitedSupportedInstanceFamily string

// Enum values for UnlimitedSupportedInstanceFamily
const (
	UnlimitedSupportedInstanceFamilyT2  UnlimitedSupportedInstanceFamily = "t2"
	UnlimitedSupportedInstanceFamilyT3  UnlimitedSupportedInstanceFamily = "t3"
	UnlimitedSupportedInstanceFamilyT3a UnlimitedSupportedInstanceFamily = "t3a"
	UnlimitedSupportedInstanceFamilyT4g UnlimitedSupportedInstanceFamily = "t4g"
)

// Values returns all known values for UnlimitedSupportedInstanceFamily. 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 (UnlimitedSupportedInstanceFamily) Values() []UnlimitedSupportedInstanceFamily {
	return []UnlimitedSupportedInstanceFamily{
		"t2",
		"t3",
		"t3a",
		"t4g",
	}
}

type UnsuccessfulInstanceCreditSpecificationErrorCode string

// Enum values for UnsuccessfulInstanceCreditSpecificationErrorCode
const (
	UnsuccessfulInstanceCreditSpecificationErrorCodeInvalidInstanceId                       UnsuccessfulInstanceCreditSpecificationErrorCode = "InvalidInstanceID.Malformed"
	UnsuccessfulInstanceCreditSpecificationErrorCodeInstanceNotFound                        UnsuccessfulInstanceCreditSpecificationErrorCode = "InvalidInstanceID.NotFound"
	UnsuccessfulInstanceCreditSpecificationErrorCodeIncorrectInstanceState                  UnsuccessfulInstanceCreditSpecificationErrorCode = "IncorrectInstanceState"
	UnsuccessfulInstanceCreditSpecificationErrorCodeInstanceCreditSpecificationNotSupported UnsuccessfulInstanceCreditSpecificationErrorCode = "InstanceCreditSpecification.NotSupported"
)

// Values returns all known values for
// UnsuccessfulInstanceCreditSpecificationErrorCode. 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 (UnsuccessfulInstanceCreditSpecificationErrorCode) Values() []UnsuccessfulInstanceCreditSpecificationErrorCode {
	return []UnsuccessfulInstanceCreditSpecificationErrorCode{
		"InvalidInstanceID.Malformed",
		"InvalidInstanceID.NotFound",
		"IncorrectInstanceState",
		"InstanceCreditSpecification.NotSupported",
	}
}

type UsageClassType string

// Enum values for UsageClassType
const (
	UsageClassTypeSpot          UsageClassType = "spot"
	UsageClassTypeOnDemand      UsageClassType = "on-demand"
	UsageClassTypeCapacityBlock UsageClassType = "capacity-block"
)

// Values returns all known values for UsageClassType. 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 (UsageClassType) Values() []UsageClassType {
	return []UsageClassType{
		"spot",
		"on-demand",
		"capacity-block",
	}
}

type UserTrustProviderType string

// Enum values for UserTrustProviderType
const (
	UserTrustProviderTypeIamIdentityCenter UserTrustProviderType = "iam-identity-center"
	UserTrustProviderTypeOidc              UserTrustProviderType = "oidc"
)

// Values returns all known values for UserTrustProviderType. 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 (UserTrustProviderType) Values() []UserTrustProviderType {
	return []UserTrustProviderType{
		"iam-identity-center",
		"oidc",
	}
}

type VerificationMethod string

// Enum values for VerificationMethod
const (
	VerificationMethodRemarksX509 VerificationMethod = "remarks-x509"
	VerificationMethodDnsToken    VerificationMethod = "dns-token"
)

// Values returns all known values for VerificationMethod. 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 (VerificationMethod) Values() []VerificationMethod {
	return []VerificationMethod{
		"remarks-x509",
		"dns-token",
	}
}

type VerifiedAccessEndpointAttachmentType string

// Enum values for VerifiedAccessEndpointAttachmentType
const (
	VerifiedAccessEndpointAttachmentTypeVpc VerifiedAccessEndpointAttachmentType = "vpc"
)

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

type VerifiedAccessEndpointProtocol string

// Enum values for VerifiedAccessEndpointProtocol
const (
	VerifiedAccessEndpointProtocolHttp  VerifiedAccessEndpointProtocol = "http"
	VerifiedAccessEndpointProtocolHttps VerifiedAccessEndpointProtocol = "https"
)

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

type VerifiedAccessEndpointStatusCode string

// Enum values for VerifiedAccessEndpointStatusCode
const (
	VerifiedAccessEndpointStatusCodePending  VerifiedAccessEndpointStatusCode = "pending"
	VerifiedAccessEndpointStatusCodeActive   VerifiedAccessEndpointStatusCode = "active"
	VerifiedAccessEndpointStatusCodeUpdating VerifiedAccessEndpointStatusCode = "updating"
	VerifiedAccessEndpointStatusCodeDeleting VerifiedAccessEndpointStatusCode = "deleting"
	VerifiedAccessEndpointStatusCodeDeleted  VerifiedAccessEndpointStatusCode = "deleted"
)

// Values returns all known values for VerifiedAccessEndpointStatusCode. 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 (VerifiedAccessEndpointStatusCode) Values() []VerifiedAccessEndpointStatusCode {
	return []VerifiedAccessEndpointStatusCode{
		"pending",
		"active",
		"updating",
		"deleting",
		"deleted",
	}
}

type VerifiedAccessEndpointType string

// Enum values for VerifiedAccessEndpointType
const (
	VerifiedAccessEndpointTypeLoadBalancer     VerifiedAccessEndpointType = "load-balancer"
	VerifiedAccessEndpointTypeNetworkInterface VerifiedAccessEndpointType = "network-interface"
)

// Values returns all known values for VerifiedAccessEndpointType. 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 (VerifiedAccessEndpointType) Values() []VerifiedAccessEndpointType {
	return []VerifiedAccessEndpointType{
		"load-balancer",
		"network-interface",
	}
}

type VerifiedAccessLogDeliveryStatusCode string

// Enum values for VerifiedAccessLogDeliveryStatusCode
const (
	VerifiedAccessLogDeliveryStatusCodeSuccess VerifiedAccessLogDeliveryStatusCode = "success"
	VerifiedAccessLogDeliveryStatusCodeFailed  VerifiedAccessLogDeliveryStatusCode = "failed"
)

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

type VirtualizationType string

// Enum values for VirtualizationType
const (
	VirtualizationTypeHvm         VirtualizationType = "hvm"
	VirtualizationTypeParavirtual VirtualizationType = "paravirtual"
)

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

type VolumeAttachmentState string

// Enum values for VolumeAttachmentState
const (
	VolumeAttachmentStateAttaching VolumeAttachmentState = "attaching"
	VolumeAttachmentStateAttached  VolumeAttachmentState = "attached"
	VolumeAttachmentStateDetaching VolumeAttachmentState = "detaching"
	VolumeAttachmentStateDetached  VolumeAttachmentState = "detached"
	VolumeAttachmentStateBusy      VolumeAttachmentState = "busy"
)

// Values returns all known values for VolumeAttachmentState. 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 (VolumeAttachmentState) Values() []VolumeAttachmentState {
	return []VolumeAttachmentState{
		"attaching",
		"attached",
		"detaching",
		"detached",
		"busy",
	}
}

type VolumeAttributeName string

// Enum values for VolumeAttributeName
const (
	VolumeAttributeNameAutoEnableIO VolumeAttributeName = "autoEnableIO"
	VolumeAttributeNameProductCodes VolumeAttributeName = "productCodes"
)

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

type VolumeModificationState string

// Enum values for VolumeModificationState
const (
	VolumeModificationStateModifying  VolumeModificationState = "modifying"
	VolumeModificationStateOptimizing VolumeModificationState = "optimizing"
	VolumeModificationStateCompleted  VolumeModificationState = "completed"
	VolumeModificationStateFailed     VolumeModificationState = "failed"
)

// Values returns all known values for VolumeModificationState. 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 (VolumeModificationState) Values() []VolumeModificationState {
	return []VolumeModificationState{
		"modifying",
		"optimizing",
		"completed",
		"failed",
	}
}

type VolumeState string

// Enum values for VolumeState
const (
	VolumeStateCreating  VolumeState = "creating"
	VolumeStateAvailable VolumeState = "available"
	VolumeStateInUse     VolumeState = "in-use"
	VolumeStateDeleting  VolumeState = "deleting"
	VolumeStateDeleted   VolumeState = "deleted"
	VolumeStateError     VolumeState = "error"
)

// Values returns all known values for VolumeState. 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 (VolumeState) Values() []VolumeState {
	return []VolumeState{
		"creating",
		"available",
		"in-use",
		"deleting",
		"deleted",
		"error",
	}
}

type VolumeStatusInfoStatus string

// Enum values for VolumeStatusInfoStatus
const (
	VolumeStatusInfoStatusOk               VolumeStatusInfoStatus = "ok"
	VolumeStatusInfoStatusImpaired         VolumeStatusInfoStatus = "impaired"
	VolumeStatusInfoStatusInsufficientData VolumeStatusInfoStatus = "insufficient-data"
)

// Values returns all known values for VolumeStatusInfoStatus. 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 (VolumeStatusInfoStatus) Values() []VolumeStatusInfoStatus {
	return []VolumeStatusInfoStatus{
		"ok",
		"impaired",
		"insufficient-data",
	}
}

type VolumeStatusName string

// Enum values for VolumeStatusName
const (
	VolumeStatusNameIoEnabled     VolumeStatusName = "io-enabled"
	VolumeStatusNameIoPerformance VolumeStatusName = "io-performance"
)

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

type VolumeType string

// Enum values for VolumeType
const (
	VolumeTypeStandard VolumeType = "standard"
	VolumeTypeIo1      VolumeType = "io1"
	VolumeTypeIo2      VolumeType = "io2"
	VolumeTypeGp2      VolumeType = "gp2"
	VolumeTypeSc1      VolumeType = "sc1"
	VolumeTypeSt1      VolumeType = "st1"
	VolumeTypeGp3      VolumeType = "gp3"
)

// Values returns all known values for VolumeType. 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 (VolumeType) Values() []VolumeType {
	return []VolumeType{
		"standard",
		"io1",
		"io2",
		"gp2",
		"sc1",
		"st1",
		"gp3",
	}
}

type VpcAttributeName string

// Enum values for VpcAttributeName
const (
	VpcAttributeNameEnableDnsSupport                 VpcAttributeName = "enableDnsSupport"
	VpcAttributeNameEnableDnsHostnames               VpcAttributeName = "enableDnsHostnames"
	VpcAttributeNameEnableNetworkAddressUsageMetrics VpcAttributeName = "enableNetworkAddressUsageMetrics"
)

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

type VpcBlockPublicAccessExclusionState string

// Enum values for VpcBlockPublicAccessExclusionState
const (
	VpcBlockPublicAccessExclusionStateCreateInProgress  VpcBlockPublicAccessExclusionState = "create-in-progress"
	VpcBlockPublicAccessExclusionStateCreateComplete    VpcBlockPublicAccessExclusionState = "create-complete"
	VpcBlockPublicAccessExclusionStateCreateFailed      VpcBlockPublicAccessExclusionState = "create-failed"
	VpcBlockPublicAccessExclusionStateUpdateInProgress  VpcBlockPublicAccessExclusionState = "update-in-progress"
	VpcBlockPublicAccessExclusionStateUpdateComplete    VpcBlockPublicAccessExclusionState = "update-complete"
	VpcBlockPublicAccessExclusionStateUpdateFailed      VpcBlockPublicAccessExclusionState = "update-failed"
	VpcBlockPublicAccessExclusionStateDeleteInProgress  VpcBlockPublicAccessExclusionState = "delete-in-progress"
	VpcBlockPublicAccessExclusionStateDeleteComplete    VpcBlockPublicAccessExclusionState = "delete-complete"
	VpcBlockPublicAccessExclusionStateDisableInProgress VpcBlockPublicAccessExclusionState = "disable-in-progress"
	VpcBlockPublicAccessExclusionStateDisableComplete   VpcBlockPublicAccessExclusionState = "disable-complete"
)

// Values returns all known values for VpcBlockPublicAccessExclusionState. 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 (VpcBlockPublicAccessExclusionState) Values() []VpcBlockPublicAccessExclusionState {
	return []VpcBlockPublicAccessExclusionState{
		"create-in-progress",
		"create-complete",
		"create-failed",
		"update-in-progress",
		"update-complete",
		"update-failed",
		"delete-in-progress",
		"delete-complete",
		"disable-in-progress",
		"disable-complete",
	}
}

type VpcBlockPublicAccessState string

// Enum values for VpcBlockPublicAccessState
const (
	VpcBlockPublicAccessStateDefaultState     VpcBlockPublicAccessState = "default-state"
	VpcBlockPublicAccessStateUpdateInProgress VpcBlockPublicAccessState = "update-in-progress"
	VpcBlockPublicAccessStateUpdateComplete   VpcBlockPublicAccessState = "update-complete"
)

// Values returns all known values for VpcBlockPublicAccessState. 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 (VpcBlockPublicAccessState) Values() []VpcBlockPublicAccessState {
	return []VpcBlockPublicAccessState{
		"default-state",
		"update-in-progress",
		"update-complete",
	}
}

type VpcCidrBlockStateCode string

// Enum values for VpcCidrBlockStateCode
const (
	VpcCidrBlockStateCodeAssociating    VpcCidrBlockStateCode = "associating"
	VpcCidrBlockStateCodeAssociated     VpcCidrBlockStateCode = "associated"
	VpcCidrBlockStateCodeDisassociating VpcCidrBlockStateCode = "disassociating"
	VpcCidrBlockStateCodeDisassociated  VpcCidrBlockStateCode = "disassociated"
	VpcCidrBlockStateCodeFailing        VpcCidrBlockStateCode = "failing"
	VpcCidrBlockStateCodeFailed         VpcCidrBlockStateCode = "failed"
)

// Values returns all known values for VpcCidrBlockStateCode. 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 (VpcCidrBlockStateCode) Values() []VpcCidrBlockStateCode {
	return []VpcCidrBlockStateCode{
		"associating",
		"associated",
		"disassociating",
		"disassociated",
		"failing",
		"failed",
	}
}

type VpcEndpointType string

// Enum values for VpcEndpointType
const (
	VpcEndpointTypeInterface           VpcEndpointType = "Interface"
	VpcEndpointTypeGateway             VpcEndpointType = "Gateway"
	VpcEndpointTypeGatewayLoadBalancer VpcEndpointType = "GatewayLoadBalancer"
)

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

type VpcPeeringConnectionStateReasonCode string

// Enum values for VpcPeeringConnectionStateReasonCode
const (
	VpcPeeringConnectionStateReasonCodeInitiatingRequest VpcPeeringConnectionStateReasonCode = "initiating-request"
	VpcPeeringConnectionStateReasonCodePendingAcceptance VpcPeeringConnectionStateReasonCode = "pending-acceptance"
	VpcPeeringConnectionStateReasonCodeActive            VpcPeeringConnectionStateReasonCode = "active"
	VpcPeeringConnectionStateReasonCodeDeleted           VpcPeeringConnectionStateReasonCode = "deleted"
	VpcPeeringConnectionStateReasonCodeRejected          VpcPeeringConnectionStateReasonCode = "rejected"
	VpcPeeringConnectionStateReasonCodeFailed            VpcPeeringConnectionStateReasonCode = "failed"
	VpcPeeringConnectionStateReasonCodeExpired           VpcPeeringConnectionStateReasonCode = "expired"
	VpcPeeringConnectionStateReasonCodeProvisioning      VpcPeeringConnectionStateReasonCode = "provisioning"
	VpcPeeringConnectionStateReasonCodeDeleting          VpcPeeringConnectionStateReasonCode = "deleting"
)

// Values returns all known values for VpcPeeringConnectionStateReasonCode. 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 (VpcPeeringConnectionStateReasonCode) Values() []VpcPeeringConnectionStateReasonCode {
	return []VpcPeeringConnectionStateReasonCode{
		"initiating-request",
		"pending-acceptance",
		"active",
		"deleted",
		"rejected",
		"failed",
		"expired",
		"provisioning",
		"deleting",
	}
}

type VpcState string

// Enum values for VpcState
const (
	VpcStatePending   VpcState = "pending"
	VpcStateAvailable VpcState = "available"
)

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

type VpcTenancy string

// Enum values for VpcTenancy
const (
	VpcTenancyDefault VpcTenancy = "default"
)

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

type VpnEcmpSupportValue string

// Enum values for VpnEcmpSupportValue
const (
	VpnEcmpSupportValueEnable  VpnEcmpSupportValue = "enable"
	VpnEcmpSupportValueDisable VpnEcmpSupportValue = "disable"
)

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

type VpnProtocol string

// Enum values for VpnProtocol
const (
	VpnProtocolOpenvpn VpnProtocol = "openvpn"
)

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

type VpnState string

// Enum values for VpnState
const (
	VpnStatePending   VpnState = "pending"
	VpnStateAvailable VpnState = "available"
	VpnStateDeleting  VpnState = "deleting"
	VpnStateDeleted   VpnState = "deleted"
)

// Values returns all known values for VpnState. 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 (VpnState) Values() []VpnState {
	return []VpnState{
		"pending",
		"available",
		"deleting",
		"deleted",
	}
}

type VpnStaticRouteSource string

// Enum values for VpnStaticRouteSource
const (
	VpnStaticRouteSourceStatic VpnStaticRouteSource = "Static"
)

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

type WeekDay string

// Enum values for WeekDay
const (
	WeekDaySunday    WeekDay = "sunday"
	WeekDayMonday    WeekDay = "monday"
	WeekDayTuesday   WeekDay = "tuesday"
	WeekDayWednesday WeekDay = "wednesday"
	WeekDayThursday  WeekDay = "thursday"
	WeekDayFriday    WeekDay = "friday"
	WeekDaySaturday  WeekDay = "saturday"
)

// Values returns all known values for WeekDay. 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 (WeekDay) Values() []WeekDay {
	return []WeekDay{
		"sunday",
		"monday",
		"tuesday",
		"wednesday",
		"thursday",
		"friday",
		"saturday",
	}
}
