enums.go

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

package types

type AccountFilterType string

// Enum values for AccountFilterType
const (
	AccountFilterTypeNone         AccountFilterType = "NONE"
	AccountFilterTypeIntersection AccountFilterType = "INTERSECTION"
	AccountFilterTypeDifference   AccountFilterType = "DIFFERENCE"
	AccountFilterTypeUnion        AccountFilterType = "UNION"
)

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

type AccountGateStatus string

// Enum values for AccountGateStatus
const (
	AccountGateStatusSucceeded AccountGateStatus = "SUCCEEDED"
	AccountGateStatusFailed    AccountGateStatus = "FAILED"
	AccountGateStatusSkipped   AccountGateStatus = "SKIPPED"
)

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

type AttributeChangeType string

// Enum values for AttributeChangeType
const (
	AttributeChangeTypeAdd    AttributeChangeType = "Add"
	AttributeChangeTypeRemove AttributeChangeType = "Remove"
	AttributeChangeTypeModify AttributeChangeType = "Modify"
)

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

type CallAs string

// Enum values for CallAs
const (
	CallAsSelf           CallAs = "SELF"
	CallAsDelegatedAdmin CallAs = "DELEGATED_ADMIN"
)

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

type Capability string

// Enum values for Capability
const (
	CapabilityCapabilityIam        Capability = "CAPABILITY_IAM"
	CapabilityCapabilityNamedIam   Capability = "CAPABILITY_NAMED_IAM"
	CapabilityCapabilityAutoExpand Capability = "CAPABILITY_AUTO_EXPAND"
)

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

type Category string

// Enum values for Category
const (
	CategoryRegistered Category = "REGISTERED"
	CategoryActivated  Category = "ACTIVATED"
	CategoryThirdParty Category = "THIRD_PARTY"
	CategoryAwsTypes   Category = "AWS_TYPES"
)

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

type ChangeAction string

// Enum values for ChangeAction
const (
	ChangeActionAdd     ChangeAction = "Add"
	ChangeActionModify  ChangeAction = "Modify"
	ChangeActionRemove  ChangeAction = "Remove"
	ChangeActionImport  ChangeAction = "Import"
	ChangeActionDynamic ChangeAction = "Dynamic"
)

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

type ChangeSetHooksStatus string

// Enum values for ChangeSetHooksStatus
const (
	ChangeSetHooksStatusPlanning    ChangeSetHooksStatus = "PLANNING"
	ChangeSetHooksStatusPlanned     ChangeSetHooksStatus = "PLANNED"
	ChangeSetHooksStatusUnavailable ChangeSetHooksStatus = "UNAVAILABLE"
)

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

type ChangeSetStatus string

// Enum values for ChangeSetStatus
const (
	ChangeSetStatusCreatePending    ChangeSetStatus = "CREATE_PENDING"
	ChangeSetStatusCreateInProgress ChangeSetStatus = "CREATE_IN_PROGRESS"
	ChangeSetStatusCreateComplete   ChangeSetStatus = "CREATE_COMPLETE"
	ChangeSetStatusDeletePending    ChangeSetStatus = "DELETE_PENDING"
	ChangeSetStatusDeleteInProgress ChangeSetStatus = "DELETE_IN_PROGRESS"
	ChangeSetStatusDeleteComplete   ChangeSetStatus = "DELETE_COMPLETE"
	ChangeSetStatusDeleteFailed     ChangeSetStatus = "DELETE_FAILED"
	ChangeSetStatusFailed           ChangeSetStatus = "FAILED"
)

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

type ChangeSetType string

// Enum values for ChangeSetType
const (
	ChangeSetTypeCreate ChangeSetType = "CREATE"
	ChangeSetTypeUpdate ChangeSetType = "UPDATE"
	ChangeSetTypeImport ChangeSetType = "IMPORT"
)

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

type ChangeSource string

// Enum values for ChangeSource
const (
	ChangeSourceResourceReference  ChangeSource = "ResourceReference"
	ChangeSourceParameterReference ChangeSource = "ParameterReference"
	ChangeSourceResourceAttribute  ChangeSource = "ResourceAttribute"
	ChangeSourceDirectModification ChangeSource = "DirectModification"
	ChangeSourceAutomatic          ChangeSource = "Automatic"
)

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

