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

package types

type AccessDirection string

// Enum values for AccessDirection
const (
	AccessDirectionInbound  AccessDirection = "inbound"
	AccessDirectionOutbound AccessDirection = "outbound"
)

// Values returns all known values for AccessDirection. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (AccessDirection) Values() []AccessDirection {
	return []AccessDirection{
		"inbound",
		"outbound",
	}
}

type AccessType string

// Enum values for AccessType
const (
	AccessTypePublic  AccessType = "public"
	AccessTypePrivate AccessType = "private"
)

// Values returns all known values for AccessType. Note that this can be expanded
// in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (AccessType) Values() []AccessType {
	return []AccessType{
		"public",
		"private",
	}
}

type AccountLevelBpaSyncStatus string

// Enum values for AccountLevelBpaSyncStatus
const (
	AccountLevelBpaSyncStatusInSync      AccountLevelBpaSyncStatus = "InSync"
	AccountLevelBpaSyncStatusFailed      AccountLevelBpaSyncStatus = "Failed"
	AccountLevelBpaSyncStatusNeverSynced AccountLevelBpaSyncStatus = "NeverSynced"
	AccountLevelBpaSyncStatusDefaulted   AccountLevelBpaSyncStatus = "Defaulted"
)

// Values returns all known values for AccountLevelBpaSyncStatus. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (AccountLevelBpaSyncStatus) Values() []AccountLevelBpaSyncStatus {
	return []AccountLevelBpaSyncStatus{
		"InSync",
		"Failed",
		"NeverSynced",
		"Defaulted",
	}
}

type AddOnType string

// Enum values for AddOnType
const (
	AddOnTypeAutoSnapshot       AddOnType = "AutoSnapshot"
	AddOnTypeStopInstanceOnIdle AddOnType = "StopInstanceOnIdle"
)

// Values returns all known values for AddOnType. Note that this can be expanded
// in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (AddOnType) Values() []AddOnType {
	return []AddOnType{
		"AutoSnapshot",
		"StopInstanceOnIdle",
	}
}

type AlarmState string

// Enum values for AlarmState
const (
	AlarmStateOk               AlarmState = "OK"
	AlarmStateAlarm            AlarmState = "ALARM"
	AlarmStateInsufficientData AlarmState = "INSUFFICIENT_DATA"
)

// Values returns all known values for AlarmState. Note that this can be expanded
// in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (AlarmState) Values() []AlarmState {
	return []AlarmState{
		"OK",
		"ALARM",
		"INSUFFICIENT_DATA",
	}
}

type AppCategory string

// Enum values for AppCategory
const (
	AppCategoryLfR AppCategory = "LfR"
)

// Values returns all known values for AppCategory. Note that this can be expanded
// in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (AppCategory) Values() []AppCategory {
	return []AppCategory{
		"LfR",
	}
}

type AutoMountStatus string

// Enum values for AutoMountStatus
const (
	AutoMountStatusFailed     AutoMountStatus = "Failed"
	AutoMountStatusPending    AutoMountStatus = "Pending"
	AutoMountStatusMounted    AutoMountStatus = "Mounted"
	AutoMountStatusNotMounted AutoMountStatus = "NotMounted"
)

// Values returns all known values for AutoMountStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (AutoMountStatus) Values() []AutoMountStatus {
	return []AutoMountStatus{
		"Failed",
		"Pending",
		"Mounted",
		"NotMounted",
	}
}

type AutoSnapshotStatus string

// Enum values for AutoSnapshotStatus
const (
	AutoSnapshotStatusSuccess    AutoSnapshotStatus = "Success"
	AutoSnapshotStatusFailed     AutoSnapshotStatus = "Failed"
	AutoSnapshotStatusInProgress AutoSnapshotStatus = "InProgress"
	AutoSnapshotStatusNotFound   AutoSnapshotStatus = "NotFound"
)

// Values returns all known values for AutoSnapshotStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (AutoSnapshotStatus) Values() []AutoSnapshotStatus {
	return []AutoSnapshotStatus{
		"Success",
		"Failed",
		"InProgress",
		"NotFound",
	}
}

type BehaviorEnum string

// Enum values for BehaviorEnum
const (
	BehaviorEnumDontCacheSetting BehaviorEnum = "dont-cache"
	BehaviorEnumCacheSetting     BehaviorEnum = "cache"
)

// Values returns all known values for BehaviorEnum. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (BehaviorEnum) Values() []BehaviorEnum {
	return []BehaviorEnum{
		"dont-cache",
		"cache",
	}
}

type BlueprintType string

// Enum values for BlueprintType
const (
	BlueprintTypeOs  BlueprintType = "os"
	BlueprintTypeApp BlueprintType = "app"
)

// Values returns all known values for BlueprintType. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (BlueprintType) Values() []BlueprintType {
	return []BlueprintType{
		"os",
		"app",
	}
}

type BPAStatusMessage string

// Enum values for BPAStatusMessage
const (
	BPAStatusMessageDefaultedForSlrMissing       BPAStatusMessage = "DEFAULTED_FOR_SLR_MISSING"
	BPAStatusMessageSyncOnHold                   BPAStatusMessage = "SYNC_ON_HOLD"
	BPAStatusMessageDefaultedForSlrMissingOnHold BPAStatusMessage = "DEFAULTED_FOR_SLR_MISSING_ON_HOLD"
	BPAStatusMessageUnknown                      BPAStatusMessage = "Unknown"
)

// Values returns all known values for BPAStatusMessage. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (BPAStatusMessage) Values() []BPAStatusMessage {
	return []BPAStatusMessage{
		"DEFAULTED_FOR_SLR_MISSING",
		"SYNC_ON_HOLD",
		"DEFAULTED_FOR_SLR_MISSING_ON_HOLD",
		"Unknown",
	}
}

type BucketMetricName string

// Enum values for BucketMetricName
const (
	BucketMetricNameBucketSizeBytes BucketMetricName = "BucketSizeBytes"
	BucketMetricNameNumberOfObjects BucketMetricName = "NumberOfObjects"
)

// Values returns all known values for BucketMetricName. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (BucketMetricName) Values() []BucketMetricName {
	return []BucketMetricName{
		"BucketSizeBytes",
		"NumberOfObjects",
	}
}

type CertificateDomainValidationStatus string

// Enum values for CertificateDomainValidationStatus
const (
	CertificateDomainValidationStatusPendingValidation CertificateDomainValidationStatus = "PENDING_VALIDATION"
	CertificateDomainValidationStatusFailed            CertificateDomainValidationStatus = "FAILED"
	CertificateDomainValidationStatusSuccess           CertificateDomainValidationStatus = "SUCCESS"
)

// Values returns all known values for CertificateDomainValidationStatus. Note
// that this can be expanded in the future, and so it is only as up to date as the
// client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (CertificateDomainValidationStatus) Values() []CertificateDomainValidationStatus {
	return []CertificateDomainValidationStatus{
		"PENDING_VALIDATION",
		"FAILED",
		"SUCCESS",
	}
}

type CertificateProvider string

// Enum values for CertificateProvider
const (
	CertificateProviderLetsEncrypt CertificateProvider = "LetsEncrypt"
)

// Values returns all known values for CertificateProvider. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (CertificateProvider) Values() []CertificateProvider {
	return []CertificateProvider{
		"LetsEncrypt",
	}
}

type CertificateStatus string

// Enum values for CertificateStatus
const (
	CertificateStatusPendingValidation  CertificateStatus = "PENDING_VALIDATION"
	CertificateStatusIssued             CertificateStatus = "ISSUED"
	CertificateStatusInactive           CertificateStatus = "INACTIVE"
	CertificateStatusExpired            CertificateStatus = "EXPIRED"
	CertificateStatusValidationTimedOut CertificateStatus = "VALIDATION_TIMED_OUT"
	CertificateStatusRevoked            CertificateStatus = "REVOKED"
	CertificateStatusFailed             CertificateStatus = "FAILED"
)

// Values returns all known values for CertificateStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (CertificateStatus) Values() []CertificateStatus {
	return []CertificateStatus{
		"PENDING_VALIDATION",
		"ISSUED",
		"INACTIVE",
		"EXPIRED",
		"VALIDATION_TIMED_OUT",
		"REVOKED",
		"FAILED",
	}
}

type CloudFormationStackRecordSourceType string

// Enum values for CloudFormationStackRecordSourceType
const (
	CloudFormationStackRecordSourceTypeExportSnapshotRecord CloudFormationStackRecordSourceType = "ExportSnapshotRecord"
)

// Values returns all known values for CloudFormationStackRecordSourceType. Note
// that this can be expanded in the future, and so it is only as up to date as the
// client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (CloudFormationStackRecordSourceType) Values() []CloudFormationStackRecordSourceType {
	return []CloudFormationStackRecordSourceType{
		"ExportSnapshotRecord",
	}
}

type ComparisonOperator string

// Enum values for ComparisonOperator
const (
	ComparisonOperatorGreaterThanOrEqualToThreshold ComparisonOperator = "GreaterThanOrEqualToThreshold"
	ComparisonOperatorGreaterThanThreshold          ComparisonOperator = "GreaterThanThreshold"
	ComparisonOperatorLessThanThreshold             ComparisonOperator = "LessThanThreshold"
	ComparisonOperatorLessThanOrEqualToThreshold    ComparisonOperator = "LessThanOrEqualToThreshold"
)

// Values returns all known values for ComparisonOperator. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (ComparisonOperator) Values() []ComparisonOperator {
	return []ComparisonOperator{
		"GreaterThanOrEqualToThreshold",
		"GreaterThanThreshold",
		"LessThanThreshold",
		"LessThanOrEqualToThreshold",
	}
}

type ContactMethodStatus string

// Enum values for ContactMethodStatus
const (
	ContactMethodStatusPendingVerification ContactMethodStatus = "PendingVerification"
	ContactMethodStatusValid               ContactMethodStatus = "Valid"
	ContactMethodStatusInvalid             ContactMethodStatus = "Invalid"
)

