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

package types

type AcceleratorManufacturer string

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

// 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{
		"nvidia",
		"amd",
		"amazon-web-services",
		"xilinx",
	}
}

type AcceleratorName string

// Enum values for AcceleratorName
const (
	AcceleratorNameA100          AcceleratorName = "a100"
	AcceleratorNameV100          AcceleratorName = "v100"
	AcceleratorNameK80           AcceleratorName = "k80"
	AcceleratorNameT4            AcceleratorName = "t4"
	AcceleratorNameM60           AcceleratorName = "m60"
	AcceleratorNameRadeonProV520 AcceleratorName = "radeon-pro-v520"
	AcceleratorNameVu9p          AcceleratorName = "vu9p"
)

// 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",
		"v100",
		"k80",
		"t4",
		"m60",
		"radeon-pro-v520",
		"vu9p",
	}
}

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 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"
)

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

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 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"
)

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

type ArchitectureValues string

// Enum values for ArchitectureValues
const (
	ArchitectureValuesI386     ArchitectureValues = "i386"
	ArchitectureValuesX8664    ArchitectureValues = "x86_64"
	ArchitectureValuesArm64    ArchitectureValues = "arm64"
	ArchitectureValuesX8664Mac ArchitectureValues = "x86_64_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",
	}
}

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"
)

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

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 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"
)

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

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 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 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"
)

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

type CapacityReservationPreference string

// Enum values for CapacityReservationPreference
const (
	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{
		"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"
)

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

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 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"
)

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

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 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"
)

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

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 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 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 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 (
	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{
		"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"
)

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

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"
)

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

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 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 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"
)

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

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"
)

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

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 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 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 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 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"
)

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

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"
)

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

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 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 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"
)

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

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 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 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"
)

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

type LogDestinationType string

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

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

type MarketType string

// Enum values for MarketType
const (
	MarketTypeSpot MarketType = "spot"
)

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

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 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 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"
)

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

type NetworkInterfaceCreationType string

// Enum values for NetworkInterfaceCreationType
const (
	NetworkInterfaceCreationTypeEfa    NetworkInterfaceCreationType = "efa"
	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",
		"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"
	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",
		"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 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 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 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"
	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"
	ResourceTypeVpcEndpointService                                     ResourceType = "vpc-endpoint-service"
	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"
)

// 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",
		"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-service",
		"vpc-peering-connection",
		"vpn-connection",
		"vpn-gateway",
		"vpc-flow-log",
		"capacity-reservation-fleet",
		"traffic-mirror-filter-rule",
		"vpc-endpoint-connection-device-type",
	}
}

type RIProductDescription string

// 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 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 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"
)

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

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"
)

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

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 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 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"
)

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

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 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 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 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"
)

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

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"
)

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

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",
	}
}