type ChangeType string

// Enum values for ChangeType
const (
	ChangeTypeResource ChangeType = "Resource"
)

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

type ConcurrencyMode string

// Enum values for ConcurrencyMode
const (
	ConcurrencyModeStrictFailureTolerance ConcurrencyMode = "STRICT_FAILURE_TOLERANCE"
	ConcurrencyModeSoftFailureTolerance   ConcurrencyMode = "SOFT_FAILURE_TOLERANCE"
)

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

type DeprecatedStatus string

// Enum values for DeprecatedStatus
const (
	DeprecatedStatusLive       DeprecatedStatus = "LIVE"
	DeprecatedStatusDeprecated DeprecatedStatus = "DEPRECATED"
)

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

type DetailedStatus string

// Enum values for DetailedStatus
const (
	DetailedStatusConfigurationComplete DetailedStatus = "CONFIGURATION_COMPLETE"
	DetailedStatusValidationFailed      DetailedStatus = "VALIDATION_FAILED"
)

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

type DifferenceType string

// Enum values for DifferenceType
const (
	DifferenceTypeAdd      DifferenceType = "ADD"
	DifferenceTypeRemove   DifferenceType = "REMOVE"
	DifferenceTypeNotEqual DifferenceType = "NOT_EQUAL"
)

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

type EvaluationType string

// Enum values for EvaluationType
const (
	EvaluationTypeStatic  EvaluationType = "Static"
	EvaluationTypeDynamic EvaluationType = "Dynamic"
)

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

type ExecutionStatus string

// Enum values for ExecutionStatus
const (
	ExecutionStatusUnavailable       ExecutionStatus = "UNAVAILABLE"
	ExecutionStatusAvailable         ExecutionStatus = "AVAILABLE"
	ExecutionStatusExecuteInProgress ExecutionStatus = "EXECUTE_IN_PROGRESS"
	ExecutionStatusExecuteComplete   ExecutionStatus = "EXECUTE_COMPLETE"
	ExecutionStatusExecuteFailed     ExecutionStatus = "EXECUTE_FAILED"
	ExecutionStatusObsolete          ExecutionStatus = "OBSOLETE"
)

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

type GeneratedTemplateDeletionPolicy string

// Enum values for GeneratedTemplateDeletionPolicy
const (
	GeneratedTemplateDeletionPolicyDelete GeneratedTemplateDeletionPolicy = "DELETE"
	GeneratedTemplateDeletionPolicyRetain GeneratedTemplateDeletionPolicy = "RETAIN"
)

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

type GeneratedTemplateResourceStatus string

// Enum values for GeneratedTemplateResourceStatus
const (
	GeneratedTemplateResourceStatusPending    GeneratedTemplateResourceStatus = "PENDING"
	GeneratedTemplateResourceStatusInProgress GeneratedTemplateResourceStatus = "IN_PROGRESS"
	GeneratedTemplateResourceStatusFailed     GeneratedTemplateResourceStatus = "FAILED"
	GeneratedTemplateResourceStatusComplete   GeneratedTemplateResourceStatus = "COMPLETE"
)

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

type GeneratedTemplateStatus string

// Enum values for GeneratedTemplateStatus
const (
	GeneratedTemplateStatusCreatePending    GeneratedTemplateStatus = "CREATE_PENDING"
	GeneratedTemplateStatusUpdatePending    GeneratedTemplateStatus = "UPDATE_PENDING"
	GeneratedTemplateStatusDeletePending    GeneratedTemplateStatus = "DELETE_PENDING"
	GeneratedTemplateStatusCreateInProgress GeneratedTemplateStatus = "CREATE_IN_PROGRESS"
	GeneratedTemplateStatusUpdateInProgress GeneratedTemplateStatus = "UPDATE_IN_PROGRESS"
	GeneratedTemplateStatusDeleteInProgress GeneratedTemplateStatus = "DELETE_IN_PROGRESS"
	GeneratedTemplateStatusFailed           GeneratedTemplateStatus = "FAILED"
	GeneratedTemplateStatusComplete         GeneratedTemplateStatus = "COMPLETE"
)

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

type GeneratedTemplateUpdateReplacePolicy string