// Values returns all known values for ContactMethodStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (ContactMethodStatus) Values() []ContactMethodStatus {
	return []ContactMethodStatus{
		"PendingVerification",
		"Valid",
		"Invalid",
	}
}

type ContactMethodVerificationProtocol string

// Enum values for ContactMethodVerificationProtocol
const (
	ContactMethodVerificationProtocolEmail ContactMethodVerificationProtocol = "Email"
)

// Values returns all known values for ContactMethodVerificationProtocol. Note
// that this can be expanded in the future, and so it is only as up to date as the
// client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (ContactMethodVerificationProtocol) Values() []ContactMethodVerificationProtocol {
	return []ContactMethodVerificationProtocol{
		"Email",
	}
}

type ContactProtocol string

// Enum values for ContactProtocol
const (
	ContactProtocolEmail ContactProtocol = "Email"
	ContactProtocolSms   ContactProtocol = "SMS"
)

// Values returns all known values for ContactProtocol. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (ContactProtocol) Values() []ContactProtocol {
	return []ContactProtocol{
		"Email",
		"SMS",
	}
}

type ContainerServiceDeploymentState string

// Enum values for ContainerServiceDeploymentState
const (
	ContainerServiceDeploymentStateActivating ContainerServiceDeploymentState = "ACTIVATING"
	ContainerServiceDeploymentStateActive     ContainerServiceDeploymentState = "ACTIVE"
	ContainerServiceDeploymentStateInactive   ContainerServiceDeploymentState = "INACTIVE"
	ContainerServiceDeploymentStateFailed     ContainerServiceDeploymentState = "FAILED"
)

// Values returns all known values for ContainerServiceDeploymentState. Note that
// this can be expanded in the future, and so it is only as up to date as the
// client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (ContainerServiceDeploymentState) Values() []ContainerServiceDeploymentState {
	return []ContainerServiceDeploymentState{
		"ACTIVATING",
		"ACTIVE",
		"INACTIVE",
		"FAILED",
	}
}

type ContainerServiceMetricName string

// Enum values for ContainerServiceMetricName
const (
	ContainerServiceMetricNameCPUUtilization    ContainerServiceMetricName = "CPUUtilization"
	ContainerServiceMetricNameMemoryUtilization ContainerServiceMetricName = "MemoryUtilization"
)

// Values returns all known values for ContainerServiceMetricName. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (ContainerServiceMetricName) Values() []ContainerServiceMetricName {
	return []ContainerServiceMetricName{
		"CPUUtilization",
		"MemoryUtilization",
	}
}

type ContainerServicePowerName string

// Enum values for ContainerServicePowerName
const (
	ContainerServicePowerNameNano   ContainerServicePowerName = "nano"
	ContainerServicePowerNameMicro  ContainerServicePowerName = "micro"
	ContainerServicePowerNameSmall  ContainerServicePowerName = "small"
	ContainerServicePowerNameMedium ContainerServicePowerName = "medium"
	ContainerServicePowerNameLarge  ContainerServicePowerName = "large"
	ContainerServicePowerNameXlarge ContainerServicePowerName = "xlarge"
)

// Values returns all known values for ContainerServicePowerName. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (ContainerServicePowerName) Values() []ContainerServicePowerName {
	return []ContainerServicePowerName{
		"nano",
		"micro",
		"small",
		"medium",
		"large",
		"xlarge",
	}
}

type ContainerServiceProtocol string

// Enum values for ContainerServiceProtocol
const (
	ContainerServiceProtocolHttp  ContainerServiceProtocol = "HTTP"
	ContainerServiceProtocolHttps ContainerServiceProtocol = "HTTPS"
	ContainerServiceProtocolTcp   ContainerServiceProtocol = "TCP"
	ContainerServiceProtocolUdp   ContainerServiceProtocol = "UDP"
)

// Values returns all known values for ContainerServiceProtocol. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (ContainerServiceProtocol) Values() []ContainerServiceProtocol {
	return []ContainerServiceProtocol{
		"HTTP",
		"HTTPS",
		"TCP",
		"UDP",
	}
}

type ContainerServiceState string

// Enum values for ContainerServiceState
const (
	ContainerServiceStatePending   ContainerServiceState = "PENDING"
	ContainerServiceStateReady     ContainerServiceState = "READY"
	ContainerServiceStateRunning   ContainerServiceState = "RUNNING"
	ContainerServiceStateUpdating  ContainerServiceState = "UPDATING"
	ContainerServiceStateDeleting  ContainerServiceState = "DELETING"
	ContainerServiceStateDisabled  ContainerServiceState = "DISABLED"
	ContainerServiceStateDeploying ContainerServiceState = "DEPLOYING"
)

// Values returns all known values for ContainerServiceState. Note that this can
// be expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (ContainerServiceState) Values() []ContainerServiceState {
	return []ContainerServiceState{
		"PENDING",
		"READY",
		"RUNNING",
		"UPDATING",
		"DELETING",
		"DISABLED",
		"DEPLOYING",
	}
}

type ContainerServiceStateDetailCode string

// Enum values for ContainerServiceStateDetailCode
const (
	ContainerServiceStateDetailCodeCreatingSystemResources       ContainerServiceStateDetailCode = "CREATING_SYSTEM_RESOURCES"
	ContainerServiceStateDetailCodeCreatingNetworkInfrastructure ContainerServiceStateDetailCode = "CREATING_NETWORK_INFRASTRUCTURE"
	ContainerServiceStateDetailCodeProvisioningCertificate       ContainerServiceStateDetailCode = "PROVISIONING_CERTIFICATE"
	ContainerServiceStateDetailCodeProvisioningService           ContainerServiceStateDetailCode = "PROVISIONING_SERVICE"
	ContainerServiceStateDetailCodeCreatingDeployment            ContainerServiceStateDetailCode = "CREATING_DEPLOYMENT"
	ContainerServiceStateDetailCodeEvaluatingHealthCheck         ContainerServiceStateDetailCode = "EVALUATING_HEALTH_CHECK"
	ContainerServiceStateDetailCodeActivatingDeployment          ContainerServiceStateDetailCode = "ACTIVATING_DEPLOYMENT"
	ContainerServiceStateDetailCodeCertificateLimitExceeded      ContainerServiceStateDetailCode = "CERTIFICATE_LIMIT_EXCEEDED"
	ContainerServiceStateDetailCodeUnknownError                  ContainerServiceStateDetailCode = "UNKNOWN_ERROR"
)

// Values returns all known values for ContainerServiceStateDetailCode. Note that
// this can be expanded in the future, and so it is only as up to date as the
// client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (ContainerServiceStateDetailCode) Values() []ContainerServiceStateDetailCode {
	return []ContainerServiceStateDetailCode{
		"CREATING_SYSTEM_RESOURCES",
		"CREATING_NETWORK_INFRASTRUCTURE",
		"PROVISIONING_CERTIFICATE",
		"PROVISIONING_SERVICE",
		"CREATING_DEPLOYMENT",
		"EVALUATING_HEALTH_CHECK",
		"ACTIVATING_DEPLOYMENT",
		"CERTIFICATE_LIMIT_EXCEEDED",
		"UNKNOWN_ERROR",
	}
}

type Currency string

// Enum values for Currency
const (
	CurrencyUsd Currency = "USD"
)

// Values returns all known values for Currency. Note that this can be expanded in
// the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (Currency) Values() []Currency {
	return []Currency{
		"USD",
	}
}

type DiskSnapshotState string

// Enum values for DiskSnapshotState
const (
	DiskSnapshotStatePending   DiskSnapshotState = "pending"
	DiskSnapshotStateCompleted DiskSnapshotState = "completed"
	DiskSnapshotStateError     DiskSnapshotState = "error"
	DiskSnapshotStateUnknown   DiskSnapshotState = "unknown"
)

// Values returns all known values for DiskSnapshotState. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (DiskSnapshotState) Values() []DiskSnapshotState {
	return []DiskSnapshotState{
		"pending",
		"completed",
		"error",
		"unknown",
	}
}

type DiskState string

// Enum values for DiskState
const (
	DiskStatePending   DiskState = "pending"
	DiskStateError     DiskState = "error"
	DiskStateAvailable DiskState = "available"
	DiskStateInUse     DiskState = "in-use"
	DiskStateUnknown   DiskState = "unknown"
)

// Values returns all known values for DiskState. Note that this can be expanded
// in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (DiskState) Values() []DiskState {
	return []DiskState{
		"pending",
		"error",
		"available",
		"in-use",
		"unknown",
	}
}

type DistributionMetricName string

// Enum values for DistributionMetricName
const (
	DistributionMetricNameRequests         DistributionMetricName = "Requests"
	DistributionMetricNameBytesDownloaded  DistributionMetricName = "BytesDownloaded"
	DistributionMetricNameBytesUploaded    DistributionMetricName = "BytesUploaded"
	DistributionMetricNameTotalErrorRate   DistributionMetricName = "TotalErrorRate"
	DistributionMetricNameHttp4xxErrorRate DistributionMetricName = "Http4xxErrorRate"
	DistributionMetricNameHttp5xxErrorRate DistributionMetricName = "Http5xxErrorRate"
)

// Values returns all known values for DistributionMetricName. Note that this can
// be expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (DistributionMetricName) Values() []DistributionMetricName {
	return []DistributionMetricName{
		"Requests",
		"BytesDownloaded",
		"BytesUploaded",
		"TotalErrorRate",
		"Http4xxErrorRate",
		"Http5xxErrorRate",
	}
}

type DnsRecordCreationStateCode string

// Enum values for DnsRecordCreationStateCode
const (
	DnsRecordCreationStateCodeSucceeded DnsRecordCreationStateCode = "SUCCEEDED"
	DnsRecordCreationStateCodeStarted   DnsRecordCreationStateCode = "STARTED"
	DnsRecordCreationStateCodeFailed    DnsRecordCreationStateCode = "FAILED"
)