// Enum values for GeneratedTemplateUpdateReplacePolicy
const (
	GeneratedTemplateUpdateReplacePolicyDelete GeneratedTemplateUpdateReplacePolicy = "DELETE"
	GeneratedTemplateUpdateReplacePolicyRetain GeneratedTemplateUpdateReplacePolicy = "RETAIN"
)

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

type HandlerErrorCode string

// Enum values for HandlerErrorCode
const (
	HandlerErrorCodeNotUpdatable             HandlerErrorCode = "NotUpdatable"
	HandlerErrorCodeInvalidRequest           HandlerErrorCode = "InvalidRequest"
	HandlerErrorCodeAccessDenied             HandlerErrorCode = "AccessDenied"
	HandlerErrorCodeInvalidCredentials       HandlerErrorCode = "InvalidCredentials"
	HandlerErrorCodeAlreadyExists            HandlerErrorCode = "AlreadyExists"
	HandlerErrorCodeNotFound                 HandlerErrorCode = "NotFound"
	HandlerErrorCodeResourceConflict         HandlerErrorCode = "ResourceConflict"
	HandlerErrorCodeThrottling               HandlerErrorCode = "Throttling"
	HandlerErrorCodeServiceLimitExceeded     HandlerErrorCode = "ServiceLimitExceeded"
	HandlerErrorCodeServiceTimeout           HandlerErrorCode = "NotStabilized"
	HandlerErrorCodeGeneralServiceException  HandlerErrorCode = "GeneralServiceException"
	HandlerErrorCodeServiceInternalError     HandlerErrorCode = "ServiceInternalError"
	HandlerErrorCodeNetworkFailure           HandlerErrorCode = "NetworkFailure"
	HandlerErrorCodeInternalFailure          HandlerErrorCode = "InternalFailure"
	HandlerErrorCodeInvalidTypeConfiguration HandlerErrorCode = "InvalidTypeConfiguration"
	HandlerErrorCodeHandlerInternalFailure   HandlerErrorCode = "HandlerInternalFailure"
	HandlerErrorCodeNonCompliant             HandlerErrorCode = "NonCompliant"
	HandlerErrorCodeUnknown                  HandlerErrorCode = "Unknown"
	HandlerErrorCodeUnsupportedTarget        HandlerErrorCode = "UnsupportedTarget"
)

// Values returns all known values for HandlerErrorCode. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (HandlerErrorCode) Values() []HandlerErrorCode {
	return []HandlerErrorCode{
		"NotUpdatable",
		"InvalidRequest",
		"AccessDenied",
		"InvalidCredentials",
		"AlreadyExists",
		"NotFound",
		"ResourceConflict",
		"Throttling",
		"ServiceLimitExceeded",
		"NotStabilized",
		"GeneralServiceException",
		"ServiceInternalError",
		"NetworkFailure",
		"InternalFailure",
		"InvalidTypeConfiguration",
		"HandlerInternalFailure",
		"NonCompliant",
		"Unknown",
		"UnsupportedTarget",
	}
}

type HookFailureMode string

// Enum values for HookFailureMode
const (
	HookFailureModeFail HookFailureMode = "FAIL"
	HookFailureModeWarn HookFailureMode = "WARN"
)

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

type HookInvocationPoint string

// Enum values for HookInvocationPoint
const (
	HookInvocationPointPreProvision HookInvocationPoint = "PRE_PROVISION"
)

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

type HookStatus string

// Enum values for HookStatus
const (
	HookStatusHookInProgress        HookStatus = "HOOK_IN_PROGRESS"
	HookStatusHookCompleteSucceeded HookStatus = "HOOK_COMPLETE_SUCCEEDED"
	HookStatusHookCompleteFailed    HookStatus = "HOOK_COMPLETE_FAILED"
	HookStatusHookFailed            HookStatus = "HOOK_FAILED"
)

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

type HookTargetType string

// Enum values for HookTargetType
const (
	HookTargetTypeResource HookTargetType = "RESOURCE"
)

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

type IdentityProvider string

// Enum values for IdentityProvider
const (
	IdentityProviderAwsMarketplace IdentityProvider = "AWS_Marketplace"
	IdentityProviderGitHub         IdentityProvider = "GitHub"
	IdentityProviderBitbucket      IdentityProvider = "Bitbucket"
)

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

type OnFailure string

// Enum values for OnFailure
const (
	OnFailureDoNothing OnFailure = "DO_NOTHING"
	OnFailureRollback  OnFailure = "ROLLBACK"
	OnFailureDelete    OnFailure = "DELETE"
)

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

type OnStackFailure string

// Enum values for OnStackFailure
const (
	OnStackFailureDoNothing OnStackFailure = "DO_NOTHING"
	OnStackFailureRollback  OnStackFailure = "ROLLBACK"
	OnStackFailureDelete    OnStackFailure = "DELETE"
)

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

type OperationResultFilterName string

// Enum values for OperationResultFilterName
const (
	OperationResultFilterNameOperationResultStatus OperationResultFilterName = "OPERATION_RESULT_STATUS"
)

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

type OperationStatus string

// Enum values for OperationStatus
const (
	OperationStatusPending    OperationStatus = "PENDING"
	OperationStatusInProgress OperationStatus = "IN_PROGRESS"
	OperationStatusSuccess    OperationStatus = "SUCCESS"
	OperationStatusFailed     OperationStatus = "FAILED"
)

// 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{
		"PENDING",
		"IN_PROGRESS",
		"SUCCESS",
		"FAILED",
	}
}

type OrganizationStatus string

// Enum values for OrganizationStatus
const (
	OrganizationStatusEnabled             OrganizationStatus = "ENABLED"
	OrganizationStatusDisabled            OrganizationStatus = "DISABLED"
	OrganizationStatusDisabledPermanently OrganizationStatus = "DISABLED_PERMANENTLY"
)

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

type PermissionModels string

// Enum values for PermissionModels
const (
	PermissionModelsServiceManaged PermissionModels = "SERVICE_MANAGED"
	PermissionModelsSelfManaged    PermissionModels = "SELF_MANAGED"
)

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

type PolicyAction string

// Enum values for PolicyAction
const (
	PolicyActionDelete             PolicyAction = "Delete"
	PolicyActionRetain             PolicyAction = "Retain"
	PolicyActionSnapshot           PolicyAction = "Snapshot"
	PolicyActionReplaceAndDelete   PolicyAction = "ReplaceAndDelete"
	PolicyActionReplaceAndRetain   PolicyAction = "ReplaceAndRetain"
	PolicyActionReplaceAndSnapshot PolicyAction = "ReplaceAndSnapshot"
)

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

type ProvisioningType string

// Enum values for ProvisioningType
const (
	ProvisioningTypeNonProvisionable ProvisioningType = "NON_PROVISIONABLE"
	ProvisioningTypeImmutable        ProvisioningType = "IMMUTABLE"
	ProvisioningTypeFullyMutable     ProvisioningType = "FULLY_MUTABLE"
)

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

type PublisherStatus string

// Enum values for PublisherStatus
const (
	PublisherStatusVerified   PublisherStatus = "VERIFIED"
	PublisherStatusUnverified PublisherStatus = "UNVERIFIED"
)

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

type RegionConcurrencyType string

// Enum values for RegionConcurrencyType
const (
	RegionConcurrencyTypeSequential RegionConcurrencyType = "SEQUENTIAL"
	RegionConcurrencyTypeParallel   RegionConcurrencyType = "PARALLEL"
)

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

type RegistrationStatus string

// Enum values for RegistrationStatus
const (
	RegistrationStatusComplete   RegistrationStatus = "COMPLETE"
	RegistrationStatusInProgress RegistrationStatus = "IN_PROGRESS"
	RegistrationStatusFailed     RegistrationStatus = "FAILED"
)

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

type RegistryType string

// Enum values for RegistryType
const (
	RegistryTypeResource RegistryType = "RESOURCE"
	RegistryTypeModule   RegistryType = "MODULE"
	RegistryTypeHook     RegistryType = "HOOK"
)

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

type Replacement string

// Enum values for Replacement
const (
	ReplacementTrue        Replacement = "True"
	ReplacementFalse       Replacement = "False"
	ReplacementConditional Replacement = "Conditional"
)

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

type RequiresRecreation string