// Values returns all known values for DnsRecordCreationStateCode. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (DnsRecordCreationStateCode) Values() []DnsRecordCreationStateCode {
	return []DnsRecordCreationStateCode{
		"SUCCEEDED",
		"STARTED",
		"FAILED",
	}
}

type ExportSnapshotRecordSourceType string

// Enum values for ExportSnapshotRecordSourceType
const (
	ExportSnapshotRecordSourceTypeInstanceSnapshot ExportSnapshotRecordSourceType = "InstanceSnapshot"
	ExportSnapshotRecordSourceTypeDiskSnapshot     ExportSnapshotRecordSourceType = "DiskSnapshot"
)

// Values returns all known values for ExportSnapshotRecordSourceType. Note that
// this can be expanded in the future, and so it is only as up to date as the
// client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (ExportSnapshotRecordSourceType) Values() []ExportSnapshotRecordSourceType {
	return []ExportSnapshotRecordSourceType{
		"InstanceSnapshot",
		"DiskSnapshot",
	}
}

type ForwardValues string

// Enum values for ForwardValues
const (
	ForwardValuesNone      ForwardValues = "none"
	ForwardValuesAllowList ForwardValues = "allow-list"
	ForwardValuesAll       ForwardValues = "all"
)

// Values returns all known values for ForwardValues. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (ForwardValues) Values() []ForwardValues {
	return []ForwardValues{
		"none",
		"allow-list",
		"all",
	}
}

type HeaderEnum string

// Enum values for HeaderEnum
const (
	HeaderEnumAccept                    HeaderEnum = "Accept"
	HeaderEnumAcceptCharset             HeaderEnum = "Accept-Charset"
	HeaderEnumAcceptDatetime            HeaderEnum = "Accept-Datetime"
	HeaderEnumAcceptEncoding            HeaderEnum = "Accept-Encoding"
	HeaderEnumAcceptLanguage            HeaderEnum = "Accept-Language"
	HeaderEnumAuthorization             HeaderEnum = "Authorization"
	HeaderEnumCloudFrontForwardedProto  HeaderEnum = "CloudFront-Forwarded-Proto"
	HeaderEnumCloudFrontIsDesktopViewer HeaderEnum = "CloudFront-Is-Desktop-Viewer"
	HeaderEnumCloudFrontIsMobileViewer  HeaderEnum = "CloudFront-Is-Mobile-Viewer"
	HeaderEnumCloudFrontIsSmartTVViewer HeaderEnum = "CloudFront-Is-SmartTV-Viewer"
	HeaderEnumCloudFrontIsTabletViewer  HeaderEnum = "CloudFront-Is-Tablet-Viewer"
	HeaderEnumCloudFrontViewerCountry   HeaderEnum = "CloudFront-Viewer-Country"
	HeaderEnumHost                      HeaderEnum = "Host"
	HeaderEnumOrigin                    HeaderEnum = "Origin"
	HeaderEnumReferer                   HeaderEnum = "Referer"
)

// Values returns all known values for HeaderEnum. Note that this can be expanded
// in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (HeaderEnum) Values() []HeaderEnum {
	return []HeaderEnum{
		"Accept",
		"Accept-Charset",
		"Accept-Datetime",
		"Accept-Encoding",
		"Accept-Language",
		"Authorization",
		"CloudFront-Forwarded-Proto",
		"CloudFront-Is-Desktop-Viewer",
		"CloudFront-Is-Mobile-Viewer",
		"CloudFront-Is-SmartTV-Viewer",
		"CloudFront-Is-Tablet-Viewer",
		"CloudFront-Viewer-Country",
		"Host",
		"Origin",
		"Referer",
	}
}

type HttpEndpoint string

// Enum values for HttpEndpoint
const (
	HttpEndpointDisabled HttpEndpoint = "disabled"
	HttpEndpointEnabled  HttpEndpoint = "enabled"
)

// Values returns all known values for HttpEndpoint. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (HttpEndpoint) Values() []HttpEndpoint {
	return []HttpEndpoint{
		"disabled",
		"enabled",
	}
}

type HttpProtocolIpv6 string

// Enum values for HttpProtocolIpv6
const (
	HttpProtocolIpv6Disabled HttpProtocolIpv6 = "disabled"
	HttpProtocolIpv6Enabled  HttpProtocolIpv6 = "enabled"
)

// Values returns all known values for HttpProtocolIpv6. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (HttpProtocolIpv6) Values() []HttpProtocolIpv6 {
	return []HttpProtocolIpv6{
		"disabled",
		"enabled",
	}
}

type HttpTokens string

// Enum values for HttpTokens
const (
	HttpTokensOptional HttpTokens = "optional"
	HttpTokensRequired HttpTokens = "required"
)

// Values returns all known values for HttpTokens. Note that this can be expanded
// in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (HttpTokens) Values() []HttpTokens {
	return []HttpTokens{
		"optional",
		"required",
	}
}

type InstanceAccessProtocol string

// Enum values for InstanceAccessProtocol
const (
	InstanceAccessProtocolSsh InstanceAccessProtocol = "ssh"
	InstanceAccessProtocolRdp InstanceAccessProtocol = "rdp"
)

// Values returns all known values for InstanceAccessProtocol. Note that this can
// be expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (InstanceAccessProtocol) Values() []InstanceAccessProtocol {
	return []InstanceAccessProtocol{
		"ssh",
		"rdp",
	}
}

type InstanceHealthReason string

// Enum values for InstanceHealthReason
const (
	InstanceHealthReasonLbRegistrationInProgress         InstanceHealthReason = "Lb.RegistrationInProgress"
	InstanceHealthReasonLbInitialHealthChecking          InstanceHealthReason = "Lb.InitialHealthChecking"
	InstanceHealthReasonLbInternalError                  InstanceHealthReason = "Lb.InternalError"
	InstanceHealthReasonInstanceResponseCodeMismatch     InstanceHealthReason = "Instance.ResponseCodeMismatch"
	InstanceHealthReasonInstanceTimeout                  InstanceHealthReason = "Instance.Timeout"
	InstanceHealthReasonInstanceFailedHealthChecks       InstanceHealthReason = "Instance.FailedHealthChecks"
	InstanceHealthReasonInstanceNotRegistered            InstanceHealthReason = "Instance.NotRegistered"
	InstanceHealthReasonInstanceNotInUse                 InstanceHealthReason = "Instance.NotInUse"
	InstanceHealthReasonInstanceDeregistrationInProgress InstanceHealthReason = "Instance.DeregistrationInProgress"
	InstanceHealthReasonInstanceInvalidState             InstanceHealthReason = "Instance.InvalidState"
	InstanceHealthReasonInstanceIpUnusable               InstanceHealthReason = "Instance.IpUnusable"
)

// Values returns all known values for InstanceHealthReason. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (InstanceHealthReason) Values() []InstanceHealthReason {
	return []InstanceHealthReason{
		"Lb.RegistrationInProgress",
		"Lb.InitialHealthChecking",
		"Lb.InternalError",
		"Instance.ResponseCodeMismatch",
		"Instance.Timeout",
		"Instance.FailedHealthChecks",
		"Instance.NotRegistered",
		"Instance.NotInUse",
		"Instance.DeregistrationInProgress",
		"Instance.InvalidState",
		"Instance.IpUnusable",
	}
}

type InstanceHealthState string

// Enum values for InstanceHealthState
const (
	InstanceHealthStateInitial     InstanceHealthState = "initial"
	InstanceHealthStateHealthy     InstanceHealthState = "healthy"
	InstanceHealthStateUnhealthy   InstanceHealthState = "unhealthy"
	InstanceHealthStateUnused      InstanceHealthState = "unused"
	InstanceHealthStateDraining    InstanceHealthState = "draining"
	InstanceHealthStateUnavailable InstanceHealthState = "unavailable"
)

// Values returns all known values for InstanceHealthState. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (InstanceHealthState) Values() []InstanceHealthState {
	return []InstanceHealthState{
		"initial",
		"healthy",
		"unhealthy",
		"unused",
		"draining",
		"unavailable",
	}
}

type InstanceMetadataState string

// Enum values for InstanceMetadataState
const (
	InstanceMetadataStatePending InstanceMetadataState = "pending"
	InstanceMetadataStateApplied InstanceMetadataState = "applied"
)

// Values returns all known values for InstanceMetadataState. Note that this can
// be expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (InstanceMetadataState) Values() []InstanceMetadataState {
	return []InstanceMetadataState{
		"pending",
		"applied",
	}
}

type InstanceMetricName string

// Enum values for InstanceMetricName
const (
	InstanceMetricNameCPUUtilization            InstanceMetricName = "CPUUtilization"
	InstanceMetricNameNetworkIn                 InstanceMetricName = "NetworkIn"
	InstanceMetricNameNetworkOut                InstanceMetricName = "NetworkOut"
	InstanceMetricNameStatusCheckFailed         InstanceMetricName = "StatusCheckFailed"
	InstanceMetricNameStatusCheckFailedInstance InstanceMetricName = "StatusCheckFailed_Instance"
	InstanceMetricNameStatusCheckFailedSystem   InstanceMetricName = "StatusCheckFailed_System"
	InstanceMetricNameBurstCapacityTime         InstanceMetricName = "BurstCapacityTime"
	InstanceMetricNameBurstCapacityPercentage   InstanceMetricName = "BurstCapacityPercentage"
	InstanceMetricNameMetadataNoToken           InstanceMetricName = "MetadataNoToken"
)

// Values returns all known values for InstanceMetricName. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (InstanceMetricName) Values() []InstanceMetricName {
	return []InstanceMetricName{
		"CPUUtilization",
		"NetworkIn",
		"NetworkOut",
		"StatusCheckFailed",
		"StatusCheckFailed_Instance",
		"StatusCheckFailed_System",
		"BurstCapacityTime",
		"BurstCapacityPercentage",
		"MetadataNoToken",
	}
}