// Enum values for RequiresRecreation
const (
	RequiresRecreationNever         RequiresRecreation = "Never"
	RequiresRecreationConditionally RequiresRecreation = "Conditionally"
	RequiresRecreationAlways        RequiresRecreation = "Always"
)

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

type ResourceAttribute string

// Enum values for ResourceAttribute
const (
	ResourceAttributeProperties          ResourceAttribute = "Properties"
	ResourceAttributeMetadata            ResourceAttribute = "Metadata"
	ResourceAttributeCreationPolicy      ResourceAttribute = "CreationPolicy"
	ResourceAttributeUpdatePolicy        ResourceAttribute = "UpdatePolicy"
	ResourceAttributeDeletionPolicy      ResourceAttribute = "DeletionPolicy"
	ResourceAttributeUpdateReplacePolicy ResourceAttribute = "UpdateReplacePolicy"
	ResourceAttributeTags                ResourceAttribute = "Tags"
)

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

type ResourceScanStatus string

// Enum values for ResourceScanStatus
const (
	ResourceScanStatusInProgress ResourceScanStatus = "IN_PROGRESS"
	ResourceScanStatusFailed     ResourceScanStatus = "FAILED"
	ResourceScanStatusComplete   ResourceScanStatus = "COMPLETE"
	ResourceScanStatusExpired    ResourceScanStatus = "EXPIRED"
)

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

type ResourceSignalStatus string

// Enum values for ResourceSignalStatus
const (
	ResourceSignalStatusSuccess ResourceSignalStatus = "SUCCESS"
	ResourceSignalStatusFailure ResourceSignalStatus = "FAILURE"
)

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

type ResourceStatus string

// Enum values for ResourceStatus
const (
	ResourceStatusCreateInProgress         ResourceStatus = "CREATE_IN_PROGRESS"
	ResourceStatusCreateFailed             ResourceStatus = "CREATE_FAILED"
	ResourceStatusCreateComplete           ResourceStatus = "CREATE_COMPLETE"
	ResourceStatusDeleteInProgress         ResourceStatus = "DELETE_IN_PROGRESS"
	ResourceStatusDeleteFailed             ResourceStatus = "DELETE_FAILED"
	ResourceStatusDeleteComplete           ResourceStatus = "DELETE_COMPLETE"
	ResourceStatusDeleteSkipped            ResourceStatus = "DELETE_SKIPPED"
	ResourceStatusUpdateInProgress         ResourceStatus = "UPDATE_IN_PROGRESS"
	ResourceStatusUpdateFailed             ResourceStatus = "UPDATE_FAILED"
	ResourceStatusUpdateComplete           ResourceStatus = "UPDATE_COMPLETE"
	ResourceStatusImportFailed             ResourceStatus = "IMPORT_FAILED"
	ResourceStatusImportComplete           ResourceStatus = "IMPORT_COMPLETE"
	ResourceStatusImportInProgress         ResourceStatus = "IMPORT_IN_PROGRESS"
	ResourceStatusImportRollbackInProgress ResourceStatus = "IMPORT_ROLLBACK_IN_PROGRESS"
	ResourceStatusImportRollbackFailed     ResourceStatus = "IMPORT_ROLLBACK_FAILED"
	ResourceStatusImportRollbackComplete   ResourceStatus = "IMPORT_ROLLBACK_COMPLETE"
	ResourceStatusUpdateRollbackInProgress ResourceStatus = "UPDATE_ROLLBACK_IN_PROGRESS"
	ResourceStatusUpdateRollbackComplete   ResourceStatus = "UPDATE_ROLLBACK_COMPLETE"
	ResourceStatusUpdateRollbackFailed     ResourceStatus = "UPDATE_ROLLBACK_FAILED"
	ResourceStatusRollbackInProgress       ResourceStatus = "ROLLBACK_IN_PROGRESS"
	ResourceStatusRollbackComplete         ResourceStatus = "ROLLBACK_COMPLETE"
	ResourceStatusRollbackFailed           ResourceStatus = "ROLLBACK_FAILED"
)