type InstancePlatform string

// Enum values for InstancePlatform
const (
	InstancePlatformLinuxUnix InstancePlatform = "LINUX_UNIX"
	InstancePlatformWindows   InstancePlatform = "WINDOWS"
)

// Values returns all known values for InstancePlatform. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (InstancePlatform) Values() []InstancePlatform {
	return []InstancePlatform{
		"LINUX_UNIX",
		"WINDOWS",
	}
}

type InstanceSnapshotState string

// Enum values for InstanceSnapshotState
const (
	InstanceSnapshotStatePending   InstanceSnapshotState = "pending"
	InstanceSnapshotStateError     InstanceSnapshotState = "error"
	InstanceSnapshotStateAvailable InstanceSnapshotState = "available"
)

// Values returns all known values for InstanceSnapshotState. Note that this can
// be expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (InstanceSnapshotState) Values() []InstanceSnapshotState {
	return []InstanceSnapshotState{
		"pending",
		"error",
		"available",
	}
}

type IpAddressType string

// Enum values for IpAddressType
const (
	IpAddressTypeDualstack IpAddressType = "dualstack"
	IpAddressTypeIpv4      IpAddressType = "ipv4"
	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{
		"dualstack",
		"ipv4",
		"ipv6",
	}
}

type LoadBalancerAttributeName string

// Enum values for LoadBalancerAttributeName
const (
	LoadBalancerAttributeNameHealthCheckPath                          LoadBalancerAttributeName = "HealthCheckPath"
	LoadBalancerAttributeNameSessionStickinessEnabled                 LoadBalancerAttributeName = "SessionStickinessEnabled"
	LoadBalancerAttributeNameSessionStickinessLbCookieDurationSeconds LoadBalancerAttributeName = "SessionStickiness_LB_CookieDurationSeconds"
	LoadBalancerAttributeNameHttpsRedirectionEnabled                  LoadBalancerAttributeName = "HttpsRedirectionEnabled"
	LoadBalancerAttributeNameTlsPolicyName                            LoadBalancerAttributeName = "TlsPolicyName"
)

// Values returns all known values for LoadBalancerAttributeName. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (LoadBalancerAttributeName) Values() []LoadBalancerAttributeName {
	return []LoadBalancerAttributeName{
		"HealthCheckPath",
		"SessionStickinessEnabled",
		"SessionStickiness_LB_CookieDurationSeconds",
		"HttpsRedirectionEnabled",
		"TlsPolicyName",
	}
}

type LoadBalancerMetricName string

// Enum values for LoadBalancerMetricName
const (
	LoadBalancerMetricNameClientTLSNegotiationErrorCount LoadBalancerMetricName = "ClientTLSNegotiationErrorCount"
	LoadBalancerMetricNameHealthyHostCount               LoadBalancerMetricName = "HealthyHostCount"
	LoadBalancerMetricNameUnhealthyHostCount             LoadBalancerMetricName = "UnhealthyHostCount"
	LoadBalancerMetricNameHTTPCodeLb4xxCount             LoadBalancerMetricName = "HTTPCode_LB_4XX_Count"
	LoadBalancerMetricNameHTTPCodeLb5xxCount             LoadBalancerMetricName = "HTTPCode_LB_5XX_Count"
	LoadBalancerMetricNameHTTPCodeInstance2xxCount       LoadBalancerMetricName = "HTTPCode_Instance_2XX_Count"
	LoadBalancerMetricNameHTTPCodeInstance3xxCount       LoadBalancerMetricName = "HTTPCode_Instance_3XX_Count"
	LoadBalancerMetricNameHTTPCodeInstance4xxCount       LoadBalancerMetricName = "HTTPCode_Instance_4XX_Count"
	LoadBalancerMetricNameHTTPCodeInstance5xxCount       LoadBalancerMetricName = "HTTPCode_Instance_5XX_Count"
	LoadBalancerMetricNameInstanceResponseTime           LoadBalancerMetricName = "InstanceResponseTime"
	LoadBalancerMetricNameRejectedConnectionCount        LoadBalancerMetricName = "RejectedConnectionCount"
	LoadBalancerMetricNameRequestCount                   LoadBalancerMetricName = "RequestCount"
)

// Values returns all known values for LoadBalancerMetricName. Note that this can
// be expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (LoadBalancerMetricName) Values() []LoadBalancerMetricName {
	return []LoadBalancerMetricName{
		"ClientTLSNegotiationErrorCount",
		"HealthyHostCount",
		"UnhealthyHostCount",
		"HTTPCode_LB_4XX_Count",
		"HTTPCode_LB_5XX_Count",
		"HTTPCode_Instance_2XX_Count",
		"HTTPCode_Instance_3XX_Count",
		"HTTPCode_Instance_4XX_Count",
		"HTTPCode_Instance_5XX_Count",
		"InstanceResponseTime",
		"RejectedConnectionCount",
		"RequestCount",
	}
}

type LoadBalancerProtocol string

// Enum values for LoadBalancerProtocol
const (
	LoadBalancerProtocolHttpHttps LoadBalancerProtocol = "HTTP_HTTPS"
	LoadBalancerProtocolHttp      LoadBalancerProtocol = "HTTP"
)

// Values returns all known values for LoadBalancerProtocol. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (LoadBalancerProtocol) Values() []LoadBalancerProtocol {
	return []LoadBalancerProtocol{
		"HTTP_HTTPS",
		"HTTP",
	}
}

type LoadBalancerState string

// Enum values for LoadBalancerState
const (
	LoadBalancerStateActive         LoadBalancerState = "active"
	LoadBalancerStateProvisioning   LoadBalancerState = "provisioning"
	LoadBalancerStateActiveImpaired LoadBalancerState = "active_impaired"
	LoadBalancerStateFailed         LoadBalancerState = "failed"
	LoadBalancerStateUnknown        LoadBalancerState = "unknown"
)

// Values returns all known values for LoadBalancerState. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (LoadBalancerState) Values() []LoadBalancerState {
	return []LoadBalancerState{
		"active",
		"provisioning",
		"active_impaired",
		"failed",
		"unknown",
	}
}

type LoadBalancerTlsCertificateDnsRecordCreationStateCode string

// Enum values for LoadBalancerTlsCertificateDnsRecordCreationStateCode
const (
	LoadBalancerTlsCertificateDnsRecordCreationStateCodeSucceeded LoadBalancerTlsCertificateDnsRecordCreationStateCode = "SUCCEEDED"
	LoadBalancerTlsCertificateDnsRecordCreationStateCodeStarted   LoadBalancerTlsCertificateDnsRecordCreationStateCode = "STARTED"
	LoadBalancerTlsCertificateDnsRecordCreationStateCodeFailed    LoadBalancerTlsCertificateDnsRecordCreationStateCode = "FAILED"
)

// Values returns all known values for
// LoadBalancerTlsCertificateDnsRecordCreationStateCode. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (LoadBalancerTlsCertificateDnsRecordCreationStateCode) Values() []LoadBalancerTlsCertificateDnsRecordCreationStateCode {
	return []LoadBalancerTlsCertificateDnsRecordCreationStateCode{
		"SUCCEEDED",
		"STARTED",
		"FAILED",
	}
}

type LoadBalancerTlsCertificateDomainStatus string

// Enum values for LoadBalancerTlsCertificateDomainStatus
const (
	LoadBalancerTlsCertificateDomainStatusPendingValidation LoadBalancerTlsCertificateDomainStatus = "PENDING_VALIDATION"
	LoadBalancerTlsCertificateDomainStatusFailed            LoadBalancerTlsCertificateDomainStatus = "FAILED"
	LoadBalancerTlsCertificateDomainStatusSuccess           LoadBalancerTlsCertificateDomainStatus = "SUCCESS"
)

// Values returns all known values for LoadBalancerTlsCertificateDomainStatus.
// Note that this can be expanded in the future, and so it is only as up to date as
// the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (LoadBalancerTlsCertificateDomainStatus) Values() []LoadBalancerTlsCertificateDomainStatus {
	return []LoadBalancerTlsCertificateDomainStatus{
		"PENDING_VALIDATION",
		"FAILED",
		"SUCCESS",
	}
}

type LoadBalancerTlsCertificateFailureReason string

// Enum values for LoadBalancerTlsCertificateFailureReason
const (
	LoadBalancerTlsCertificateFailureReasonNoAvailableContacts            LoadBalancerTlsCertificateFailureReason = "NO_AVAILABLE_CONTACTS"
	LoadBalancerTlsCertificateFailureReasonAdditionalVerificationRequired LoadBalancerTlsCertificateFailureReason = "ADDITIONAL_VERIFICATION_REQUIRED"
	LoadBalancerTlsCertificateFailureReasonDomainNotAllowed               LoadBalancerTlsCertificateFailureReason = "DOMAIN_NOT_ALLOWED"
	LoadBalancerTlsCertificateFailureReasonInvalidPublicDomain            LoadBalancerTlsCertificateFailureReason = "INVALID_PUBLIC_DOMAIN"
	LoadBalancerTlsCertificateFailureReasonOther                          LoadBalancerTlsCertificateFailureReason = "OTHER"
)

// Values returns all known values for LoadBalancerTlsCertificateFailureReason.
// Note that this can be expanded in the future, and so it is only as up to date as
// the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (LoadBalancerTlsCertificateFailureReason) Values() []LoadBalancerTlsCertificateFailureReason {
	return []LoadBalancerTlsCertificateFailureReason{
		"NO_AVAILABLE_CONTACTS",
		"ADDITIONAL_VERIFICATION_REQUIRED",
		"DOMAIN_NOT_ALLOWED",
		"INVALID_PUBLIC_DOMAIN",
		"OTHER",
	}
}