// Values returns all known values for ResourceStatus. Note that this can be
// expanded in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (ResourceStatus) Values() []ResourceStatus {
	return []ResourceStatus{
		"CREATE_IN_PROGRESS",
		"CREATE_FAILED",
		"CREATE_COMPLETE",
		"DELETE_IN_PROGRESS",
		"DELETE_FAILED",
		"DELETE_COMPLETE",
		"DELETE_SKIPPED",
		"UPDATE_IN_PROGRESS",
		"UPDATE_FAILED",
		"UPDATE_COMPLETE",
		"IMPORT_FAILED",
		"IMPORT_COMPLETE",
		"IMPORT_IN_PROGRESS",
		"IMPORT_ROLLBACK_IN_PROGRESS",
		"IMPORT_ROLLBACK_FAILED",
		"IMPORT_ROLLBACK_COMPLETE",
		"UPDATE_ROLLBACK_IN_PROGRESS",
		"UPDATE_ROLLBACK_COMPLETE",
		"UPDATE_ROLLBACK_FAILED",
		"ROLLBACK_IN_PROGRESS",
		"ROLLBACK_COMPLETE",
		"ROLLBACK_FAILED",
	}
}

type StackDriftDetectionStatus string

// Enum values for StackDriftDetectionStatus
const (
	StackDriftDetectionStatusDetectionInProgress StackDriftDetectionStatus = "DETECTION_IN_PROGRESS"
	StackDriftDetectionStatusDetectionFailed     StackDriftDetectionStatus = "DETECTION_FAILED"
	StackDriftDetectionStatusDetectionComplete   StackDriftDetectionStatus = "DETECTION_COMPLETE"
)

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

type StackDriftStatus string

// Enum values for StackDriftStatus
const (
	StackDriftStatusDrifted    StackDriftStatus = "DRIFTED"
	StackDriftStatusInSync     StackDriftStatus = "IN_SYNC"
	StackDriftStatusUnknown    StackDriftStatus = "UNKNOWN"
	StackDriftStatusNotChecked StackDriftStatus = "NOT_CHECKED"
)

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

type StackInstanceDetailedStatus string

// Enum values for StackInstanceDetailedStatus
const (
	StackInstanceDetailedStatusPending                 StackInstanceDetailedStatus = "PENDING"
	StackInstanceDetailedStatusRunning                 StackInstanceDetailedStatus = "RUNNING"
	StackInstanceDetailedStatusSucceeded               StackInstanceDetailedStatus = "SUCCEEDED"
	StackInstanceDetailedStatusFailed                  StackInstanceDetailedStatus = "FAILED"
	StackInstanceDetailedStatusCancelled               StackInstanceDetailedStatus = "CANCELLED"
	StackInstanceDetailedStatusInoperable              StackInstanceDetailedStatus = "INOPERABLE"
	StackInstanceDetailedStatusSkippedSuspendedAccount StackInstanceDetailedStatus = "SKIPPED_SUSPENDED_ACCOUNT"
	StackInstanceDetailedStatusFailedImport            StackInstanceDetailedStatus = "FAILED_IMPORT"
)

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

type StackInstanceFilterName string

// Enum values for StackInstanceFilterName
const (
	StackInstanceFilterNameDetailedStatus  StackInstanceFilterName = "DETAILED_STATUS"
	StackInstanceFilterNameLastOperationId StackInstanceFilterName = "LAST_OPERATION_ID"
	StackInstanceFilterNameDriftStatus     StackInstanceFilterName = "DRIFT_STATUS"
)

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

type StackInstanceStatus string

// Enum values for StackInstanceStatus
const (
	StackInstanceStatusCurrent    StackInstanceStatus = "CURRENT"
	StackInstanceStatusOutdated   StackInstanceStatus = "OUTDATED"
	StackInstanceStatusInoperable StackInstanceStatus = "INOPERABLE"
)

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

type StackResourceDriftStatus string

// Enum values for StackResourceDriftStatus
const (
	StackResourceDriftStatusInSync     StackResourceDriftStatus = "IN_SYNC"
	StackResourceDriftStatusModified   StackResourceDriftStatus = "MODIFIED"
	StackResourceDriftStatusDeleted    StackResourceDriftStatus = "DELETED"
	StackResourceDriftStatusNotChecked StackResourceDriftStatus = "NOT_CHECKED"
)

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

type StackSetDriftDetectionStatus string

// Enum values for StackSetDriftDetectionStatus
const (
	StackSetDriftDetectionStatusCompleted      StackSetDriftDetectionStatus = "COMPLETED"
	StackSetDriftDetectionStatusFailed         StackSetDriftDetectionStatus = "FAILED"
	StackSetDriftDetectionStatusPartialSuccess StackSetDriftDetectionStatus = "PARTIAL_SUCCESS"
	StackSetDriftDetectionStatusInProgress     StackSetDriftDetectionStatus = "IN_PROGRESS"
	StackSetDriftDetectionStatusStopped        StackSetDriftDetectionStatus = "STOPPED"
)

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

type StackSetDriftStatus string

// Enum values for StackSetDriftStatus
const (
	StackSetDriftStatusDrifted    StackSetDriftStatus = "DRIFTED"
	StackSetDriftStatusInSync     StackSetDriftStatus = "IN_SYNC"
	StackSetDriftStatusNotChecked StackSetDriftStatus = "NOT_CHECKED"
)

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

type StackSetOperationAction string

// Enum values for StackSetOperationAction
const (
	StackSetOperationActionCreate      StackSetOperationAction = "CREATE"
	StackSetOperationActionUpdate      StackSetOperationAction = "UPDATE"
	StackSetOperationActionDelete      StackSetOperationAction = "DELETE"
	StackSetOperationActionDetectDrift StackSetOperationAction = "DETECT_DRIFT"
)

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

type StackSetOperationResultStatus string

// Enum values for StackSetOperationResultStatus
const (
	StackSetOperationResultStatusPending   StackSetOperationResultStatus = "PENDING"
	StackSetOperationResultStatusRunning   StackSetOperationResultStatus = "RUNNING"
	StackSetOperationResultStatusSucceeded StackSetOperationResultStatus = "SUCCEEDED"
	StackSetOperationResultStatusFailed    StackSetOperationResultStatus = "FAILED"
	StackSetOperationResultStatusCancelled StackSetOperationResultStatus = "CANCELLED"
)

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

type StackSetOperationStatus string

// Enum values for StackSetOperationStatus
const (
	StackSetOperationStatusRunning   StackSetOperationStatus = "RUNNING"
	StackSetOperationStatusSucceeded StackSetOperationStatus = "SUCCEEDED"
	StackSetOperationStatusFailed    StackSetOperationStatus = "FAILED"
	StackSetOperationStatusStopping  StackSetOperationStatus = "STOPPING"
	StackSetOperationStatusStopped   StackSetOperationStatus = "STOPPED"
	StackSetOperationStatusQueued    StackSetOperationStatus = "QUEUED"
)

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

type StackSetStatus string

// Enum values for StackSetStatus
const (
	StackSetStatusActive  StackSetStatus = "ACTIVE"
	StackSetStatusDeleted StackSetStatus = "DELETED"
)

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

type StackStatus string

// Enum values for StackStatus
const (
	StackStatusCreateInProgress                        StackStatus = "CREATE_IN_PROGRESS"
	StackStatusCreateFailed                            StackStatus = "CREATE_FAILED"
	StackStatusCreateComplete                          StackStatus = "CREATE_COMPLETE"
	StackStatusRollbackInProgress                      StackStatus = "ROLLBACK_IN_PROGRESS"
	StackStatusRollbackFailed                          StackStatus = "ROLLBACK_FAILED"
	StackStatusRollbackComplete                        StackStatus = "ROLLBACK_COMPLETE"
	StackStatusDeleteInProgress                        StackStatus = "DELETE_IN_PROGRESS"
	StackStatusDeleteFailed                            StackStatus = "DELETE_FAILED"
	StackStatusDeleteComplete                          StackStatus = "DELETE_COMPLETE"
	StackStatusUpdateInProgress                        StackStatus = "UPDATE_IN_PROGRESS"
	StackStatusUpdateCompleteCleanupInProgress         StackStatus = "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS"
	StackStatusUpdateComplete                          StackStatus = "UPDATE_COMPLETE"
	StackStatusUpdateFailed                            StackStatus = "UPDATE_FAILED"
	StackStatusUpdateRollbackInProgress                StackStatus = "UPDATE_ROLLBACK_IN_PROGRESS"
	StackStatusUpdateRollbackFailed                    StackStatus = "UPDATE_ROLLBACK_FAILED"
	StackStatusUpdateRollbackCompleteCleanupInProgress StackStatus = "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS"
	StackStatusUpdateRollbackComplete                  StackStatus = "UPDATE_ROLLBACK_COMPLETE"
	StackStatusReviewInProgress                        StackStatus = "REVIEW_IN_PROGRESS"
	StackStatusImportInProgress                        StackStatus = "IMPORT_IN_PROGRESS"
	StackStatusImportComplete                          StackStatus = "IMPORT_COMPLETE"
	StackStatusImportRollbackInProgress                StackStatus = "IMPORT_ROLLBACK_IN_PROGRESS"
	StackStatusImportRollbackFailed                    StackStatus = "IMPORT_ROLLBACK_FAILED"
	StackStatusImportRollbackComplete                  StackStatus = "IMPORT_ROLLBACK_COMPLETE"
)