type LoadBalancerTlsCertificateRenewalStatus string

// Enum values for LoadBalancerTlsCertificateRenewalStatus
const (
	LoadBalancerTlsCertificateRenewalStatusPendingAutoRenewal LoadBalancerTlsCertificateRenewalStatus = "PENDING_AUTO_RENEWAL"
	LoadBalancerTlsCertificateRenewalStatusPendingValidation  LoadBalancerTlsCertificateRenewalStatus = "PENDING_VALIDATION"
	LoadBalancerTlsCertificateRenewalStatusSuccess            LoadBalancerTlsCertificateRenewalStatus = "SUCCESS"
	LoadBalancerTlsCertificateRenewalStatusFailed             LoadBalancerTlsCertificateRenewalStatus = "FAILED"
)

// Values returns all known values for LoadBalancerTlsCertificateRenewalStatus.
// Note that this can be expanded in the future, and so it is only as up to date as
// the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (LoadBalancerTlsCertificateRenewalStatus) Values() []LoadBalancerTlsCertificateRenewalStatus {
	return []LoadBalancerTlsCertificateRenewalStatus{
		"PENDING_AUTO_RENEWAL",
		"PENDING_VALIDATION",
		"SUCCESS",
		"FAILED",
	}
}

type LoadBalancerTlsCertificateRevocationReason string

// Enum values for LoadBalancerTlsCertificateRevocationReason
const (
	LoadBalancerTlsCertificateRevocationReasonUnspecified          LoadBalancerTlsCertificateRevocationReason = "UNSPECIFIED"
	LoadBalancerTlsCertificateRevocationReasonKeyCompromise        LoadBalancerTlsCertificateRevocationReason = "KEY_COMPROMISE"
	LoadBalancerTlsCertificateRevocationReasonCaCompromise         LoadBalancerTlsCertificateRevocationReason = "CA_COMPROMISE"
	LoadBalancerTlsCertificateRevocationReasonAffiliationChanged   LoadBalancerTlsCertificateRevocationReason = "AFFILIATION_CHANGED"
	LoadBalancerTlsCertificateRevocationReasonSuperceded           LoadBalancerTlsCertificateRevocationReason = "SUPERCEDED"
	LoadBalancerTlsCertificateRevocationReasonCessationOfOperation LoadBalancerTlsCertificateRevocationReason = "CESSATION_OF_OPERATION"
	LoadBalancerTlsCertificateRevocationReasonCertificateHold      LoadBalancerTlsCertificateRevocationReason = "CERTIFICATE_HOLD"
	LoadBalancerTlsCertificateRevocationReasonRemoveFromCrl        LoadBalancerTlsCertificateRevocationReason = "REMOVE_FROM_CRL"
	LoadBalancerTlsCertificateRevocationReasonPrivilegeWithdrawn   LoadBalancerTlsCertificateRevocationReason = "PRIVILEGE_WITHDRAWN"
	LoadBalancerTlsCertificateRevocationReasonAACompromise         LoadBalancerTlsCertificateRevocationReason = "A_A_COMPROMISE"
)

// Values returns all known values for LoadBalancerTlsCertificateRevocationReason.
// Note that this can be expanded in the future, and so it is only as up to date as
// the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (LoadBalancerTlsCertificateRevocationReason) Values() []LoadBalancerTlsCertificateRevocationReason {
	return []LoadBalancerTlsCertificateRevocationReason{
		"UNSPECIFIED",
		"KEY_COMPROMISE",
		"CA_COMPROMISE",
		"AFFILIATION_CHANGED",
		"SUPERCEDED",
		"CESSATION_OF_OPERATION",
		"CERTIFICATE_HOLD",
		"REMOVE_FROM_CRL",
		"PRIVILEGE_WITHDRAWN",
		"A_A_COMPROMISE",
	}
}

type LoadBalancerTlsCertificateStatus string

// Enum values for LoadBalancerTlsCertificateStatus
const (
	LoadBalancerTlsCertificateStatusPendingValidation  LoadBalancerTlsCertificateStatus = "PENDING_VALIDATION"
	LoadBalancerTlsCertificateStatusIssued             LoadBalancerTlsCertificateStatus = "ISSUED"
	LoadBalancerTlsCertificateStatusInactive           LoadBalancerTlsCertificateStatus = "INACTIVE"
	LoadBalancerTlsCertificateStatusExpired            LoadBalancerTlsCertificateStatus = "EXPIRED"
	LoadBalancerTlsCertificateStatusValidationTimedOut LoadBalancerTlsCertificateStatus = "VALIDATION_TIMED_OUT"
	LoadBalancerTlsCertificateStatusRevoked            LoadBalancerTlsCertificateStatus = "REVOKED"
	LoadBalancerTlsCertificateStatusFailed             LoadBalancerTlsCertificateStatus = "FAILED"
	LoadBalancerTlsCertificateStatusUnknown            LoadBalancerTlsCertificateStatus = "UNKNOWN"
)

// Values returns all known values for LoadBalancerTlsCertificateStatus. Note that
// this can be expanded in the future, and so it is only as up to date as the
// client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (LoadBalancerTlsCertificateStatus) Values() []LoadBalancerTlsCertificateStatus {
	return []LoadBalancerTlsCertificateStatus{
		"PENDING_VALIDATION",
		"ISSUED",
		"INACTIVE",
		"EXPIRED",
		"VALIDATION_TIMED_OUT",
		"REVOKED",
		"FAILED",
		"UNKNOWN",
	}
}

type MetricName string

// Enum values for MetricName
const (
	MetricNameCPUUtilization                 MetricName = "CPUUtilization"
	MetricNameNetworkIn                      MetricName = "NetworkIn"
	MetricNameNetworkOut                     MetricName = "NetworkOut"
	MetricNameStatusCheckFailed              MetricName = "StatusCheckFailed"
	MetricNameStatusCheckFailedInstance      MetricName = "StatusCheckFailed_Instance"
	MetricNameStatusCheckFailedSystem        MetricName = "StatusCheckFailed_System"
	MetricNameClientTLSNegotiationErrorCount MetricName = "ClientTLSNegotiationErrorCount"
	MetricNameHealthyHostCount               MetricName = "HealthyHostCount"
	MetricNameUnhealthyHostCount             MetricName = "UnhealthyHostCount"
	MetricNameHTTPCodeLb4xxCount             MetricName = "HTTPCode_LB_4XX_Count"
	MetricNameHTTPCodeLb5xxCount             MetricName = "HTTPCode_LB_5XX_Count"
	MetricNameHTTPCodeInstance2xxCount       MetricName = "HTTPCode_Instance_2XX_Count"
	MetricNameHTTPCodeInstance3xxCount       MetricName = "HTTPCode_Instance_3XX_Count"
	MetricNameHTTPCodeInstance4xxCount       MetricName = "HTTPCode_Instance_4XX_Count"
	MetricNameHTTPCodeInstance5xxCount       MetricName = "HTTPCode_Instance_5XX_Count"
	MetricNameInstanceResponseTime           MetricName = "InstanceResponseTime"
	MetricNameRejectedConnectionCount        MetricName = "RejectedConnectionCount"
	MetricNameRequestCount                   MetricName = "RequestCount"
	MetricNameDatabaseConnections            MetricName = "DatabaseConnections"
	MetricNameDiskQueueDepth                 MetricName = "DiskQueueDepth"
	MetricNameFreeStorageSpace               MetricName = "FreeStorageSpace"
	MetricNameNetworkReceiveThroughput       MetricName = "NetworkReceiveThroughput"
	MetricNameNetworkTransmitThroughput      MetricName = "NetworkTransmitThroughput"
	MetricNameBurstCapacityTime              MetricName = "BurstCapacityTime"
	MetricNameBurstCapacityPercentage        MetricName = "BurstCapacityPercentage"
)

// Values returns all known values for MetricName. Note that this can be expanded
// in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (MetricName) Values() []MetricName {
	return []MetricName{
		"CPUUtilization",
		"NetworkIn",
		"NetworkOut",
		"StatusCheckFailed",
		"StatusCheckFailed_Instance",
		"StatusCheckFailed_System",
		"ClientTLSNegotiationErrorCount",
		"HealthyHostCount",
		"UnhealthyHostCount",
		"HTTPCode_LB_4XX_Count",
		"HTTPCode_LB_5XX_Count",
		"HTTPCode_Instance_2XX_Count",
		"HTTPCode_Instance_3XX_Count",
		"HTTPCode_Instance_4XX_Count",
		"HTTPCode_Instance_5XX_Count",
		"InstanceResponseTime",
		"RejectedConnectionCount",
		"RequestCount",
		"DatabaseConnections",
		"DiskQueueDepth",
		"FreeStorageSpace",
		"NetworkReceiveThroughput",
		"NetworkTransmitThroughput",
		"BurstCapacityTime",
		"BurstCapacityPercentage",
	}
}

type MetricStatistic string

// Enum values for MetricStatistic
const (
	MetricStatisticMinimum     MetricStatistic = "Minimum"
	MetricStatisticMaximum     MetricStatistic = "Maximum"
	MetricStatisticSum         MetricStatistic = "Sum"
	MetricStatisticAverage     MetricStatistic = "Average"
	MetricStatisticSampleCount MetricStatistic = "SampleCount"
)

// Values returns all known values for MetricStatistic. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (MetricStatistic) Values() []MetricStatistic {
	return []MetricStatistic{
		"Minimum",
		"Maximum",
		"Sum",
		"Average",
		"SampleCount",
	}
}

type MetricUnit string

// Enum values for MetricUnit
const (
	MetricUnitSeconds         MetricUnit = "Seconds"
	MetricUnitMicroseconds    MetricUnit = "Microseconds"
	MetricUnitMilliseconds    MetricUnit = "Milliseconds"
	MetricUnitBytes           MetricUnit = "Bytes"
	MetricUnitKilobytes       MetricUnit = "Kilobytes"
	MetricUnitMegabytes       MetricUnit = "Megabytes"
	MetricUnitGigabytes       MetricUnit = "Gigabytes"
	MetricUnitTerabytes       MetricUnit = "Terabytes"
	MetricUnitBits            MetricUnit = "Bits"
	MetricUnitKilobits        MetricUnit = "Kilobits"
	MetricUnitMegabits        MetricUnit = "Megabits"
	MetricUnitGigabits        MetricUnit = "Gigabits"
	MetricUnitTerabits        MetricUnit = "Terabits"
	MetricUnitPercent         MetricUnit = "Percent"
	MetricUnitCount           MetricUnit = "Count"
	MetricUnitBytesSecond     MetricUnit = "Bytes/Second"
	MetricUnitKilobytesSecond MetricUnit = "Kilobytes/Second"
	MetricUnitMegabytesSecond MetricUnit = "Megabytes/Second"
	MetricUnitGigabytesSecond MetricUnit = "Gigabytes/Second"
	MetricUnitTerabytesSecond MetricUnit = "Terabytes/Second"
	MetricUnitBitsSecond      MetricUnit = "Bits/Second"
	MetricUnitKilobitsSecond  MetricUnit = "Kilobits/Second"
	MetricUnitMegabitsSecond  MetricUnit = "Megabits/Second"
	MetricUnitGigabitsSecond  MetricUnit = "Gigabits/Second"
	MetricUnitTerabitsSecond  MetricUnit = "Terabits/Second"
	MetricUnitCountSecond     MetricUnit = "Count/Second"
	MetricUnitNone            MetricUnit = "None"
)

// Values returns all known values for MetricUnit. Note that this can be expanded
// in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (MetricUnit) Values() []MetricUnit {
	return []MetricUnit{
		"Seconds",
		"Microseconds",
		"Milliseconds",
		"Bytes",
		"Kilobytes",
		"Megabytes",
		"Gigabytes",
		"Terabytes",
		"Bits",
		"Kilobits",
		"Megabits",
		"Gigabits",
		"Terabits",
		"Percent",
		"Count",
		"Bytes/Second",
		"Kilobytes/Second",
		"Megabytes/Second",
		"Gigabytes/Second",
		"Terabytes/Second",
		"Bits/Second",
		"Kilobits/Second",
		"Megabits/Second",
		"Gigabits/Second",
		"Terabits/Second",
		"Count/Second",
		"None",
	}
}

type NameServersUpdateStateCode string

// Enum values for NameServersUpdateStateCode
const (
	NameServersUpdateStateCodeSucceeded NameServersUpdateStateCode = "SUCCEEDED"
	NameServersUpdateStateCodePending   NameServersUpdateStateCode = "PENDING"
	NameServersUpdateStateCodeFailed    NameServersUpdateStateCode = "FAILED"
	NameServersUpdateStateCodeStarted   NameServersUpdateStateCode = "STARTED"
)

// Values returns all known values for NameServersUpdateStateCode. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (NameServersUpdateStateCode) Values() []NameServersUpdateStateCode {
	return []NameServersUpdateStateCode{
		"SUCCEEDED",
		"PENDING",
		"FAILED",
		"STARTED",
	}
}

type NetworkProtocol string

// Enum values for NetworkProtocol
const (
	NetworkProtocolTcp    NetworkProtocol = "tcp"
	NetworkProtocolAll    NetworkProtocol = "all"
	NetworkProtocolUdp    NetworkProtocol = "udp"
	NetworkProtocolIcmp   NetworkProtocol = "icmp"
	NetworkProtocolIcmpv6 NetworkProtocol = "icmpv6"
)

// Values returns all known values for NetworkProtocol. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (NetworkProtocol) Values() []NetworkProtocol {
	return []NetworkProtocol{
		"tcp",
		"all",
		"udp",
		"icmp",
		"icmpv6",
	}
}

type OperationStatus string

// Enum values for OperationStatus
const (
	OperationStatusNotStarted OperationStatus = "NotStarted"
	OperationStatusStarted    OperationStatus = "Started"
	OperationStatusFailed     OperationStatus = "Failed"
	OperationStatusCompleted  OperationStatus = "Completed"
	OperationStatusSucceeded  OperationStatus = "Succeeded"
)

// Values returns all known values for OperationStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (OperationStatus) Values() []OperationStatus {
	return []OperationStatus{
		"NotStarted",
		"Started",
		"Failed",
		"Completed",
		"Succeeded",
	}
}

type OperationType string

// Enum values for OperationType
const (
	OperationTypeDeleteKnownHostKeys                  OperationType = "DeleteKnownHostKeys"
	OperationTypeDeleteInstance                       OperationType = "DeleteInstance"
	OperationTypeCreateInstance                       OperationType = "CreateInstance"
	OperationTypeStopInstance                         OperationType = "StopInstance"
	OperationTypeStartInstance                        OperationType = "StartInstance"
	OperationTypeRebootInstance                       OperationType = "RebootInstance"
	OperationTypeOpenInstancePublicPorts              OperationType = "OpenInstancePublicPorts"
	OperationTypePutInstancePublicPorts               OperationType = "PutInstancePublicPorts"
	OperationTypeCloseInstancePublicPorts             OperationType = "CloseInstancePublicPorts"
	OperationTypeAllocateStaticIp                     OperationType = "AllocateStaticIp"
	OperationTypeReleaseStaticIp                      OperationType = "ReleaseStaticIp"
	OperationTypeAttachStaticIp                       OperationType = "AttachStaticIp"
	OperationTypeDetachStaticIp                       OperationType = "DetachStaticIp"
	OperationTypeUpdateDomainEntry                    OperationType = "UpdateDomainEntry"
	OperationTypeDeleteDomainEntry                    OperationType = "DeleteDomainEntry"
	OperationTypeCreateDomain                         OperationType = "CreateDomain"
	OperationTypeDeleteDomain                         OperationType = "DeleteDomain"
	OperationTypeCreateInstanceSnapshot               OperationType = "CreateInstanceSnapshot"
	OperationTypeDeleteInstanceSnapshot               OperationType = "DeleteInstanceSnapshot"
	OperationTypeCreateInstancesFromSnapshot          OperationType = "CreateInstancesFromSnapshot"
	OperationTypeCreateLoadBalancer                   OperationType = "CreateLoadBalancer"
	OperationTypeDeleteLoadBalancer                   OperationType = "DeleteLoadBalancer"
	OperationTypeAttachInstancesToLoadBalancer        OperationType = "AttachInstancesToLoadBalancer"
	OperationTypeDetachInstancesFromLoadBalancer      OperationType = "DetachInstancesFromLoadBalancer"
	OperationTypeUpdateLoadBalancerAttribute          OperationType = "UpdateLoadBalancerAttribute"
	OperationTypeCreateLoadBalancerTlsCertificate     OperationType = "CreateLoadBalancerTlsCertificate"
	OperationTypeDeleteLoadBalancerTlsCertificate     OperationType = "DeleteLoadBalancerTlsCertificate"
	OperationTypeAttachLoadBalancerTlsCertificate     OperationType = "AttachLoadBalancerTlsCertificate"
	OperationTypeCreateDisk                           OperationType = "CreateDisk"
	OperationTypeDeleteDisk                           OperationType = "DeleteDisk"
	OperationTypeAttachDisk                           OperationType = "AttachDisk"
	OperationTypeDetachDisk                           OperationType = "DetachDisk"
	OperationTypeCreateDiskSnapshot                   OperationType = "CreateDiskSnapshot"
	OperationTypeDeleteDiskSnapshot                   OperationType = "DeleteDiskSnapshot"
	OperationTypeCreateDiskFromSnapshot               OperationType = "CreateDiskFromSnapshot"
	OperationTypeCreateRelationalDatabase             OperationType = "CreateRelationalDatabase"
	OperationTypeUpdateRelationalDatabase             OperationType = "UpdateRelationalDatabase"
	OperationTypeDeleteRelationalDatabase             OperationType = "DeleteRelationalDatabase"
	OperationTypeCreateRelationalDatabaseFromSnapshot OperationType = "CreateRelationalDatabaseFromSnapshot"
	OperationTypeCreateRelationalDatabaseSnapshot     OperationType = "CreateRelationalDatabaseSnapshot"
	OperationTypeDeleteRelationalDatabaseSnapshot     OperationType = "DeleteRelationalDatabaseSnapshot"
	OperationTypeUpdateRelationalDatabaseParameters   OperationType = "UpdateRelationalDatabaseParameters"
	OperationTypeStartRelationalDatabase              OperationType = "StartRelationalDatabase"
	OperationTypeRebootRelationalDatabase             OperationType = "RebootRelationalDatabase"
	OperationTypeStopRelationalDatabase               OperationType = "StopRelationalDatabase"
	OperationTypeEnableAddOn                          OperationType = "EnableAddOn"
	OperationTypeDisableAddOn                         OperationType = "DisableAddOn"
	OperationTypePutAlarm                             OperationType = "PutAlarm"
	OperationTypeGetAlarms                            OperationType = "GetAlarms"
	OperationTypeDeleteAlarm                          OperationType = "DeleteAlarm"
	OperationTypeTestAlarm                            OperationType = "TestAlarm"
	OperationTypeCreateContactMethod                  OperationType = "CreateContactMethod"
	OperationTypeGetContactMethods                    OperationType = "GetContactMethods"
	OperationTypeSendContactMethodVerification        OperationType = "SendContactMethodVerification"
	OperationTypeDeleteContactMethod                  OperationType = "DeleteContactMethod"
	OperationTypeCreateDistribution                   OperationType = "CreateDistribution"
	OperationTypeUpdateDistribution                   OperationType = "UpdateDistribution"
	OperationTypeDeleteDistribution                   OperationType = "DeleteDistribution"
	OperationTypeResetDistributionCache               OperationType = "ResetDistributionCache"
	OperationTypeAttachCertificateToDistribution      OperationType = "AttachCertificateToDistribution"
	OperationTypeDetachCertificateFromDistribution    OperationType = "DetachCertificateFromDistribution"
	OperationTypeUpdateDistributionBundle             OperationType = "UpdateDistributionBundle"
	OperationTypeSetIpAddressType                     OperationType = "SetIpAddressType"
	OperationTypeCreateCertificate                    OperationType = "CreateCertificate"
	OperationTypeDeleteCertificate                    OperationType = "DeleteCertificate"
	OperationTypeCreateContainerService               OperationType = "CreateContainerService"
	OperationTypeUpdateContainerService               OperationType = "UpdateContainerService"
	OperationTypeDeleteContainerService               OperationType = "DeleteContainerService"
	OperationTypeCreateContainerServiceDeployment     OperationType = "CreateContainerServiceDeployment"
	OperationTypeCreateContainerServiceRegistryLogin  OperationType = "CreateContainerServiceRegistryLogin"
	OperationTypeRegisterContainerImage               OperationType = "RegisterContainerImage"
	OperationTypeDeleteContainerImage                 OperationType = "DeleteContainerImage"
	OperationTypeCreateBucket                         OperationType = "CreateBucket"
	OperationTypeDeleteBucket                         OperationType = "DeleteBucket"
	OperationTypeCreateBucketAccessKey                OperationType = "CreateBucketAccessKey"
	OperationTypeDeleteBucketAccessKey                OperationType = "DeleteBucketAccessKey"
	OperationTypeUpdateBucketBundle                   OperationType = "UpdateBucketBundle"
	OperationTypeUpdateBucket                         OperationType = "UpdateBucket"
	OperationTypeSetResourceAccessForBucket           OperationType = "SetResourceAccessForBucket"
	OperationTypeUpdateInstanceMetadataOptions        OperationType = "UpdateInstanceMetadataOptions"
	OperationTypeStartGUISession                      OperationType = "StartGUISession"
	OperationTypeStopGUISession                       OperationType = "StopGUISession"
	OperationTypeSetupInstanceHttps                   OperationType = "SetupInstanceHttps"
)