// Values returns all known values for StackStatus. Note that this can be expanded
// in the future, and so it is only as up to date as the client.
//
// The ordering of this slice is not guaranteed to be stable across updates.
func (StackStatus) Values() []StackStatus {
	return []StackStatus{
		"CREATE_IN_PROGRESS",
		"CREATE_FAILED",
		"CREATE_COMPLETE",
		"ROLLBACK_IN_PROGRESS",
		"ROLLBACK_FAILED",
		"ROLLBACK_COMPLETE",
		"DELETE_IN_PROGRESS",
		"DELETE_FAILED",
		"DELETE_COMPLETE",
		"UPDATE_IN_PROGRESS",
		"UPDATE_COMPLETE_CLEANUP_IN_PROGRESS",
		"UPDATE_COMPLETE",
		"UPDATE_FAILED",
		"UPDATE_ROLLBACK_IN_PROGRESS",
		"UPDATE_ROLLBACK_FAILED",
		"UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS",
		"UPDATE_ROLLBACK_COMPLETE",
		"REVIEW_IN_PROGRESS",
		"IMPORT_IN_PROGRESS",
		"IMPORT_COMPLETE",
		"IMPORT_ROLLBACK_IN_PROGRESS",
		"IMPORT_ROLLBACK_FAILED",
		"IMPORT_ROLLBACK_COMPLETE",
	}
}

type TemplateFormat string

// Enum values for TemplateFormat
const (
	TemplateFormatJson TemplateFormat = "JSON"
	TemplateFormatYaml TemplateFormat = "YAML"
)

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

type TemplateStage string

// Enum values for TemplateStage
const (
	TemplateStageOriginal  TemplateStage = "Original"
	TemplateStageProcessed TemplateStage = "Processed"
)

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

type ThirdPartyType string

// Enum values for ThirdPartyType
const (
	ThirdPartyTypeResource ThirdPartyType = "RESOURCE"
	ThirdPartyTypeModule   ThirdPartyType = "MODULE"
	ThirdPartyTypeHook     ThirdPartyType = "HOOK"
)

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

type TypeTestsStatus string

// Enum values for TypeTestsStatus
const (
	TypeTestsStatusPassed     TypeTestsStatus = "PASSED"
	TypeTestsStatusFailed     TypeTestsStatus = "FAILED"
	TypeTestsStatusInProgress TypeTestsStatus = "IN_PROGRESS"
	TypeTestsStatusNotTested  TypeTestsStatus = "NOT_TESTED"
)

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

type VersionBump string

// Enum values for VersionBump
const (
	VersionBumpMajor VersionBump = "MAJOR"
	VersionBumpMinor VersionBump = "MINOR"
)

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

type Visibility string

// Enum values for Visibility
const (
	VisibilityPublic  Visibility = "PUBLIC"
	VisibilityPrivate Visibility = "PRIVATE"
)

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

type WarningType string

// Enum values for WarningType
const (
	WarningTypeMutuallyExclusiveProperties WarningType = "MUTUALLY_EXCLUSIVE_PROPERTIES"
	WarningTypeUnsupportedProperties       WarningType = "UNSUPPORTED_PROPERTIES"
	WarningTypeMutuallyExclusiveTypes      WarningType = "MUTUALLY_EXCLUSIVE_TYPES"
)

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