// 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{
		"DeleteKnownHostKeys",
		"DeleteInstance",
		"CreateInstance",
		"StopInstance",
		"StartInstance",
		"RebootInstance",
		"OpenInstancePublicPorts",
		"PutInstancePublicPorts",
		"CloseInstancePublicPorts",
		"AllocateStaticIp",
		"ReleaseStaticIp",
		"AttachStaticIp",
		"DetachStaticIp",
		"UpdateDomainEntry",
		"DeleteDomainEntry",
		"CreateDomain",
		"DeleteDomain",
		"CreateInstanceSnapshot",
		"DeleteInstanceSnapshot",
		"CreateInstancesFromSnapshot",
		"CreateLoadBalancer",
		"DeleteLoadBalancer",
		"AttachInstancesToLoadBalancer",
		"DetachInstancesFromLoadBalancer",
		"UpdateLoadBalancerAttribute",
		"CreateLoadBalancerTlsCertificate",
		"DeleteLoadBalancerTlsCertificate",
		"AttachLoadBalancerTlsCertificate",
		"CreateDisk",
		"DeleteDisk",
		"AttachDisk",
		"DetachDisk",
		"CreateDiskSnapshot",
		"DeleteDiskSnapshot",
		"CreateDiskFromSnapshot",
		"CreateRelationalDatabase",
		"UpdateRelationalDatabase",
		"DeleteRelationalDatabase",
		"CreateRelationalDatabaseFromSnapshot",
		"CreateRelationalDatabaseSnapshot",
		"DeleteRelationalDatabaseSnapshot",
		"UpdateRelationalDatabaseParameters",
		"StartRelationalDatabase",
		"RebootRelationalDatabase",
		"StopRelationalDatabase",
		"EnableAddOn",
		"DisableAddOn",
		"PutAlarm",
		"GetAlarms",
		"DeleteAlarm",
		"TestAlarm",
		"CreateContactMethod",
		"GetContactMethods",
		"SendContactMethodVerification",
		"DeleteContactMethod",
		"CreateDistribution",
		"UpdateDistribution",
		"DeleteDistribution",
		"ResetDistributionCache",
		"AttachCertificateToDistribution",
		"DetachCertificateFromDistribution",
		"UpdateDistributionBundle",
		"SetIpAddressType",
		"CreateCertificate",
		"DeleteCertificate",
		"CreateContainerService",
		"UpdateContainerService",
		"DeleteContainerService",
		"CreateContainerServiceDeployment",
		"CreateContainerServiceRegistryLogin",
		"RegisterContainerImage",
		"DeleteContainerImage",
		"CreateBucket",
		"DeleteBucket",
		"CreateBucketAccessKey",
		"DeleteBucketAccessKey",
		"UpdateBucketBundle",
		"UpdateBucket",
		"SetResourceAccessForBucket",
		"UpdateInstanceMetadataOptions",
		"StartGUISession",
		"StopGUISession",
		"SetupInstanceHttps",
	}
}

type OriginProtocolPolicyEnum string

// Enum values for OriginProtocolPolicyEnum
const (
	OriginProtocolPolicyEnumHTTPOnly  OriginProtocolPolicyEnum = "http-only"
	OriginProtocolPolicyEnumHTTPSOnly OriginProtocolPolicyEnum = "https-only"
)

// Values returns all known values for OriginProtocolPolicyEnum. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (OriginProtocolPolicyEnum) Values() []OriginProtocolPolicyEnum {
	return []OriginProtocolPolicyEnum{
		"http-only",
		"https-only",
	}
}

type PortAccessType string

// Enum values for PortAccessType
const (
	PortAccessTypePublic  PortAccessType = "Public"
	PortAccessTypePrivate PortAccessType = "Private"
)

// Values returns all known values for PortAccessType. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (PortAccessType) Values() []PortAccessType {
	return []PortAccessType{
		"Public",
		"Private",
	}
}

type PortInfoSourceType string

// Enum values for PortInfoSourceType
const (
	PortInfoSourceTypeDefault  PortInfoSourceType = "DEFAULT"
	PortInfoSourceTypeInstance PortInfoSourceType = "INSTANCE"
	PortInfoSourceTypeNone     PortInfoSourceType = "NONE"
	PortInfoSourceTypeClosed   PortInfoSourceType = "CLOSED"
)

// Values returns all known values for PortInfoSourceType. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (PortInfoSourceType) Values() []PortInfoSourceType {
	return []PortInfoSourceType{
		"DEFAULT",
		"INSTANCE",
		"NONE",
		"CLOSED",
	}
}

type PortState string

// Enum values for PortState
const (
	PortStateOpen   PortState = "open"
	PortStateClosed PortState = "closed"
)

// Values returns all known values for PortState. Note that this can be expanded
// in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (PortState) Values() []PortState {
	return []PortState{
		"open",
		"closed",
	}
}

type PricingUnit string

// Enum values for PricingUnit
const (
	PricingUnitGb      PricingUnit = "GB"
	PricingUnitHrs     PricingUnit = "Hrs"
	PricingUnitGBMo    PricingUnit = "GB-Mo"
	PricingUnitBundles PricingUnit = "Bundles"
	PricingUnitQueries PricingUnit = "Queries"
)

// Values returns all known values for PricingUnit. Note that this can be expanded
// in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (PricingUnit) Values() []PricingUnit {
	return []PricingUnit{
		"GB",
		"Hrs",
		"GB-Mo",
		"Bundles",
		"Queries",
	}
}

type R53HostedZoneDeletionStateCode string

// Enum values for R53HostedZoneDeletionStateCode
const (
	R53HostedZoneDeletionStateCodeSucceeded R53HostedZoneDeletionStateCode = "SUCCEEDED"
	R53HostedZoneDeletionStateCodePending   R53HostedZoneDeletionStateCode = "PENDING"
	R53HostedZoneDeletionStateCodeFailed    R53HostedZoneDeletionStateCode = "FAILED"
	R53HostedZoneDeletionStateCodeStarted   R53HostedZoneDeletionStateCode = "STARTED"
)

// Values returns all known values for R53HostedZoneDeletionStateCode. Note that
// this can be expanded in the future, and so it is only as up to date as the
// client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (R53HostedZoneDeletionStateCode) Values() []R53HostedZoneDeletionStateCode {
	return []R53HostedZoneDeletionStateCode{
		"SUCCEEDED",
		"PENDING",
		"FAILED",
		"STARTED",
	}
}

type RecordState string

// Enum values for RecordState
const (
	RecordStateStarted   RecordState = "Started"
	RecordStateSucceeded RecordState = "Succeeded"
	RecordStateFailed    RecordState = "Failed"
)

// Values returns all known values for RecordState. Note that this can be expanded
// in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (RecordState) Values() []RecordState {
	return []RecordState{
		"Started",
		"Succeeded",
		"Failed",
	}
}

type RegionName string

// Enum values for RegionName
const (
	RegionNameUsEast1      RegionName = "us-east-1"
	RegionNameUsEast2      RegionName = "us-east-2"
	RegionNameUsWest1      RegionName = "us-west-1"
	RegionNameUsWest2      RegionName = "us-west-2"
	RegionNameEuWest1      RegionName = "eu-west-1"
	RegionNameEuWest2      RegionName = "eu-west-2"
	RegionNameEuWest3      RegionName = "eu-west-3"
	RegionNameEuCentral1   RegionName = "eu-central-1"
	RegionNameEuNorth1     RegionName = "eu-north-1"
	RegionNameCaCentral1   RegionName = "ca-central-1"
	RegionNameApSouth1     RegionName = "ap-south-1"
	RegionNameApSoutheast1 RegionName = "ap-southeast-1"
	RegionNameApSoutheast2 RegionName = "ap-southeast-2"
	RegionNameApNortheast1 RegionName = "ap-northeast-1"
	RegionNameApNortheast2 RegionName = "ap-northeast-2"
	RegionNameApSoutheast3 RegionName = "ap-southeast-3"
	RegionNameApSoutheast5 RegionName = "ap-southeast-5"
)

// Values returns all known values for RegionName. Note that this can be expanded
// in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (RegionName) Values() []RegionName {
	return []RegionName{
		"us-east-1",
		"us-east-2",
		"us-west-1",
		"us-west-2",
		"eu-west-1",
		"eu-west-2",
		"eu-west-3",
		"eu-central-1",
		"eu-north-1",
		"ca-central-1",
		"ap-south-1",
		"ap-southeast-1",
		"ap-southeast-2",
		"ap-northeast-1",
		"ap-northeast-2",
		"ap-southeast-3",
		"ap-southeast-5",
	}
}

type RelationalDatabaseEngine string

// Enum values for RelationalDatabaseEngine
const (
	RelationalDatabaseEngineMysql RelationalDatabaseEngine = "mysql"
)

// Values returns all known values for RelationalDatabaseEngine. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (RelationalDatabaseEngine) Values() []RelationalDatabaseEngine {
	return []RelationalDatabaseEngine{
		"mysql",
	}
}

type RelationalDatabaseMetricName string

// Enum values for RelationalDatabaseMetricName
const (
	RelationalDatabaseMetricNameCPUUtilization            RelationalDatabaseMetricName = "CPUUtilization"
	RelationalDatabaseMetricNameDatabaseConnections       RelationalDatabaseMetricName = "DatabaseConnections"
	RelationalDatabaseMetricNameDiskQueueDepth            RelationalDatabaseMetricName = "DiskQueueDepth"
	RelationalDatabaseMetricNameFreeStorageSpace          RelationalDatabaseMetricName = "FreeStorageSpace"
	RelationalDatabaseMetricNameNetworkReceiveThroughput  RelationalDatabaseMetricName = "NetworkReceiveThroughput"
	RelationalDatabaseMetricNameNetworkTransmitThroughput RelationalDatabaseMetricName = "NetworkTransmitThroughput"
)

// Values returns all known values for RelationalDatabaseMetricName. Note that
// this can be expanded in the future, and so it is only as up to date as the
// client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (RelationalDatabaseMetricName) Values() []RelationalDatabaseMetricName {
	return []RelationalDatabaseMetricName{
		"CPUUtilization",
		"DatabaseConnections",
		"DiskQueueDepth",
		"FreeStorageSpace",
		"NetworkReceiveThroughput",
		"NetworkTransmitThroughput",
	}
}

type RelationalDatabasePasswordVersion string

// Enum values for RelationalDatabasePasswordVersion
const (
	RelationalDatabasePasswordVersionCurrent  RelationalDatabasePasswordVersion = "CURRENT"
	RelationalDatabasePasswordVersionPrevious RelationalDatabasePasswordVersion = "PREVIOUS"
	RelationalDatabasePasswordVersionPending  RelationalDatabasePasswordVersion = "PENDING"
)

// Values returns all known values for RelationalDatabasePasswordVersion. Note
// that this can be expanded in the future, and so it is only as up to date as the
// client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (RelationalDatabasePasswordVersion) Values() []RelationalDatabasePasswordVersion {
	return []RelationalDatabasePasswordVersion{
		"CURRENT",
		"PREVIOUS",
		"PENDING",
	}
}

type RenewalStatus string

// Enum values for RenewalStatus
const (
	RenewalStatusPendingAutoRenewal RenewalStatus = "PendingAutoRenewal"
	RenewalStatusPendingValidation  RenewalStatus = "PendingValidation"
	RenewalStatusSuccess            RenewalStatus = "Success"
	RenewalStatusFailed             RenewalStatus = "Failed"
)

// Values returns all known values for RenewalStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (RenewalStatus) Values() []RenewalStatus {
	return []RenewalStatus{
		"PendingAutoRenewal",
		"PendingValidation",
		"Success",
		"Failed",
	}
}

type ResourceBucketAccess string

// Enum values for ResourceBucketAccess
const (
	ResourceBucketAccessAllow ResourceBucketAccess = "allow"
	ResourceBucketAccessDeny  ResourceBucketAccess = "deny"
)

// Values returns all known values for ResourceBucketAccess. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (ResourceBucketAccess) Values() []ResourceBucketAccess {
	return []ResourceBucketAccess{
		"allow",
		"deny",
	}
}

type ResourceType string

// Enum values for ResourceType
const (
	ResourceTypeContainerService           ResourceType = "ContainerService"
	ResourceTypeInstance                   ResourceType = "Instance"
	ResourceTypeStaticIp                   ResourceType = "StaticIp"
	ResourceTypeKeyPair                    ResourceType = "KeyPair"
	ResourceTypeInstanceSnapshot           ResourceType = "InstanceSnapshot"
	ResourceTypeDomain                     ResourceType = "Domain"
	ResourceTypePeeredVpc                  ResourceType = "PeeredVpc"
	ResourceTypeLoadBalancer               ResourceType = "LoadBalancer"
	ResourceTypeLoadBalancerTlsCertificate ResourceType = "LoadBalancerTlsCertificate"
	ResourceTypeDisk                       ResourceType = "Disk"
	ResourceTypeDiskSnapshot               ResourceType = "DiskSnapshot"
	ResourceTypeRelationalDatabase         ResourceType = "RelationalDatabase"
	ResourceTypeRelationalDatabaseSnapshot ResourceType = "RelationalDatabaseSnapshot"
	ResourceTypeExportSnapshotRecord       ResourceType = "ExportSnapshotRecord"
	ResourceTypeCloudFormationStackRecord  ResourceType = "CloudFormationStackRecord"
	ResourceTypeAlarm                      ResourceType = "Alarm"
	ResourceTypeContactMethod              ResourceType = "ContactMethod"
	ResourceTypeDistribution               ResourceType = "Distribution"
	ResourceTypeCertificate                ResourceType = "Certificate"
	ResourceTypeBucket                     ResourceType = "Bucket"
)

// 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{
		"ContainerService",
		"Instance",
		"StaticIp",
		"KeyPair",
		"InstanceSnapshot",
		"Domain",
		"PeeredVpc",
		"LoadBalancer",
		"LoadBalancerTlsCertificate",
		"Disk",
		"DiskSnapshot",
		"RelationalDatabase",
		"RelationalDatabaseSnapshot",
		"ExportSnapshotRecord",
		"CloudFormationStackRecord",
		"Alarm",
		"ContactMethod",
		"Distribution",
		"Certificate",
		"Bucket",
	}
}

type SetupStatus string

// Enum values for SetupStatus
const (
	SetupStatusSucceeded  SetupStatus = "succeeded"
	SetupStatusFailed     SetupStatus = "failed"
	SetupStatusInProgress SetupStatus = "inProgress"
)

// Values returns all known values for SetupStatus. Note that this can be expanded
// in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (SetupStatus) Values() []SetupStatus {
	return []SetupStatus{
		"succeeded",
		"failed",
		"inProgress",
	}
}

type Status string

// Enum values for Status
const (
	StatusStartExpired             Status = "startExpired"
	StatusNotStarted               Status = "notStarted"
	StatusStarted                  Status = "started"
	StatusStarting                 Status = "starting"
	StatusStopped                  Status = "stopped"
	StatusStopping                 Status = "stopping"
	StatusSettingUpInstance        Status = "settingUpInstance"
	StatusFailedInstanceCreation   Status = "failedInstanceCreation"
	StatusFailedStartingGUISession Status = "failedStartingGUISession"
	StatusFailedStoppingGUISession Status = "failedStoppingGUISession"
)

// 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{
		"startExpired",
		"notStarted",
		"started",
		"starting",
		"stopped",
		"stopping",
		"settingUpInstance",
		"failedInstanceCreation",
		"failedStartingGUISession",
		"failedStoppingGUISession",
	}
}

type StatusType string

// Enum values for StatusType
const (
	StatusTypeActive   StatusType = "Active"
	StatusTypeInactive StatusType = "Inactive"
)

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

type TreatMissingData string

// Enum values for TreatMissingData
const (
	TreatMissingDataBreaching    TreatMissingData = "breaching"
	TreatMissingDataNotBreaching TreatMissingData = "notBreaching"
	TreatMissingDataIgnore       TreatMissingData = "ignore"
	TreatMissingDataMissing      TreatMissingData = "missing"
)

// Values returns all known values for TreatMissingData. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (TreatMissingData) Values() []TreatMissingData {
	return []TreatMissingData{
		"breaching",
		"notBreaching",
		"ignore",
		"missing",
	}
}

type ViewerMinimumTlsProtocolVersionEnum string

// Enum values for ViewerMinimumTlsProtocolVersionEnum
const (
	ViewerMinimumTlsProtocolVersionEnumTLSv112016 ViewerMinimumTlsProtocolVersionEnum = "TLSv1.1_2016"
	ViewerMinimumTlsProtocolVersionEnumTLSv122018 ViewerMinimumTlsProtocolVersionEnum = "TLSv1.2_2018"
	ViewerMinimumTlsProtocolVersionEnumTLSv122019 ViewerMinimumTlsProtocolVersionEnum = "TLSv1.2_2019"
	ViewerMinimumTlsProtocolVersionEnumTLSv122021 ViewerMinimumTlsProtocolVersionEnum = "TLSv1.2_2021"
)

// Values returns all known values for ViewerMinimumTlsProtocolVersionEnum. Note
// that this can be expanded in the future, and so it is only as up to date as the
// client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (ViewerMinimumTlsProtocolVersionEnum) Values() []ViewerMinimumTlsProtocolVersionEnum {
	return []ViewerMinimumTlsProtocolVersionEnum{
		"TLSv1.1_2016",
		"TLSv1.2_2018",
		"TLSv1.2_2019",
		"TLSv1.2_2021",
	}
}
