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

package types

type AacCodingMode string

// Enum values for AacCodingMode
const (
	AacCodingModeAdReceiverMix AacCodingMode = "AD_RECEIVER_MIX"
	AacCodingModeCodingMode10  AacCodingMode = "CODING_MODE_1_0"
	AacCodingModeCodingMode11  AacCodingMode = "CODING_MODE_1_1"
	AacCodingModeCodingMode20  AacCodingMode = "CODING_MODE_2_0"
	AacCodingModeCodingMode51  AacCodingMode = "CODING_MODE_5_1"
)

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

type AacInputType string

// Enum values for AacInputType
const (
	AacInputTypeBroadcasterMixedAd AacInputType = "BROADCASTER_MIXED_AD"
	AacInputTypeNormal             AacInputType = "NORMAL"
)

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

type AacProfile string

// Enum values for AacProfile
const (
	AacProfileHev1 AacProfile = "HEV1"
	AacProfileHev2 AacProfile = "HEV2"
	AacProfileLc   AacProfile = "LC"
)

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

type AacRateControlMode string

// Enum values for AacRateControlMode
const (
	AacRateControlModeCbr AacRateControlMode = "CBR"
	AacRateControlModeVbr AacRateControlMode = "VBR"
)

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

type AacRawFormat string

// Enum values for AacRawFormat
const (
	AacRawFormatLatmLoas AacRawFormat = "LATM_LOAS"
	AacRawFormatNone     AacRawFormat = "NONE"
)

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

type AacSpec string

// Enum values for AacSpec
const (
	AacSpecMpeg2 AacSpec = "MPEG2"
	AacSpecMpeg4 AacSpec = "MPEG4"
)

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

type AacVbrQuality string

// Enum values for AacVbrQuality
const (
	AacVbrQualityHigh       AacVbrQuality = "HIGH"
	AacVbrQualityLow        AacVbrQuality = "LOW"
	AacVbrQualityMediumHigh AacVbrQuality = "MEDIUM_HIGH"
	AacVbrQualityMediumLow  AacVbrQuality = "MEDIUM_LOW"
)

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

type Ac3BitstreamMode string

// Enum values for Ac3BitstreamMode
const (
	Ac3BitstreamModeCommentary       Ac3BitstreamMode = "COMMENTARY"
	Ac3BitstreamModeCompleteMain     Ac3BitstreamMode = "COMPLETE_MAIN"
	Ac3BitstreamModeDialogue         Ac3BitstreamMode = "DIALOGUE"
	Ac3BitstreamModeEmergency        Ac3BitstreamMode = "EMERGENCY"
	Ac3BitstreamModeHearingImpaired  Ac3BitstreamMode = "HEARING_IMPAIRED"
	Ac3BitstreamModeMusicAndEffects  Ac3BitstreamMode = "MUSIC_AND_EFFECTS"
	Ac3BitstreamModeVisuallyImpaired Ac3BitstreamMode = "VISUALLY_IMPAIRED"
	Ac3BitstreamModeVoiceOver        Ac3BitstreamMode = "VOICE_OVER"
)

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

type Ac3CodingMode string

// Enum values for Ac3CodingMode
const (
	Ac3CodingModeCodingMode10    Ac3CodingMode = "CODING_MODE_1_0"
	Ac3CodingModeCodingMode11    Ac3CodingMode = "CODING_MODE_1_1"
	Ac3CodingModeCodingMode20    Ac3CodingMode = "CODING_MODE_2_0"
	Ac3CodingModeCodingMode32Lfe Ac3CodingMode = "CODING_MODE_3_2_LFE"
)

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

type Ac3DrcProfile string

// Enum values for Ac3DrcProfile
const (
	Ac3DrcProfileFilmStandard Ac3DrcProfile = "FILM_STANDARD"
	Ac3DrcProfileNone         Ac3DrcProfile = "NONE"
)

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

type Ac3LfeFilter string

// Enum values for Ac3LfeFilter
const (
	Ac3LfeFilterDisabled Ac3LfeFilter = "DISABLED"
	Ac3LfeFilterEnabled  Ac3LfeFilter = "ENABLED"
)

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

type Ac3MetadataControl string

// Enum values for Ac3MetadataControl
const (
	Ac3MetadataControlFollowInput   Ac3MetadataControl = "FOLLOW_INPUT"
	Ac3MetadataControlUseConfigured Ac3MetadataControl = "USE_CONFIGURED"
)

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

type AcceptHeader string

// Enum values for AcceptHeader
const (
	AcceptHeaderImageJpeg AcceptHeader = "image/jpeg"
)

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

type AccessibilityType string

// Enum values for AccessibilityType
const (
	AccessibilityTypeDoesNotImplementAccessibilityFeatures AccessibilityType = "DOES_NOT_IMPLEMENT_ACCESSIBILITY_FEATURES"
	AccessibilityTypeImplementsAccessibilityFeatures       AccessibilityType = "IMPLEMENTS_ACCESSIBILITY_FEATURES"
)

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

type AfdSignaling string

// Enum values for AfdSignaling
const (
	AfdSignalingAuto  AfdSignaling = "AUTO"
	AfdSignalingFixed AfdSignaling = "FIXED"
	AfdSignalingNone  AfdSignaling = "NONE"
)

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

type AudioDescriptionAudioTypeControl string

// Enum values for AudioDescriptionAudioTypeControl
const (
	AudioDescriptionAudioTypeControlFollowInput   AudioDescriptionAudioTypeControl = "FOLLOW_INPUT"
	AudioDescriptionAudioTypeControlUseConfigured AudioDescriptionAudioTypeControl = "USE_CONFIGURED"
)

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

type AudioDescriptionLanguageCodeControl string

// Enum values for AudioDescriptionLanguageCodeControl
const (
	AudioDescriptionLanguageCodeControlFollowInput   AudioDescriptionLanguageCodeControl = "FOLLOW_INPUT"
	AudioDescriptionLanguageCodeControlUseConfigured AudioDescriptionLanguageCodeControl = "USE_CONFIGURED"
)

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

type AudioLanguageSelectionPolicy string

// Enum values for AudioLanguageSelectionPolicy
const (
	AudioLanguageSelectionPolicyLoose  AudioLanguageSelectionPolicy = "LOOSE"
	AudioLanguageSelectionPolicyStrict AudioLanguageSelectionPolicy = "STRICT"
)

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

type AudioNormalizationAlgorithm string

// Enum values for AudioNormalizationAlgorithm
const (
	AudioNormalizationAlgorithmItu17701 AudioNormalizationAlgorithm = "ITU_1770_1"
	AudioNormalizationAlgorithmItu17702 AudioNormalizationAlgorithm = "ITU_1770_2"
)

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

type AudioNormalizationAlgorithmControl string

// Enum values for AudioNormalizationAlgorithmControl
const (
	AudioNormalizationAlgorithmControlCorrectAudio AudioNormalizationAlgorithmControl = "CORRECT_AUDIO"
)

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

type AudioOnlyHlsSegmentType string

// Enum values for AudioOnlyHlsSegmentType
const (
	AudioOnlyHlsSegmentTypeAac  AudioOnlyHlsSegmentType = "AAC"
	AudioOnlyHlsSegmentTypeFmp4 AudioOnlyHlsSegmentType = "FMP4"
)

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

type AudioOnlyHlsTrackType string

// Enum values for AudioOnlyHlsTrackType
const (
	AudioOnlyHlsTrackTypeAlternateAudioAutoSelect        AudioOnlyHlsTrackType = "ALTERNATE_AUDIO_AUTO_SELECT"
	AudioOnlyHlsTrackTypeAlternateAudioAutoSelectDefault AudioOnlyHlsTrackType = "ALTERNATE_AUDIO_AUTO_SELECT_DEFAULT"
	AudioOnlyHlsTrackTypeAlternateAudioNotAutoSelect     AudioOnlyHlsTrackType = "ALTERNATE_AUDIO_NOT_AUTO_SELECT"
	AudioOnlyHlsTrackTypeAudioOnlyVariantStream          AudioOnlyHlsTrackType = "AUDIO_ONLY_VARIANT_STREAM"
)

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

type AudioType string

// Enum values for AudioType
const (
	AudioTypeCleanEffects             AudioType = "CLEAN_EFFECTS"
	AudioTypeHearingImpaired          AudioType = "HEARING_IMPAIRED"
	AudioTypeUndefined                AudioType = "UNDEFINED"
	AudioTypeVisualImpairedCommentary AudioType = "VISUAL_IMPAIRED_COMMENTARY"
)

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

type AuthenticationScheme string

// Enum values for AuthenticationScheme
const (
	AuthenticationSchemeAkamai AuthenticationScheme = "AKAMAI"
	AuthenticationSchemeCommon AuthenticationScheme = "COMMON"
)

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

type AvailBlankingState string

// Enum values for AvailBlankingState
const (
	AvailBlankingStateDisabled AvailBlankingState = "DISABLED"
	AvailBlankingStateEnabled  AvailBlankingState = "ENABLED"
)

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

type BlackoutSlateNetworkEndBlackout string

// Enum values for BlackoutSlateNetworkEndBlackout
const (
	BlackoutSlateNetworkEndBlackoutDisabled BlackoutSlateNetworkEndBlackout = "DISABLED"
	BlackoutSlateNetworkEndBlackoutEnabled  BlackoutSlateNetworkEndBlackout = "ENABLED"
)

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

type BlackoutSlateState string

// Enum values for BlackoutSlateState
const (
	BlackoutSlateStateDisabled BlackoutSlateState = "DISABLED"
	BlackoutSlateStateEnabled  BlackoutSlateState = "ENABLED"
)

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

type BurnInAlignment string

// Enum values for BurnInAlignment
const (
	BurnInAlignmentCentered BurnInAlignment = "CENTERED"
	BurnInAlignmentLeft     BurnInAlignment = "LEFT"
	BurnInAlignmentSmart    BurnInAlignment = "SMART"
)

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

type BurnInBackgroundColor string

// Enum values for BurnInBackgroundColor
const (
	BurnInBackgroundColorBlack BurnInBackgroundColor = "BLACK"
	BurnInBackgroundColorNone  BurnInBackgroundColor = "NONE"
	BurnInBackgroundColorWhite BurnInBackgroundColor = "WHITE"
)

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

type BurnInFontColor string

// Enum values for BurnInFontColor
const (
	BurnInFontColorBlack  BurnInFontColor = "BLACK"
	BurnInFontColorBlue   BurnInFontColor = "BLUE"
	BurnInFontColorGreen  BurnInFontColor = "GREEN"
	BurnInFontColorRed    BurnInFontColor = "RED"
	BurnInFontColorWhite  BurnInFontColor = "WHITE"
	BurnInFontColorYellow BurnInFontColor = "YELLOW"
)

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

type BurnInOutlineColor string

// Enum values for BurnInOutlineColor
const (
	BurnInOutlineColorBlack  BurnInOutlineColor = "BLACK"
	BurnInOutlineColorBlue   BurnInOutlineColor = "BLUE"
	BurnInOutlineColorGreen  BurnInOutlineColor = "GREEN"
	BurnInOutlineColorRed    BurnInOutlineColor = "RED"
	BurnInOutlineColorWhite  BurnInOutlineColor = "WHITE"
	BurnInOutlineColorYellow BurnInOutlineColor = "YELLOW"
)

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

type BurnInShadowColor string

// Enum values for BurnInShadowColor
const (
	BurnInShadowColorBlack BurnInShadowColor = "BLACK"
	BurnInShadowColorNone  BurnInShadowColor = "NONE"
	BurnInShadowColorWhite BurnInShadowColor = "WHITE"
)

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

type BurnInTeletextGridControl string

// Enum values for BurnInTeletextGridControl
const (
	BurnInTeletextGridControlFixed  BurnInTeletextGridControl = "FIXED"
	BurnInTeletextGridControlScaled BurnInTeletextGridControl = "SCALED"
)

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

type CdiInputResolution string

// Enum values for CdiInputResolution
const (
	CdiInputResolutionSd  CdiInputResolution = "SD"
	CdiInputResolutionHd  CdiInputResolution = "HD"
	CdiInputResolutionFhd CdiInputResolution = "FHD"
	CdiInputResolutionUhd CdiInputResolution = "UHD"
)

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

type ChannelClass string

// Enum values for ChannelClass
const (
	ChannelClassStandard       ChannelClass = "STANDARD"
	ChannelClassSinglePipeline ChannelClass = "SINGLE_PIPELINE"
)

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

type ChannelState string

// Enum values for ChannelState
const (
	ChannelStateCreating     ChannelState = "CREATING"
	ChannelStateCreateFailed ChannelState = "CREATE_FAILED"
	ChannelStateIdle         ChannelState = "IDLE"
	ChannelStateStarting     ChannelState = "STARTING"
	ChannelStateRunning      ChannelState = "RUNNING"
	ChannelStateRecovering   ChannelState = "RECOVERING"
	ChannelStateStopping     ChannelState = "STOPPING"
	ChannelStateDeleting     ChannelState = "DELETING"
	ChannelStateDeleted      ChannelState = "DELETED"
	ChannelStateUpdating     ChannelState = "UPDATING"
	ChannelStateUpdateFailed ChannelState = "UPDATE_FAILED"
)

// Values returns all known values for ChannelState. Note that this can be
// expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (ChannelState) Values() []ChannelState {
	return []ChannelState{
		"CREATING",
		"CREATE_FAILED",
		"IDLE",
		"STARTING",
		"RUNNING",
		"RECOVERING",
		"STOPPING",
		"DELETING",
		"DELETED",
		"UPDATING",
		"UPDATE_FAILED",
	}
}

type ContentType string

// Enum values for ContentType
const (
	ContentTypeImageJpeg ContentType = "image/jpeg"
)

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

type DeviceSettingsSyncState string

// Enum values for DeviceSettingsSyncState
const (
	DeviceSettingsSyncStateSynced  DeviceSettingsSyncState = "SYNCED"
	DeviceSettingsSyncStateSyncing DeviceSettingsSyncState = "SYNCING"
)

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

type DeviceUpdateStatus string

// Enum values for DeviceUpdateStatus
const (
	DeviceUpdateStatusUpToDate    DeviceUpdateStatus = "UP_TO_DATE"
	DeviceUpdateStatusNotUpToDate DeviceUpdateStatus = "NOT_UP_TO_DATE"
	DeviceUpdateStatusUpdating    DeviceUpdateStatus = "UPDATING"
)

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

type DolbyEProgramSelection string

// Enum values for DolbyEProgramSelection
const (
	DolbyEProgramSelectionAllChannels DolbyEProgramSelection = "ALL_CHANNELS"
	DolbyEProgramSelectionProgram1    DolbyEProgramSelection = "PROGRAM_1"
	DolbyEProgramSelectionProgram2    DolbyEProgramSelection = "PROGRAM_2"
	DolbyEProgramSelectionProgram3    DolbyEProgramSelection = "PROGRAM_3"
	DolbyEProgramSelectionProgram4    DolbyEProgramSelection = "PROGRAM_4"
	DolbyEProgramSelectionProgram5    DolbyEProgramSelection = "PROGRAM_5"
	DolbyEProgramSelectionProgram6    DolbyEProgramSelection = "PROGRAM_6"
	DolbyEProgramSelectionProgram7    DolbyEProgramSelection = "PROGRAM_7"
	DolbyEProgramSelectionProgram8    DolbyEProgramSelection = "PROGRAM_8"
)

// Values returns all known values for DolbyEProgramSelection. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (DolbyEProgramSelection) Values() []DolbyEProgramSelection {
	return []DolbyEProgramSelection{
		"ALL_CHANNELS",
		"PROGRAM_1",
		"PROGRAM_2",
		"PROGRAM_3",
		"PROGRAM_4",
		"PROGRAM_5",
		"PROGRAM_6",
		"PROGRAM_7",
		"PROGRAM_8",
	}
}

type DvbSdtOutputSdt string

// Enum values for DvbSdtOutputSdt
const (
	DvbSdtOutputSdtSdtFollow          DvbSdtOutputSdt = "SDT_FOLLOW"
	DvbSdtOutputSdtSdtFollowIfPresent DvbSdtOutputSdt = "SDT_FOLLOW_IF_PRESENT"
	DvbSdtOutputSdtSdtManual          DvbSdtOutputSdt = "SDT_MANUAL"
	DvbSdtOutputSdtSdtNone            DvbSdtOutputSdt = "SDT_NONE"
)

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

type DvbSubDestinationAlignment string

// Enum values for DvbSubDestinationAlignment
const (
	DvbSubDestinationAlignmentCentered DvbSubDestinationAlignment = "CENTERED"
	DvbSubDestinationAlignmentLeft     DvbSubDestinationAlignment = "LEFT"
	DvbSubDestinationAlignmentSmart    DvbSubDestinationAlignment = "SMART"
)

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

type DvbSubDestinationBackgroundColor string

// Enum values for DvbSubDestinationBackgroundColor
const (
	DvbSubDestinationBackgroundColorBlack DvbSubDestinationBackgroundColor = "BLACK"
	DvbSubDestinationBackgroundColorNone  DvbSubDestinationBackgroundColor = "NONE"
	DvbSubDestinationBackgroundColorWhite DvbSubDestinationBackgroundColor = "WHITE"
)

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

type DvbSubDestinationFontColor string

// Enum values for DvbSubDestinationFontColor
const (
	DvbSubDestinationFontColorBlack  DvbSubDestinationFontColor = "BLACK"
	DvbSubDestinationFontColorBlue   DvbSubDestinationFontColor = "BLUE"
	DvbSubDestinationFontColorGreen  DvbSubDestinationFontColor = "GREEN"
	DvbSubDestinationFontColorRed    DvbSubDestinationFontColor = "RED"
	DvbSubDestinationFontColorWhite  DvbSubDestinationFontColor = "WHITE"
	DvbSubDestinationFontColorYellow DvbSubDestinationFontColor = "YELLOW"
)

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

type DvbSubDestinationOutlineColor string

// Enum values for DvbSubDestinationOutlineColor
const (
	DvbSubDestinationOutlineColorBlack  DvbSubDestinationOutlineColor = "BLACK"
	DvbSubDestinationOutlineColorBlue   DvbSubDestinationOutlineColor = "BLUE"
	DvbSubDestinationOutlineColorGreen  DvbSubDestinationOutlineColor = "GREEN"
	DvbSubDestinationOutlineColorRed    DvbSubDestinationOutlineColor = "RED"
	DvbSubDestinationOutlineColorWhite  DvbSubDestinationOutlineColor = "WHITE"
	DvbSubDestinationOutlineColorYellow DvbSubDestinationOutlineColor = "YELLOW"
)

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

type DvbSubDestinationShadowColor string

// Enum values for DvbSubDestinationShadowColor
const (
	DvbSubDestinationShadowColorBlack DvbSubDestinationShadowColor = "BLACK"
	DvbSubDestinationShadowColorNone  DvbSubDestinationShadowColor = "NONE"
	DvbSubDestinationShadowColorWhite DvbSubDestinationShadowColor = "WHITE"
)

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

type DvbSubDestinationTeletextGridControl string

// Enum values for DvbSubDestinationTeletextGridControl
const (
	DvbSubDestinationTeletextGridControlFixed  DvbSubDestinationTeletextGridControl = "FIXED"
	DvbSubDestinationTeletextGridControlScaled DvbSubDestinationTeletextGridControl = "SCALED"
)

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

type DvbSubOcrLanguage string

// Enum values for DvbSubOcrLanguage
const (
	DvbSubOcrLanguageDeu DvbSubOcrLanguage = "DEU"
	DvbSubOcrLanguageEng DvbSubOcrLanguage = "ENG"
	DvbSubOcrLanguageFra DvbSubOcrLanguage = "FRA"
	DvbSubOcrLanguageNld DvbSubOcrLanguage = "NLD"
	DvbSubOcrLanguagePor DvbSubOcrLanguage = "POR"
	DvbSubOcrLanguageSpa DvbSubOcrLanguage = "SPA"
)

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

type Eac3AtmosCodingMode string

// Enum values for Eac3AtmosCodingMode
const (
	Eac3AtmosCodingModeCodingMode514 Eac3AtmosCodingMode = "CODING_MODE_5_1_4"
	Eac3AtmosCodingModeCodingMode714 Eac3AtmosCodingMode = "CODING_MODE_7_1_4"
	Eac3AtmosCodingModeCodingMode916 Eac3AtmosCodingMode = "CODING_MODE_9_1_6"
)

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

type Eac3AtmosDrcLine string

// Enum values for Eac3AtmosDrcLine
const (
	Eac3AtmosDrcLineFilmLight     Eac3AtmosDrcLine = "FILM_LIGHT"
	Eac3AtmosDrcLineFilmStandard  Eac3AtmosDrcLine = "FILM_STANDARD"
	Eac3AtmosDrcLineMusicLight    Eac3AtmosDrcLine = "MUSIC_LIGHT"
	Eac3AtmosDrcLineMusicStandard Eac3AtmosDrcLine = "MUSIC_STANDARD"
	Eac3AtmosDrcLineNone          Eac3AtmosDrcLine = "NONE"
	Eac3AtmosDrcLineSpeech        Eac3AtmosDrcLine = "SPEECH"
)

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

type Eac3AtmosDrcRf string

// Enum values for Eac3AtmosDrcRf
const (
	Eac3AtmosDrcRfFilmLight     Eac3AtmosDrcRf = "FILM_LIGHT"
	Eac3AtmosDrcRfFilmStandard  Eac3AtmosDrcRf = "FILM_STANDARD"
	Eac3AtmosDrcRfMusicLight    Eac3AtmosDrcRf = "MUSIC_LIGHT"
	Eac3AtmosDrcRfMusicStandard Eac3AtmosDrcRf = "MUSIC_STANDARD"
	Eac3AtmosDrcRfNone          Eac3AtmosDrcRf = "NONE"
	Eac3AtmosDrcRfSpeech        Eac3AtmosDrcRf = "SPEECH"
)

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

type Eac3AttenuationControl string

// Enum values for Eac3AttenuationControl
const (
	Eac3AttenuationControlAttenuate3Db Eac3AttenuationControl = "ATTENUATE_3_DB"
	Eac3AttenuationControlNone         Eac3AttenuationControl = "NONE"
)

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

type Eac3BitstreamMode string

// Enum values for Eac3BitstreamMode
const (
	Eac3BitstreamModeCommentary       Eac3BitstreamMode = "COMMENTARY"
	Eac3BitstreamModeCompleteMain     Eac3BitstreamMode = "COMPLETE_MAIN"
	Eac3BitstreamModeEmergency        Eac3BitstreamMode = "EMERGENCY"
	Eac3BitstreamModeHearingImpaired  Eac3BitstreamMode = "HEARING_IMPAIRED"
	Eac3BitstreamModeVisuallyImpaired Eac3BitstreamMode = "VISUALLY_IMPAIRED"
)

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

type Eac3CodingMode string

// Enum values for Eac3CodingMode
const (
	Eac3CodingModeCodingMode10 Eac3CodingMode = "CODING_MODE_1_0"
	Eac3CodingModeCodingMode20 Eac3CodingMode = "CODING_MODE_2_0"
	Eac3CodingModeCodingMode32 Eac3CodingMode = "CODING_MODE_3_2"
)

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

type Eac3DcFilter string

// Enum values for Eac3DcFilter
const (
	Eac3DcFilterDisabled Eac3DcFilter = "DISABLED"
	Eac3DcFilterEnabled  Eac3DcFilter = "ENABLED"
)

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

type Eac3DrcLine string

// Enum values for Eac3DrcLine
const (
	Eac3DrcLineFilmLight     Eac3DrcLine = "FILM_LIGHT"
	Eac3DrcLineFilmStandard  Eac3DrcLine = "FILM_STANDARD"
	Eac3DrcLineMusicLight    Eac3DrcLine = "MUSIC_LIGHT"
	Eac3DrcLineMusicStandard Eac3DrcLine = "MUSIC_STANDARD"
	Eac3DrcLineNone          Eac3DrcLine = "NONE"
	Eac3DrcLineSpeech        Eac3DrcLine = "SPEECH"
)

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

type Eac3DrcRf string

// Enum values for Eac3DrcRf
const (
	Eac3DrcRfFilmLight     Eac3DrcRf = "FILM_LIGHT"
	Eac3DrcRfFilmStandard  Eac3DrcRf = "FILM_STANDARD"
	Eac3DrcRfMusicLight    Eac3DrcRf = "MUSIC_LIGHT"
	Eac3DrcRfMusicStandard Eac3DrcRf = "MUSIC_STANDARD"
	Eac3DrcRfNone          Eac3DrcRf = "NONE"
	Eac3DrcRfSpeech        Eac3DrcRf = "SPEECH"
)

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

type Eac3LfeControl string

// Enum values for Eac3LfeControl
const (
	Eac3LfeControlLfe   Eac3LfeControl = "LFE"
	Eac3LfeControlNoLfe Eac3LfeControl = "NO_LFE"
)

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

type Eac3LfeFilter string

// Enum values for Eac3LfeFilter
const (
	Eac3LfeFilterDisabled Eac3LfeFilter = "DISABLED"
	Eac3LfeFilterEnabled  Eac3LfeFilter = "ENABLED"
)

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

type Eac3MetadataControl string

// Enum values for Eac3MetadataControl
const (
	Eac3MetadataControlFollowInput   Eac3MetadataControl = "FOLLOW_INPUT"
	Eac3MetadataControlUseConfigured Eac3MetadataControl = "USE_CONFIGURED"
)

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

type Eac3PassthroughControl string

// Enum values for Eac3PassthroughControl
const (
	Eac3PassthroughControlNoPassthrough Eac3PassthroughControl = "NO_PASSTHROUGH"
	Eac3PassthroughControlWhenPossible  Eac3PassthroughControl = "WHEN_POSSIBLE"
)

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

type Eac3PhaseControl string

// Enum values for Eac3PhaseControl
const (
	Eac3PhaseControlNoShift        Eac3PhaseControl = "NO_SHIFT"
	Eac3PhaseControlShift90Degrees Eac3PhaseControl = "SHIFT_90_DEGREES"
)

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

type Eac3StereoDownmix string

// Enum values for Eac3StereoDownmix
const (
	Eac3StereoDownmixDpl2         Eac3StereoDownmix = "DPL2"
	Eac3StereoDownmixLoRo         Eac3StereoDownmix = "LO_RO"
	Eac3StereoDownmixLtRt         Eac3StereoDownmix = "LT_RT"
	Eac3StereoDownmixNotIndicated Eac3StereoDownmix = "NOT_INDICATED"
)

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

type Eac3SurroundExMode string

// Enum values for Eac3SurroundExMode
const (
	Eac3SurroundExModeDisabled     Eac3SurroundExMode = "DISABLED"
	Eac3SurroundExModeEnabled      Eac3SurroundExMode = "ENABLED"
	Eac3SurroundExModeNotIndicated Eac3SurroundExMode = "NOT_INDICATED"
)

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

type Eac3SurroundMode string

// Enum values for Eac3SurroundMode
const (
	Eac3SurroundModeDisabled     Eac3SurroundMode = "DISABLED"
	Eac3SurroundModeEnabled      Eac3SurroundMode = "ENABLED"
	Eac3SurroundModeNotIndicated Eac3SurroundMode = "NOT_INDICATED"
)

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

type EbuTtDDestinationStyleControl string

// Enum values for EbuTtDDestinationStyleControl
const (
	EbuTtDDestinationStyleControlExclude EbuTtDDestinationStyleControl = "EXCLUDE"
	EbuTtDDestinationStyleControlInclude EbuTtDDestinationStyleControl = "INCLUDE"
)

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

type EbuTtDFillLineGapControl string

// Enum values for EbuTtDFillLineGapControl
const (
	EbuTtDFillLineGapControlDisabled EbuTtDFillLineGapControl = "DISABLED"
	EbuTtDFillLineGapControlEnabled  EbuTtDFillLineGapControl = "ENABLED"
)

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

type EmbeddedConvert608To708 string

// Enum values for EmbeddedConvert608To708
const (
	EmbeddedConvert608To708Disabled  EmbeddedConvert608To708 = "DISABLED"
	EmbeddedConvert608To708Upconvert EmbeddedConvert608To708 = "UPCONVERT"
)

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

type EmbeddedScte20Detection string

// Enum values for EmbeddedScte20Detection
const (
	EmbeddedScte20DetectionAuto EmbeddedScte20Detection = "AUTO"
	EmbeddedScte20DetectionOff  EmbeddedScte20Detection = "OFF"
)

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

type FeatureActivationsInputPrepareScheduleActions string

// Enum values for FeatureActivationsInputPrepareScheduleActions
const (
	FeatureActivationsInputPrepareScheduleActionsDisabled FeatureActivationsInputPrepareScheduleActions = "DISABLED"
	FeatureActivationsInputPrepareScheduleActionsEnabled  FeatureActivationsInputPrepareScheduleActions = "ENABLED"
)

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

type FecOutputIncludeFec string

// Enum values for FecOutputIncludeFec
const (
	FecOutputIncludeFecColumn       FecOutputIncludeFec = "COLUMN"
	FecOutputIncludeFecColumnAndRow FecOutputIncludeFec = "COLUMN_AND_ROW"
)

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

type FixedAfd string

// Enum values for FixedAfd
const (
	FixedAfdAfd0000 FixedAfd = "AFD_0000"
	FixedAfdAfd0010 FixedAfd = "AFD_0010"
	FixedAfdAfd0011 FixedAfd = "AFD_0011"
	FixedAfdAfd0100 FixedAfd = "AFD_0100"
	FixedAfdAfd1000 FixedAfd = "AFD_1000"
	FixedAfdAfd1001 FixedAfd = "AFD_1001"
	FixedAfdAfd1010 FixedAfd = "AFD_1010"
	FixedAfdAfd1011 FixedAfd = "AFD_1011"
	FixedAfdAfd1101 FixedAfd = "AFD_1101"
	FixedAfdAfd1110 FixedAfd = "AFD_1110"
	FixedAfdAfd1111 FixedAfd = "AFD_1111"
)

// Values returns all known values for FixedAfd. Note that this can be expanded in
// the future, and so it is only as up to date as the client. The ordering of this
// slice is not guaranteed to be stable across updates.
func (FixedAfd) Values() []FixedAfd {
	return []FixedAfd{
		"AFD_0000",
		"AFD_0010",
		"AFD_0011",
		"AFD_0100",
		"AFD_1000",
		"AFD_1001",
		"AFD_1010",
		"AFD_1011",
		"AFD_1101",
		"AFD_1110",
		"AFD_1111",
	}
}

type Fmp4NielsenId3Behavior string

// Enum values for Fmp4NielsenId3Behavior
const (
	Fmp4NielsenId3BehaviorNoPassthrough Fmp4NielsenId3Behavior = "NO_PASSTHROUGH"
	Fmp4NielsenId3BehaviorPassthrough   Fmp4NielsenId3Behavior = "PASSTHROUGH"
)

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

type Fmp4TimedMetadataBehavior string

// Enum values for Fmp4TimedMetadataBehavior
const (
	Fmp4TimedMetadataBehaviorNoPassthrough Fmp4TimedMetadataBehavior = "NO_PASSTHROUGH"
	Fmp4TimedMetadataBehaviorPassthrough   Fmp4TimedMetadataBehavior = "PASSTHROUGH"
)

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

type FollowPoint string

// Enum values for FollowPoint
const (
	FollowPointEnd   FollowPoint = "END"
	FollowPointStart FollowPoint = "START"
)

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

type FrameCaptureIntervalUnit string

// Enum values for FrameCaptureIntervalUnit
const (
	FrameCaptureIntervalUnitMilliseconds FrameCaptureIntervalUnit = "MILLISECONDS"
	FrameCaptureIntervalUnitSeconds      FrameCaptureIntervalUnit = "SECONDS"
)

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

type GlobalConfigurationInputEndAction string

// Enum values for GlobalConfigurationInputEndAction
const (
	GlobalConfigurationInputEndActionNone                GlobalConfigurationInputEndAction = "NONE"
	GlobalConfigurationInputEndActionSwitchAndLoopInputs GlobalConfigurationInputEndAction = "SWITCH_AND_LOOP_INPUTS"
)

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

type GlobalConfigurationLowFramerateInputs string

// Enum values for GlobalConfigurationLowFramerateInputs
const (
	GlobalConfigurationLowFramerateInputsDisabled GlobalConfigurationLowFramerateInputs = "DISABLED"
	GlobalConfigurationLowFramerateInputsEnabled  GlobalConfigurationLowFramerateInputs = "ENABLED"
)

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

type GlobalConfigurationOutputLockingMode string

// Enum values for GlobalConfigurationOutputLockingMode
const (
	GlobalConfigurationOutputLockingModeEpochLocking    GlobalConfigurationOutputLockingMode = "EPOCH_LOCKING"
	GlobalConfigurationOutputLockingModePipelineLocking GlobalConfigurationOutputLockingMode = "PIPELINE_LOCKING"
)

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

type GlobalConfigurationOutputTimingSource string

// Enum values for GlobalConfigurationOutputTimingSource
const (
	GlobalConfigurationOutputTimingSourceInputClock  GlobalConfigurationOutputTimingSource = "INPUT_CLOCK"
	GlobalConfigurationOutputTimingSourceSystemClock GlobalConfigurationOutputTimingSource = "SYSTEM_CLOCK"
)

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

type H264AdaptiveQuantization string

// Enum values for H264AdaptiveQuantization
const (
	H264AdaptiveQuantizationAuto   H264AdaptiveQuantization = "AUTO"
	H264AdaptiveQuantizationHigh   H264AdaptiveQuantization = "HIGH"
	H264AdaptiveQuantizationHigher H264AdaptiveQuantization = "HIGHER"
	H264AdaptiveQuantizationLow    H264AdaptiveQuantization = "LOW"
	H264AdaptiveQuantizationMax    H264AdaptiveQuantization = "MAX"
	H264AdaptiveQuantizationMedium H264AdaptiveQuantization = "MEDIUM"
	H264AdaptiveQuantizationOff    H264AdaptiveQuantization = "OFF"
)

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

type H264ColorMetadata string

// Enum values for H264ColorMetadata
const (
	H264ColorMetadataIgnore H264ColorMetadata = "IGNORE"
	H264ColorMetadataInsert H264ColorMetadata = "INSERT"
)

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

type H264EntropyEncoding string

// Enum values for H264EntropyEncoding
const (
	H264EntropyEncodingCabac H264EntropyEncoding = "CABAC"
	H264EntropyEncodingCavlc H264EntropyEncoding = "CAVLC"
)

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

type H264FlickerAq string

// Enum values for H264FlickerAq
const (
	H264FlickerAqDisabled H264FlickerAq = "DISABLED"
	H264FlickerAqEnabled  H264FlickerAq = "ENABLED"
)

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

type H264ForceFieldPictures string

// Enum values for H264ForceFieldPictures
const (
	H264ForceFieldPicturesDisabled H264ForceFieldPictures = "DISABLED"
	H264ForceFieldPicturesEnabled  H264ForceFieldPictures = "ENABLED"
)

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

type H264FramerateControl string

// Enum values for H264FramerateControl
const (
	H264FramerateControlInitializeFromSource H264FramerateControl = "INITIALIZE_FROM_SOURCE"
	H264FramerateControlSpecified            H264FramerateControl = "SPECIFIED"
)

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

type H264GopBReference string

// Enum values for H264GopBReference
const (
	H264GopBReferenceDisabled H264GopBReference = "DISABLED"
	H264GopBReferenceEnabled  H264GopBReference = "ENABLED"
)

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

type H264GopSizeUnits string

// Enum values for H264GopSizeUnits
const (
	H264GopSizeUnitsFrames  H264GopSizeUnits = "FRAMES"
	H264GopSizeUnitsSeconds H264GopSizeUnits = "SECONDS"
)

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

type H264Level string

// Enum values for H264Level
const (
	H264LevelH264Level1    H264Level = "H264_LEVEL_1"
	H264LevelH264Level11   H264Level = "H264_LEVEL_1_1"
	H264LevelH264Level12   H264Level = "H264_LEVEL_1_2"
	H264LevelH264Level13   H264Level = "H264_LEVEL_1_3"
	H264LevelH264Level2    H264Level = "H264_LEVEL_2"
	H264LevelH264Level21   H264Level = "H264_LEVEL_2_1"
	H264LevelH264Level22   H264Level = "H264_LEVEL_2_2"
	H264LevelH264Level3    H264Level = "H264_LEVEL_3"
	H264LevelH264Level31   H264Level = "H264_LEVEL_3_1"
	H264LevelH264Level32   H264Level = "H264_LEVEL_3_2"
	H264LevelH264Level4    H264Level = "H264_LEVEL_4"
	H264LevelH264Level41   H264Level = "H264_LEVEL_4_1"
	H264LevelH264Level42   H264Level = "H264_LEVEL_4_2"
	H264LevelH264Level5    H264Level = "H264_LEVEL_5"
	H264LevelH264Level51   H264Level = "H264_LEVEL_5_1"
	H264LevelH264Level52   H264Level = "H264_LEVEL_5_2"
	H264LevelH264LevelAuto H264Level = "H264_LEVEL_AUTO"
)

// Values returns all known values for H264Level. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (H264Level) Values() []H264Level {
	return []H264Level{
		"H264_LEVEL_1",
		"H264_LEVEL_1_1",
		"H264_LEVEL_1_2",
		"H264_LEVEL_1_3",
		"H264_LEVEL_2",
		"H264_LEVEL_2_1",
		"H264_LEVEL_2_2",
		"H264_LEVEL_3",
		"H264_LEVEL_3_1",
		"H264_LEVEL_3_2",
		"H264_LEVEL_4",
		"H264_LEVEL_4_1",
		"H264_LEVEL_4_2",
		"H264_LEVEL_5",
		"H264_LEVEL_5_1",
		"H264_LEVEL_5_2",
		"H264_LEVEL_AUTO",
	}
}

type H264LookAheadRateControl string

// Enum values for H264LookAheadRateControl
const (
	H264LookAheadRateControlHigh   H264LookAheadRateControl = "HIGH"
	H264LookAheadRateControlLow    H264LookAheadRateControl = "LOW"
	H264LookAheadRateControlMedium H264LookAheadRateControl = "MEDIUM"
)

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

type H264ParControl string

// Enum values for H264ParControl
const (
	H264ParControlInitializeFromSource H264ParControl = "INITIALIZE_FROM_SOURCE"
	H264ParControlSpecified            H264ParControl = "SPECIFIED"
)

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

type H264Profile string

// Enum values for H264Profile
const (
	H264ProfileBaseline     H264Profile = "BASELINE"
	H264ProfileHigh         H264Profile = "HIGH"
	H264ProfileHigh10bit    H264Profile = "HIGH_10BIT"
	H264ProfileHigh422      H264Profile = "HIGH_422"
	H264ProfileHigh42210bit H264Profile = "HIGH_422_10BIT"
	H264ProfileMain         H264Profile = "MAIN"
)

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

type H264QualityLevel string

// Enum values for H264QualityLevel
const (
	H264QualityLevelEnhancedQuality H264QualityLevel = "ENHANCED_QUALITY"
	H264QualityLevelStandardQuality H264QualityLevel = "STANDARD_QUALITY"
)

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

type H264RateControlMode string

// Enum values for H264RateControlMode
const (
	H264RateControlModeCbr       H264RateControlMode = "CBR"
	H264RateControlModeMultiplex H264RateControlMode = "MULTIPLEX"
	H264RateControlModeQvbr      H264RateControlMode = "QVBR"
	H264RateControlModeVbr       H264RateControlMode = "VBR"
)

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

type H264ScanType string

// Enum values for H264ScanType
const (
	H264ScanTypeInterlaced  H264ScanType = "INTERLACED"
	H264ScanTypeProgressive H264ScanType = "PROGRESSIVE"
)

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

type H264SceneChangeDetect string

// Enum values for H264SceneChangeDetect
const (
	H264SceneChangeDetectDisabled H264SceneChangeDetect = "DISABLED"
	H264SceneChangeDetectEnabled  H264SceneChangeDetect = "ENABLED"
)

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

type H264SpatialAq string

// Enum values for H264SpatialAq
const (
	H264SpatialAqDisabled H264SpatialAq = "DISABLED"
	H264SpatialAqEnabled  H264SpatialAq = "ENABLED"
)

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

type H264SubGopLength string

// Enum values for H264SubGopLength
const (
	H264SubGopLengthDynamic H264SubGopLength = "DYNAMIC"
	H264SubGopLengthFixed   H264SubGopLength = "FIXED"
)

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

type H264Syntax string

// Enum values for H264Syntax
const (
	H264SyntaxDefault H264Syntax = "DEFAULT"
	H264SyntaxRp2027  H264Syntax = "RP2027"
)

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

type H264TemporalAq string

// Enum values for H264TemporalAq
const (
	H264TemporalAqDisabled H264TemporalAq = "DISABLED"
	H264TemporalAqEnabled  H264TemporalAq = "ENABLED"
)

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

type H264TimecodeInsertionBehavior string

// Enum values for H264TimecodeInsertionBehavior
const (
	H264TimecodeInsertionBehaviorDisabled     H264TimecodeInsertionBehavior = "DISABLED"
	H264TimecodeInsertionBehaviorPicTimingSei H264TimecodeInsertionBehavior = "PIC_TIMING_SEI"
)

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

type H265AdaptiveQuantization string

// Enum values for H265AdaptiveQuantization
const (
	H265AdaptiveQuantizationAuto   H265AdaptiveQuantization = "AUTO"
	H265AdaptiveQuantizationHigh   H265AdaptiveQuantization = "HIGH"
	H265AdaptiveQuantizationHigher H265AdaptiveQuantization = "HIGHER"
	H265AdaptiveQuantizationLow    H265AdaptiveQuantization = "LOW"
	H265AdaptiveQuantizationMax    H265AdaptiveQuantization = "MAX"
	H265AdaptiveQuantizationMedium H265AdaptiveQuantization = "MEDIUM"
	H265AdaptiveQuantizationOff    H265AdaptiveQuantization = "OFF"
)

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

type H265AlternativeTransferFunction string

// Enum values for H265AlternativeTransferFunction
const (
	H265AlternativeTransferFunctionInsert H265AlternativeTransferFunction = "INSERT"
	H265AlternativeTransferFunctionOmit   H265AlternativeTransferFunction = "OMIT"
)

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

type H265ColorMetadata string

// Enum values for H265ColorMetadata
const (
	H265ColorMetadataIgnore H265ColorMetadata = "IGNORE"
	H265ColorMetadataInsert H265ColorMetadata = "INSERT"
)

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

type H265FlickerAq string

// Enum values for H265FlickerAq
const (
	H265FlickerAqDisabled H265FlickerAq = "DISABLED"
	H265FlickerAqEnabled  H265FlickerAq = "ENABLED"
)

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

type H265GopSizeUnits string

// Enum values for H265GopSizeUnits
const (
	H265GopSizeUnitsFrames  H265GopSizeUnits = "FRAMES"
	H265GopSizeUnitsSeconds H265GopSizeUnits = "SECONDS"
)

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

type H265Level string

// Enum values for H265Level
const (
	H265LevelH265Level1    H265Level = "H265_LEVEL_1"
	H265LevelH265Level2    H265Level = "H265_LEVEL_2"
	H265LevelH265Level21   H265Level = "H265_LEVEL_2_1"
	H265LevelH265Level3    H265Level = "H265_LEVEL_3"
	H265LevelH265Level31   H265Level = "H265_LEVEL_3_1"
	H265LevelH265Level4    H265Level = "H265_LEVEL_4"
	H265LevelH265Level41   H265Level = "H265_LEVEL_4_1"
	H265LevelH265Level5    H265Level = "H265_LEVEL_5"
	H265LevelH265Level51   H265Level = "H265_LEVEL_5_1"
	H265LevelH265Level52   H265Level = "H265_LEVEL_5_2"
	H265LevelH265Level6    H265Level = "H265_LEVEL_6"
	H265LevelH265Level61   H265Level = "H265_LEVEL_6_1"
	H265LevelH265Level62   H265Level = "H265_LEVEL_6_2"
	H265LevelH265LevelAuto H265Level = "H265_LEVEL_AUTO"
)

// Values returns all known values for H265Level. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (H265Level) Values() []H265Level {
	return []H265Level{
		"H265_LEVEL_1",
		"H265_LEVEL_2",
		"H265_LEVEL_2_1",
		"H265_LEVEL_3",
		"H265_LEVEL_3_1",
		"H265_LEVEL_4",
		"H265_LEVEL_4_1",
		"H265_LEVEL_5",
		"H265_LEVEL_5_1",
		"H265_LEVEL_5_2",
		"H265_LEVEL_6",
		"H265_LEVEL_6_1",
		"H265_LEVEL_6_2",
		"H265_LEVEL_AUTO",
	}
}

type H265LookAheadRateControl string

// Enum values for H265LookAheadRateControl
const (
	H265LookAheadRateControlHigh   H265LookAheadRateControl = "HIGH"
	H265LookAheadRateControlLow    H265LookAheadRateControl = "LOW"
	H265LookAheadRateControlMedium H265LookAheadRateControl = "MEDIUM"
)

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

type H265Profile string

// Enum values for H265Profile
const (
	H265ProfileMain      H265Profile = "MAIN"
	H265ProfileMain10bit H265Profile = "MAIN_10BIT"
)

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

type H265RateControlMode string

// Enum values for H265RateControlMode
const (
	H265RateControlModeCbr       H265RateControlMode = "CBR"
	H265RateControlModeMultiplex H265RateControlMode = "MULTIPLEX"
	H265RateControlModeQvbr      H265RateControlMode = "QVBR"
)

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

type H265ScanType string

// Enum values for H265ScanType
const (
	H265ScanTypeInterlaced  H265ScanType = "INTERLACED"
	H265ScanTypeProgressive H265ScanType = "PROGRESSIVE"
)

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

type H265SceneChangeDetect string

// Enum values for H265SceneChangeDetect
const (
	H265SceneChangeDetectDisabled H265SceneChangeDetect = "DISABLED"
	H265SceneChangeDetectEnabled  H265SceneChangeDetect = "ENABLED"
)

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

type H265Tier string

// Enum values for H265Tier
const (
	H265TierHigh H265Tier = "HIGH"
	H265TierMain H265Tier = "MAIN"
)

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

type H265TimecodeInsertionBehavior string

// Enum values for H265TimecodeInsertionBehavior
const (
	H265TimecodeInsertionBehaviorDisabled     H265TimecodeInsertionBehavior = "DISABLED"
	H265TimecodeInsertionBehaviorPicTimingSei H265TimecodeInsertionBehavior = "PIC_TIMING_SEI"
)

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

type HlsAdMarkers string

// Enum values for HlsAdMarkers
const (
	HlsAdMarkersAdobe           HlsAdMarkers = "ADOBE"
	HlsAdMarkersElemental       HlsAdMarkers = "ELEMENTAL"
	HlsAdMarkersElementalScte35 HlsAdMarkers = "ELEMENTAL_SCTE35"
)

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

type HlsAkamaiHttpTransferMode string

// Enum values for HlsAkamaiHttpTransferMode
const (
	HlsAkamaiHttpTransferModeChunked    HlsAkamaiHttpTransferMode = "CHUNKED"
	HlsAkamaiHttpTransferModeNonChunked HlsAkamaiHttpTransferMode = "NON_CHUNKED"
)

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

type HlsCaptionLanguageSetting string

// Enum values for HlsCaptionLanguageSetting
const (
	HlsCaptionLanguageSettingInsert HlsCaptionLanguageSetting = "INSERT"
	HlsCaptionLanguageSettingNone   HlsCaptionLanguageSetting = "NONE"
	HlsCaptionLanguageSettingOmit   HlsCaptionLanguageSetting = "OMIT"
)

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

type HlsClientCache string

// Enum values for HlsClientCache
const (
	HlsClientCacheDisabled HlsClientCache = "DISABLED"
	HlsClientCacheEnabled  HlsClientCache = "ENABLED"
)

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

type HlsCodecSpecification string

// Enum values for HlsCodecSpecification
const (
	HlsCodecSpecificationRfc4281 HlsCodecSpecification = "RFC_4281"
	HlsCodecSpecificationRfc6381 HlsCodecSpecification = "RFC_6381"
)

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

type HlsDirectoryStructure string

// Enum values for HlsDirectoryStructure
const (
	HlsDirectoryStructureSingleDirectory       HlsDirectoryStructure = "SINGLE_DIRECTORY"
	HlsDirectoryStructureSubdirectoryPerStream HlsDirectoryStructure = "SUBDIRECTORY_PER_STREAM"
)

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

type HlsDiscontinuityTags string

// Enum values for HlsDiscontinuityTags
const (
	HlsDiscontinuityTagsInsert      HlsDiscontinuityTags = "INSERT"
	HlsDiscontinuityTagsNeverInsert HlsDiscontinuityTags = "NEVER_INSERT"
)

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

type HlsEncryptionType string

// Enum values for HlsEncryptionType
const (
	HlsEncryptionTypeAes128    HlsEncryptionType = "AES128"
	HlsEncryptionTypeSampleAes HlsEncryptionType = "SAMPLE_AES"
)

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

type HlsH265PackagingType string

// Enum values for HlsH265PackagingType
const (
	HlsH265PackagingTypeHev1 HlsH265PackagingType = "HEV1"
	HlsH265PackagingTypeHvc1 HlsH265PackagingType = "HVC1"
)

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

type HlsId3SegmentTaggingState string

// Enum values for HlsId3SegmentTaggingState
const (
	HlsId3SegmentTaggingStateDisabled HlsId3SegmentTaggingState = "DISABLED"
	HlsId3SegmentTaggingStateEnabled  HlsId3SegmentTaggingState = "ENABLED"
)

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

type HlsIncompleteSegmentBehavior string

// Enum values for HlsIncompleteSegmentBehavior
const (
	HlsIncompleteSegmentBehaviorAuto     HlsIncompleteSegmentBehavior = "AUTO"
	HlsIncompleteSegmentBehaviorSuppress HlsIncompleteSegmentBehavior = "SUPPRESS"
)

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

type HlsIvInManifest string

// Enum values for HlsIvInManifest
const (
	HlsIvInManifestExclude HlsIvInManifest = "EXCLUDE"
	HlsIvInManifestInclude HlsIvInManifest = "INCLUDE"
)

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

type HlsIvSource string

// Enum values for HlsIvSource
const (
	HlsIvSourceExplicit             HlsIvSource = "EXPLICIT"
	HlsIvSourceFollowsSegmentNumber HlsIvSource = "FOLLOWS_SEGMENT_NUMBER"
)

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

type HlsManifestCompression string

// Enum values for HlsManifestCompression
const (
	HlsManifestCompressionGzip HlsManifestCompression = "GZIP"
	HlsManifestCompressionNone HlsManifestCompression = "NONE"
)

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

type HlsManifestDurationFormat string

// Enum values for HlsManifestDurationFormat
const (
	HlsManifestDurationFormatFloatingPoint HlsManifestDurationFormat = "FLOATING_POINT"
	HlsManifestDurationFormatInteger       HlsManifestDurationFormat = "INTEGER"
)

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

type HlsMediaStoreStorageClass string

// Enum values for HlsMediaStoreStorageClass
const (
	HlsMediaStoreStorageClassTemporal HlsMediaStoreStorageClass = "TEMPORAL"
)

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

type HlsMode string

// Enum values for HlsMode
const (
	HlsModeLive HlsMode = "LIVE"
	HlsModeVod  HlsMode = "VOD"
)

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

type HlsOutputSelection string

// Enum values for HlsOutputSelection
const (
	HlsOutputSelectionManifestsAndSegments        HlsOutputSelection = "MANIFESTS_AND_SEGMENTS"
	HlsOutputSelectionSegmentsOnly                HlsOutputSelection = "SEGMENTS_ONLY"
	HlsOutputSelectionVariantManifestsAndSegments HlsOutputSelection = "VARIANT_MANIFESTS_AND_SEGMENTS"
)

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

type HlsProgramDateTime string

// Enum values for HlsProgramDateTime
const (
	HlsProgramDateTimeExclude HlsProgramDateTime = "EXCLUDE"
	HlsProgramDateTimeInclude HlsProgramDateTime = "INCLUDE"
)

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

type HlsProgramDateTimeClock string

// Enum values for HlsProgramDateTimeClock
const (
	HlsProgramDateTimeClockInitializeFromOutputTimecode HlsProgramDateTimeClock = "INITIALIZE_FROM_OUTPUT_TIMECODE"
	HlsProgramDateTimeClockSystemClock                  HlsProgramDateTimeClock = "SYSTEM_CLOCK"
)

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

type HlsRedundantManifest string

// Enum values for HlsRedundantManifest
const (
	HlsRedundantManifestDisabled HlsRedundantManifest = "DISABLED"
	HlsRedundantManifestEnabled  HlsRedundantManifest = "ENABLED"
)

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

type HlsScte35SourceType string

// Enum values for HlsScte35SourceType
const (
	HlsScte35SourceTypeManifest HlsScte35SourceType = "MANIFEST"
	HlsScte35SourceTypeSegments HlsScte35SourceType = "SEGMENTS"
)

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

type HlsSegmentationMode string

// Enum values for HlsSegmentationMode
const (
	HlsSegmentationModeUseInputSegmentation HlsSegmentationMode = "USE_INPUT_SEGMENTATION"
	HlsSegmentationModeUseSegmentDuration   HlsSegmentationMode = "USE_SEGMENT_DURATION"
)

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

type HlsStreamInfResolution string

// Enum values for HlsStreamInfResolution
const (
	HlsStreamInfResolutionExclude HlsStreamInfResolution = "EXCLUDE"
	HlsStreamInfResolutionInclude HlsStreamInfResolution = "INCLUDE"
)

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

type HlsTimedMetadataId3Frame string

// Enum values for HlsTimedMetadataId3Frame
const (
	HlsTimedMetadataId3FrameNone HlsTimedMetadataId3Frame = "NONE"
	HlsTimedMetadataId3FramePriv HlsTimedMetadataId3Frame = "PRIV"
	HlsTimedMetadataId3FrameTdrl HlsTimedMetadataId3Frame = "TDRL"
)

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

type HlsTsFileMode string

// Enum values for HlsTsFileMode
const (
	HlsTsFileModeSegmentedFiles HlsTsFileMode = "SEGMENTED_FILES"
	HlsTsFileModeSingleFile     HlsTsFileMode = "SINGLE_FILE"
)

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

type HlsWebdavHttpTransferMode string

// Enum values for HlsWebdavHttpTransferMode
const (
	HlsWebdavHttpTransferModeChunked    HlsWebdavHttpTransferMode = "CHUNKED"
	HlsWebdavHttpTransferModeNonChunked HlsWebdavHttpTransferMode = "NON_CHUNKED"
)

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

type IFrameOnlyPlaylistType string

// Enum values for IFrameOnlyPlaylistType
const (
	IFrameOnlyPlaylistTypeDisabled IFrameOnlyPlaylistType = "DISABLED"
	IFrameOnlyPlaylistTypeStandard IFrameOnlyPlaylistType = "STANDARD"
)

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

type InputClass string

// Enum values for InputClass
const (
	InputClassStandard       InputClass = "STANDARD"
	InputClassSinglePipeline InputClass = "SINGLE_PIPELINE"
)

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

type InputCodec string

// Enum values for InputCodec
const (
	InputCodecMpeg2 InputCodec = "MPEG2"
	InputCodecAvc   InputCodec = "AVC"
	InputCodecHevc  InputCodec = "HEVC"
)

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

type InputDeblockFilter string

// Enum values for InputDeblockFilter
const (
	InputDeblockFilterDisabled InputDeblockFilter = "DISABLED"
	InputDeblockFilterEnabled  InputDeblockFilter = "ENABLED"
)

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

type InputDenoiseFilter string

// Enum values for InputDenoiseFilter
const (
	InputDenoiseFilterDisabled InputDenoiseFilter = "DISABLED"
	InputDenoiseFilterEnabled  InputDenoiseFilter = "ENABLED"
)

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

type InputDeviceActiveInput string

// Enum values for InputDeviceActiveInput
const (
	InputDeviceActiveInputHdmi InputDeviceActiveInput = "HDMI"
	InputDeviceActiveInputSdi  InputDeviceActiveInput = "SDI"
)

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

type InputDeviceConfiguredInput string

// Enum values for InputDeviceConfiguredInput
const (
	InputDeviceConfiguredInputAuto InputDeviceConfiguredInput = "AUTO"
	InputDeviceConfiguredInputHdmi InputDeviceConfiguredInput = "HDMI"
	InputDeviceConfiguredInputSdi  InputDeviceConfiguredInput = "SDI"
)

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

type InputDeviceConnectionState string

// Enum values for InputDeviceConnectionState
const (
	InputDeviceConnectionStateDisconnected InputDeviceConnectionState = "DISCONNECTED"
	InputDeviceConnectionStateConnected    InputDeviceConnectionState = "CONNECTED"
)

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

type InputDeviceIpScheme string

// Enum values for InputDeviceIpScheme
const (
	InputDeviceIpSchemeStatic InputDeviceIpScheme = "STATIC"
	InputDeviceIpSchemeDhcp   InputDeviceIpScheme = "DHCP"
)

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

type InputDeviceScanType string

// Enum values for InputDeviceScanType
const (
	InputDeviceScanTypeInterlaced  InputDeviceScanType = "INTERLACED"
	InputDeviceScanTypeProgressive InputDeviceScanType = "PROGRESSIVE"
)

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

type InputDeviceState string

// Enum values for InputDeviceState
const (
	InputDeviceStateIdle      InputDeviceState = "IDLE"
	InputDeviceStateStreaming InputDeviceState = "STREAMING"
)

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

type InputDeviceTransferType string

// Enum values for InputDeviceTransferType
const (
	InputDeviceTransferTypeOutgoing InputDeviceTransferType = "OUTGOING"
	InputDeviceTransferTypeIncoming InputDeviceTransferType = "INCOMING"
)

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

type InputDeviceType string

// Enum values for InputDeviceType
const (
	InputDeviceTypeHd  InputDeviceType = "HD"
	InputDeviceTypeUhd InputDeviceType = "UHD"
)

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

type InputFilter string

// Enum values for InputFilter
const (
	InputFilterAuto     InputFilter = "AUTO"
	InputFilterDisabled InputFilter = "DISABLED"
	InputFilterForced   InputFilter = "FORCED"
)

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

type InputLossActionForHlsOut string

// Enum values for InputLossActionForHlsOut
const (
	InputLossActionForHlsOutEmitOutput  InputLossActionForHlsOut = "EMIT_OUTPUT"
	InputLossActionForHlsOutPauseOutput InputLossActionForHlsOut = "PAUSE_OUTPUT"
)

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

type InputLossActionForMsSmoothOut string

// Enum values for InputLossActionForMsSmoothOut
const (
	InputLossActionForMsSmoothOutEmitOutput  InputLossActionForMsSmoothOut = "EMIT_OUTPUT"
	InputLossActionForMsSmoothOutPauseOutput InputLossActionForMsSmoothOut = "PAUSE_OUTPUT"
)

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

type InputLossActionForRtmpOut string

// Enum values for InputLossActionForRtmpOut
const (
	InputLossActionForRtmpOutEmitOutput  InputLossActionForRtmpOut = "EMIT_OUTPUT"
	InputLossActionForRtmpOutPauseOutput InputLossActionForRtmpOut = "PAUSE_OUTPUT"
)

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

type InputLossActionForUdpOut string

// Enum values for InputLossActionForUdpOut
const (
	InputLossActionForUdpOutDropProgram InputLossActionForUdpOut = "DROP_PROGRAM"
	InputLossActionForUdpOutDropTs      InputLossActionForUdpOut = "DROP_TS"
	InputLossActionForUdpOutEmitProgram InputLossActionForUdpOut = "EMIT_PROGRAM"
)

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

type InputLossImageType string

// Enum values for InputLossImageType
const (
	InputLossImageTypeColor InputLossImageType = "COLOR"
	InputLossImageTypeSlate InputLossImageType = "SLATE"
)

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

type InputMaximumBitrate string

// Enum values for InputMaximumBitrate
const (
	InputMaximumBitrateMax10Mbps InputMaximumBitrate = "MAX_10_MBPS"
	InputMaximumBitrateMax20Mbps InputMaximumBitrate = "MAX_20_MBPS"
	InputMaximumBitrateMax50Mbps InputMaximumBitrate = "MAX_50_MBPS"
)

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

type InputPreference string

// Enum values for InputPreference
const (
	InputPreferenceEqualInputPreference  InputPreference = "EQUAL_INPUT_PREFERENCE"
	InputPreferencePrimaryInputPreferred InputPreference = "PRIMARY_INPUT_PREFERRED"
)

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

type InputResolution string

// Enum values for InputResolution
const (
	InputResolutionSd  InputResolution = "SD"
	InputResolutionHd  InputResolution = "HD"
	InputResolutionUhd InputResolution = "UHD"
)

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

type InputSecurityGroupState string

// Enum values for InputSecurityGroupState
const (
	InputSecurityGroupStateIdle     InputSecurityGroupState = "IDLE"
	InputSecurityGroupStateInUse    InputSecurityGroupState = "IN_USE"
	InputSecurityGroupStateUpdating InputSecurityGroupState = "UPDATING"
	InputSecurityGroupStateDeleted  InputSecurityGroupState = "DELETED"
)

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

type InputSourceEndBehavior string

// Enum values for InputSourceEndBehavior
const (
	InputSourceEndBehaviorContinue InputSourceEndBehavior = "CONTINUE"
	InputSourceEndBehaviorLoop     InputSourceEndBehavior = "LOOP"
)

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

type InputSourceType string

// Enum values for InputSourceType
const (
	InputSourceTypeStatic  InputSourceType = "STATIC"
	InputSourceTypeDynamic InputSourceType = "DYNAMIC"
)

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

type InputState string

// Enum values for InputState
const (
	InputStateCreating InputState = "CREATING"
	InputStateDetached InputState = "DETACHED"
	InputStateAttached InputState = "ATTACHED"
	InputStateDeleting InputState = "DELETING"
	InputStateDeleted  InputState = "DELETED"
)

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

type InputTimecodeSource string

// Enum values for InputTimecodeSource
const (
	InputTimecodeSourceZerobased InputTimecodeSource = "ZEROBASED"
	InputTimecodeSourceEmbedded  InputTimecodeSource = "EMBEDDED"
)

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

type InputType string

// Enum values for InputType
const (
	InputTypeUdpPush      InputType = "UDP_PUSH"
	InputTypeRtpPush      InputType = "RTP_PUSH"
	InputTypeRtmpPush     InputType = "RTMP_PUSH"
	InputTypeRtmpPull     InputType = "RTMP_PULL"
	InputTypeUrlPull      InputType = "URL_PULL"
	InputTypeMp4File      InputType = "MP4_FILE"
	InputTypeMediaconnect InputType = "MEDIACONNECT"
	InputTypeInputDevice  InputType = "INPUT_DEVICE"
	InputTypeAwsCdi       InputType = "AWS_CDI"
	InputTypeTsFile       InputType = "TS_FILE"
)

// Values returns all known values for InputType. Note that this can be expanded
// in the future, and so it is only as up to date as the client. The ordering of
// this slice is not guaranteed to be stable across updates.
func (InputType) Values() []InputType {
	return []InputType{
		"UDP_PUSH",
		"RTP_PUSH",
		"RTMP_PUSH",
		"RTMP_PULL",
		"URL_PULL",
		"MP4_FILE",
		"MEDIACONNECT",
		"INPUT_DEVICE",
		"AWS_CDI",
		"TS_FILE",
	}
}

type LastFrameClippingBehavior string

// Enum values for LastFrameClippingBehavior
const (
	LastFrameClippingBehaviorExcludeLastFrame LastFrameClippingBehavior = "EXCLUDE_LAST_FRAME"
	LastFrameClippingBehaviorIncludeLastFrame LastFrameClippingBehavior = "INCLUDE_LAST_FRAME"
)

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

type LogLevel string

// Enum values for LogLevel
const (
	LogLevelError    LogLevel = "ERROR"
	LogLevelWarning  LogLevel = "WARNING"
	LogLevelInfo     LogLevel = "INFO"
	LogLevelDebug    LogLevel = "DEBUG"
	LogLevelDisabled LogLevel = "DISABLED"
)

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

type M2tsAbsentInputAudioBehavior string

// Enum values for M2tsAbsentInputAudioBehavior
const (
	M2tsAbsentInputAudioBehaviorDrop          M2tsAbsentInputAudioBehavior = "DROP"
	M2tsAbsentInputAudioBehaviorEncodeSilence M2tsAbsentInputAudioBehavior = "ENCODE_SILENCE"
)

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

type M2tsArib string

// Enum values for M2tsArib
const (
	M2tsAribDisabled M2tsArib = "DISABLED"
	M2tsAribEnabled  M2tsArib = "ENABLED"
)

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

type M2tsAribCaptionsPidControl string

// Enum values for M2tsAribCaptionsPidControl
const (
	M2tsAribCaptionsPidControlAuto          M2tsAribCaptionsPidControl = "AUTO"
	M2tsAribCaptionsPidControlUseConfigured M2tsAribCaptionsPidControl = "USE_CONFIGURED"
)

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

type M2tsAudioBufferModel string

// Enum values for M2tsAudioBufferModel
const (
	M2tsAudioBufferModelAtsc M2tsAudioBufferModel = "ATSC"
	M2tsAudioBufferModelDvb  M2tsAudioBufferModel = "DVB"
)

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

type M2tsAudioInterval string

// Enum values for M2tsAudioInterval
const (
	M2tsAudioIntervalVideoAndFixedIntervals M2tsAudioInterval = "VIDEO_AND_FIXED_INTERVALS"
	M2tsAudioIntervalVideoInterval          M2tsAudioInterval = "VIDEO_INTERVAL"
)

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

type M2tsAudioStreamType string

// Enum values for M2tsAudioStreamType
const (
	M2tsAudioStreamTypeAtsc M2tsAudioStreamType = "ATSC"
	M2tsAudioStreamTypeDvb  M2tsAudioStreamType = "DVB"
)

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

type M2tsBufferModel string

// Enum values for M2tsBufferModel
const (
	M2tsBufferModelMultiplex M2tsBufferModel = "MULTIPLEX"
	M2tsBufferModelNone      M2tsBufferModel = "NONE"
)

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

type M2tsCcDescriptor string

// Enum values for M2tsCcDescriptor
const (
	M2tsCcDescriptorDisabled M2tsCcDescriptor = "DISABLED"
	M2tsCcDescriptorEnabled  M2tsCcDescriptor = "ENABLED"
)

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

type M2tsEbifControl string

// Enum values for M2tsEbifControl
const (
	M2tsEbifControlNone        M2tsEbifControl = "NONE"
	M2tsEbifControlPassthrough M2tsEbifControl = "PASSTHROUGH"
)

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

type M2tsEbpPlacement string

// Enum values for M2tsEbpPlacement
const (
	M2tsEbpPlacementVideoAndAudioPids M2tsEbpPlacement = "VIDEO_AND_AUDIO_PIDS"
	M2tsEbpPlacementVideoPid          M2tsEbpPlacement = "VIDEO_PID"
)

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

type M2tsEsRateInPes string

// Enum values for M2tsEsRateInPes
const (
	M2tsEsRateInPesExclude M2tsEsRateInPes = "EXCLUDE"
	M2tsEsRateInPesInclude M2tsEsRateInPes = "INCLUDE"
)

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

type M2tsKlv string

// Enum values for M2tsKlv
const (
	M2tsKlvNone        M2tsKlv = "NONE"
	M2tsKlvPassthrough M2tsKlv = "PASSTHROUGH"
)

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

type M2tsNielsenId3Behavior string

// Enum values for M2tsNielsenId3Behavior
const (
	M2tsNielsenId3BehaviorNoPassthrough M2tsNielsenId3Behavior = "NO_PASSTHROUGH"
	M2tsNielsenId3BehaviorPassthrough   M2tsNielsenId3Behavior = "PASSTHROUGH"
)

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

type M2tsPcrControl string

// Enum values for M2tsPcrControl
const (
	M2tsPcrControlConfiguredPcrPeriod M2tsPcrControl = "CONFIGURED_PCR_PERIOD"
	M2tsPcrControlPcrEveryPesPacket   M2tsPcrControl = "PCR_EVERY_PES_PACKET"
)

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

type M2tsRateMode string

// Enum values for M2tsRateMode
const (
	M2tsRateModeCbr M2tsRateMode = "CBR"
	M2tsRateModeVbr M2tsRateMode = "VBR"
)

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

type M2tsScte35Control string

// Enum values for M2tsScte35Control
const (
	M2tsScte35ControlNone        M2tsScte35Control = "NONE"
	M2tsScte35ControlPassthrough M2tsScte35Control = "PASSTHROUGH"
)

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

type M2tsSegmentationMarkers string

// Enum values for M2tsSegmentationMarkers
const (
	M2tsSegmentationMarkersEbp         M2tsSegmentationMarkers = "EBP"
	M2tsSegmentationMarkersEbpLegacy   M2tsSegmentationMarkers = "EBP_LEGACY"
	M2tsSegmentationMarkersNone        M2tsSegmentationMarkers = "NONE"
	M2tsSegmentationMarkersPsiSegstart M2tsSegmentationMarkers = "PSI_SEGSTART"
	M2tsSegmentationMarkersRaiAdapt    M2tsSegmentationMarkers = "RAI_ADAPT"
	M2tsSegmentationMarkersRaiSegstart M2tsSegmentationMarkers = "RAI_SEGSTART"
)

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

type M2tsSegmentationStyle string

// Enum values for M2tsSegmentationStyle
const (
	M2tsSegmentationStyleMaintainCadence M2tsSegmentationStyle = "MAINTAIN_CADENCE"
	M2tsSegmentationStyleResetCadence    M2tsSegmentationStyle = "RESET_CADENCE"
)

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

type M2tsTimedMetadataBehavior string

// Enum values for M2tsTimedMetadataBehavior
const (
	M2tsTimedMetadataBehaviorNoPassthrough M2tsTimedMetadataBehavior = "NO_PASSTHROUGH"
	M2tsTimedMetadataBehaviorPassthrough   M2tsTimedMetadataBehavior = "PASSTHROUGH"
)

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

type M3u8NielsenId3Behavior string

// Enum values for M3u8NielsenId3Behavior
const (
	M3u8NielsenId3BehaviorNoPassthrough M3u8NielsenId3Behavior = "NO_PASSTHROUGH"
	M3u8NielsenId3BehaviorPassthrough   M3u8NielsenId3Behavior = "PASSTHROUGH"
)

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

type M3u8PcrControl string

// Enum values for M3u8PcrControl
const (
	M3u8PcrControlConfiguredPcrPeriod M3u8PcrControl = "CONFIGURED_PCR_PERIOD"
	M3u8PcrControlPcrEveryPesPacket   M3u8PcrControl = "PCR_EVERY_PES_PACKET"
)

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

type M3u8Scte35Behavior string

// Enum values for M3u8Scte35Behavior
const (
	M3u8Scte35BehaviorNoPassthrough M3u8Scte35Behavior = "NO_PASSTHROUGH"
	M3u8Scte35BehaviorPassthrough   M3u8Scte35Behavior = "PASSTHROUGH"
)

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

type M3u8TimedMetadataBehavior string

// Enum values for M3u8TimedMetadataBehavior
const (
	M3u8TimedMetadataBehaviorNoPassthrough M3u8TimedMetadataBehavior = "NO_PASSTHROUGH"
	M3u8TimedMetadataBehaviorPassthrough   M3u8TimedMetadataBehavior = "PASSTHROUGH"
)

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

type MaintenanceDay string

// Enum values for MaintenanceDay
const (
	MaintenanceDayMonday    MaintenanceDay = "MONDAY"
	MaintenanceDayTuesday   MaintenanceDay = "TUESDAY"
	MaintenanceDayWednesday MaintenanceDay = "WEDNESDAY"
	MaintenanceDayThursday  MaintenanceDay = "THURSDAY"
	MaintenanceDayFriday    MaintenanceDay = "FRIDAY"
	MaintenanceDaySaturday  MaintenanceDay = "SATURDAY"
	MaintenanceDaySunday    MaintenanceDay = "SUNDAY"
)

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

type MotionGraphicsInsertion string

// Enum values for MotionGraphicsInsertion
const (
	MotionGraphicsInsertionDisabled MotionGraphicsInsertion = "DISABLED"
	MotionGraphicsInsertionEnabled  MotionGraphicsInsertion = "ENABLED"
)

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

type Mp2CodingMode string

// Enum values for Mp2CodingMode
const (
	Mp2CodingModeCodingMode10 Mp2CodingMode = "CODING_MODE_1_0"
	Mp2CodingModeCodingMode20 Mp2CodingMode = "CODING_MODE_2_0"
)

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

type Mpeg2AdaptiveQuantization string

// Enum values for Mpeg2AdaptiveQuantization
const (
	Mpeg2AdaptiveQuantizationAuto   Mpeg2AdaptiveQuantization = "AUTO"
	Mpeg2AdaptiveQuantizationHigh   Mpeg2AdaptiveQuantization = "HIGH"
	Mpeg2AdaptiveQuantizationLow    Mpeg2AdaptiveQuantization = "LOW"
	Mpeg2AdaptiveQuantizationMedium Mpeg2AdaptiveQuantization = "MEDIUM"
	Mpeg2AdaptiveQuantizationOff    Mpeg2AdaptiveQuantization = "OFF"
)

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

type Mpeg2ColorMetadata string

// Enum values for Mpeg2ColorMetadata
const (
	Mpeg2ColorMetadataIgnore Mpeg2ColorMetadata = "IGNORE"
	Mpeg2ColorMetadataInsert Mpeg2ColorMetadata = "INSERT"
)

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

type Mpeg2ColorSpace string

// Enum values for Mpeg2ColorSpace
const (
	Mpeg2ColorSpaceAuto        Mpeg2ColorSpace = "AUTO"
	Mpeg2ColorSpacePassthrough Mpeg2ColorSpace = "PASSTHROUGH"
)

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

type Mpeg2DisplayRatio string

// Enum values for Mpeg2DisplayRatio
const (
	Mpeg2DisplayRatioDisplayratio16x9 Mpeg2DisplayRatio = "DISPLAYRATIO16X9"
	Mpeg2DisplayRatioDisplayratio4x3  Mpeg2DisplayRatio = "DISPLAYRATIO4X3"
)

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

type Mpeg2GopSizeUnits string

// Enum values for Mpeg2GopSizeUnits
const (
	Mpeg2GopSizeUnitsFrames  Mpeg2GopSizeUnits = "FRAMES"
	Mpeg2GopSizeUnitsSeconds Mpeg2GopSizeUnits = "SECONDS"
)

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

type Mpeg2ScanType string

// Enum values for Mpeg2ScanType
const (
	Mpeg2ScanTypeInterlaced  Mpeg2ScanType = "INTERLACED"
	Mpeg2ScanTypeProgressive Mpeg2ScanType = "PROGRESSIVE"
)

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

type Mpeg2SubGopLength string

// Enum values for Mpeg2SubGopLength
const (
	Mpeg2SubGopLengthDynamic Mpeg2SubGopLength = "DYNAMIC"
	Mpeg2SubGopLengthFixed   Mpeg2SubGopLength = "FIXED"
)

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

type Mpeg2TimecodeInsertionBehavior string

// Enum values for Mpeg2TimecodeInsertionBehavior
const (
	Mpeg2TimecodeInsertionBehaviorDisabled    Mpeg2TimecodeInsertionBehavior = "DISABLED"
	Mpeg2TimecodeInsertionBehaviorGopTimecode Mpeg2TimecodeInsertionBehavior = "GOP_TIMECODE"
)

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

type MsSmoothH265PackagingType string

// Enum values for MsSmoothH265PackagingType
const (
	MsSmoothH265PackagingTypeHev1 MsSmoothH265PackagingType = "HEV1"
	MsSmoothH265PackagingTypeHvc1 MsSmoothH265PackagingType = "HVC1"
)

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

type MultiplexState string

// Enum values for MultiplexState
const (
	MultiplexStateCreating     MultiplexState = "CREATING"
	MultiplexStateCreateFailed MultiplexState = "CREATE_FAILED"
	MultiplexStateIdle         MultiplexState = "IDLE"
	MultiplexStateStarting     MultiplexState = "STARTING"
	MultiplexStateRunning      MultiplexState = "RUNNING"
	MultiplexStateRecovering   MultiplexState = "RECOVERING"
	MultiplexStateStopping     MultiplexState = "STOPPING"
	MultiplexStateDeleting     MultiplexState = "DELETING"
	MultiplexStateDeleted      MultiplexState = "DELETED"
)

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

type NetworkInputServerValidation string

// Enum values for NetworkInputServerValidation
const (
	NetworkInputServerValidationCheckCryptographyAndValidateName NetworkInputServerValidation = "CHECK_CRYPTOGRAPHY_AND_VALIDATE_NAME"
	NetworkInputServerValidationCheckCryptographyOnly            NetworkInputServerValidation = "CHECK_CRYPTOGRAPHY_ONLY"
)

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

type NielsenPcmToId3TaggingState string

// Enum values for NielsenPcmToId3TaggingState
const (
	NielsenPcmToId3TaggingStateDisabled NielsenPcmToId3TaggingState = "DISABLED"
	NielsenPcmToId3TaggingStateEnabled  NielsenPcmToId3TaggingState = "ENABLED"
)

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

type NielsenWatermarksCbetStepaside string

// Enum values for NielsenWatermarksCbetStepaside
const (
	NielsenWatermarksCbetStepasideDisabled NielsenWatermarksCbetStepaside = "DISABLED"
	NielsenWatermarksCbetStepasideEnabled  NielsenWatermarksCbetStepaside = "ENABLED"
)

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

type NielsenWatermarksDistributionTypes string

// Enum values for NielsenWatermarksDistributionTypes
const (
	NielsenWatermarksDistributionTypesFinalDistributor NielsenWatermarksDistributionTypes = "FINAL_DISTRIBUTOR"
	NielsenWatermarksDistributionTypesProgramContent   NielsenWatermarksDistributionTypes = "PROGRAM_CONTENT"
)

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

type NielsenWatermarkTimezones string

// Enum values for NielsenWatermarkTimezones
const (
	NielsenWatermarkTimezonesAmericaPuertoRico NielsenWatermarkTimezones = "AMERICA_PUERTO_RICO"
	NielsenWatermarkTimezonesUsAlaska          NielsenWatermarkTimezones = "US_ALASKA"
	NielsenWatermarkTimezonesUsArizona         NielsenWatermarkTimezones = "US_ARIZONA"
	NielsenWatermarkTimezonesUsCentral         NielsenWatermarkTimezones = "US_CENTRAL"
	NielsenWatermarkTimezonesUsEastern         NielsenWatermarkTimezones = "US_EASTERN"
	NielsenWatermarkTimezonesUsHawaii          NielsenWatermarkTimezones = "US_HAWAII"
	NielsenWatermarkTimezonesUsMountain        NielsenWatermarkTimezones = "US_MOUNTAIN"
	NielsenWatermarkTimezonesUsPacific         NielsenWatermarkTimezones = "US_PACIFIC"
	NielsenWatermarkTimezonesUsSamoa           NielsenWatermarkTimezones = "US_SAMOA"
	NielsenWatermarkTimezonesUtc               NielsenWatermarkTimezones = "UTC"
)

// Values returns all known values for NielsenWatermarkTimezones. Note that this
// can be expanded in the future, and so it is only as up to date as the client.
// The ordering of this slice is not guaranteed to be stable across updates.
func (NielsenWatermarkTimezones) Values() []NielsenWatermarkTimezones {
	return []NielsenWatermarkTimezones{
		"AMERICA_PUERTO_RICO",
		"US_ALASKA",
		"US_ARIZONA",
		"US_CENTRAL",
		"US_EASTERN",
		"US_HAWAII",
		"US_MOUNTAIN",
		"US_PACIFIC",
		"US_SAMOA",
		"UTC",
	}
}

type OfferingDurationUnits string

// Enum values for OfferingDurationUnits
const (
	OfferingDurationUnitsMonths OfferingDurationUnits = "MONTHS"
)

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

type OfferingType string

// Enum values for OfferingType
const (
	OfferingTypeNoUpfront OfferingType = "NO_UPFRONT"
)

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

type PipelineId string

// Enum values for PipelineId
const (
	PipelineIdPipeline0 PipelineId = "PIPELINE_0"
	PipelineIdPipeline1 PipelineId = "PIPELINE_1"
)

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

type PreferredChannelPipeline string

// Enum values for PreferredChannelPipeline
const (
	PreferredChannelPipelineCurrentlyActive PreferredChannelPipeline = "CURRENTLY_ACTIVE"
	PreferredChannelPipelinePipeline0       PreferredChannelPipeline = "PIPELINE_0"
	PreferredChannelPipelinePipeline1       PreferredChannelPipeline = "PIPELINE_1"
)

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

type RebootInputDeviceForce string

// Enum values for RebootInputDeviceForce
const (
	RebootInputDeviceForceNo  RebootInputDeviceForce = "NO"
	RebootInputDeviceForceYes RebootInputDeviceForce = "YES"
)

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

type ReservationAutomaticRenewal string

// Enum values for ReservationAutomaticRenewal
const (
	ReservationAutomaticRenewalDisabled    ReservationAutomaticRenewal = "DISABLED"
	ReservationAutomaticRenewalEnabled     ReservationAutomaticRenewal = "ENABLED"
	ReservationAutomaticRenewalUnavailable ReservationAutomaticRenewal = "UNAVAILABLE"
)

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

type ReservationCodec string

// Enum values for ReservationCodec
const (
	ReservationCodecMpeg2 ReservationCodec = "MPEG2"
	ReservationCodecAvc   ReservationCodec = "AVC"
	ReservationCodecHevc  ReservationCodec = "HEVC"
	ReservationCodecAudio ReservationCodec = "AUDIO"
	ReservationCodecLink  ReservationCodec = "LINK"
)

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

type ReservationMaximumBitrate string

// Enum values for ReservationMaximumBitrate
const (
	ReservationMaximumBitrateMax10Mbps ReservationMaximumBitrate = "MAX_10_MBPS"
	ReservationMaximumBitrateMax20Mbps ReservationMaximumBitrate = "MAX_20_MBPS"
	ReservationMaximumBitrateMax50Mbps ReservationMaximumBitrate = "MAX_50_MBPS"
)

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

type ReservationMaximumFramerate string

// Enum values for ReservationMaximumFramerate
const (
	ReservationMaximumFramerateMax30Fps ReservationMaximumFramerate = "MAX_30_FPS"
	ReservationMaximumFramerateMax60Fps ReservationMaximumFramerate = "MAX_60_FPS"
)

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

type ReservationResolution string

// Enum values for ReservationResolution
const (
	ReservationResolutionSd  ReservationResolution = "SD"
	ReservationResolutionHd  ReservationResolution = "HD"
	ReservationResolutionFhd ReservationResolution = "FHD"
	ReservationResolutionUhd ReservationResolution = "UHD"
)

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

type ReservationResourceType string

// Enum values for ReservationResourceType
const (
	ReservationResourceTypeInput     ReservationResourceType = "INPUT"
	ReservationResourceTypeOutput    ReservationResourceType = "OUTPUT"
	ReservationResourceTypeMultiplex ReservationResourceType = "MULTIPLEX"
	ReservationResourceTypeChannel   ReservationResourceType = "CHANNEL"
)

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

type ReservationSpecialFeature string

// Enum values for ReservationSpecialFeature
const (
	ReservationSpecialFeatureAdvancedAudio      ReservationSpecialFeature = "ADVANCED_AUDIO"
	ReservationSpecialFeatureAudioNormalization ReservationSpecialFeature = "AUDIO_NORMALIZATION"
	ReservationSpecialFeatureMghd               ReservationSpecialFeature = "MGHD"
	ReservationSpecialFeatureMguhd              ReservationSpecialFeature = "MGUHD"
)

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

type ReservationState string

// Enum values for ReservationState
const (
	ReservationStateActive   ReservationState = "ACTIVE"
	ReservationStateExpired  ReservationState = "EXPIRED"
	ReservationStateCanceled ReservationState = "CANCELED"
	ReservationStateDeleted  ReservationState = "DELETED"
)

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

type ReservationVideoQuality string

// Enum values for ReservationVideoQuality
const (
	ReservationVideoQualityStandard ReservationVideoQuality = "STANDARD"
	ReservationVideoQualityEnhanced ReservationVideoQuality = "ENHANCED"
	ReservationVideoQualityPremium  ReservationVideoQuality = "PREMIUM"
)

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

type RtmpAdMarkers string

// Enum values for RtmpAdMarkers
const (
	RtmpAdMarkersOnCuePointScte35 RtmpAdMarkers = "ON_CUE_POINT_SCTE35"
)

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

type RtmpCacheFullBehavior string

// Enum values for RtmpCacheFullBehavior
const (
	RtmpCacheFullBehaviorDisconnectImmediately RtmpCacheFullBehavior = "DISCONNECT_IMMEDIATELY"
	RtmpCacheFullBehaviorWaitForServer         RtmpCacheFullBehavior = "WAIT_FOR_SERVER"
)

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

type RtmpCaptionData string

// Enum values for RtmpCaptionData
const (
	RtmpCaptionDataAll                RtmpCaptionData = "ALL"
	RtmpCaptionDataField1608          RtmpCaptionData = "FIELD1_608"
	RtmpCaptionDataField1AndField2608 RtmpCaptionData = "FIELD1_AND_FIELD2_608"
)

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

type RtmpOutputCertificateMode string

// Enum values for RtmpOutputCertificateMode
const (
	RtmpOutputCertificateModeSelfSigned         RtmpOutputCertificateMode = "SELF_SIGNED"
	RtmpOutputCertificateModeVerifyAuthenticity RtmpOutputCertificateMode = "VERIFY_AUTHENTICITY"
)

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

type S3CannedAcl string

// Enum values for S3CannedAcl
const (
	S3CannedAclAuthenticatedRead      S3CannedAcl = "AUTHENTICATED_READ"
	S3CannedAclBucketOwnerFullControl S3CannedAcl = "BUCKET_OWNER_FULL_CONTROL"
	S3CannedAclBucketOwnerRead        S3CannedAcl = "BUCKET_OWNER_READ"
	S3CannedAclPublicRead             S3CannedAcl = "PUBLIC_READ"
)

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

type Scte20Convert608To708 string

// Enum values for Scte20Convert608To708
const (
	Scte20Convert608To708Disabled  Scte20Convert608To708 = "DISABLED"
	Scte20Convert608To708Upconvert Scte20Convert608To708 = "UPCONVERT"
)

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

type Scte27OcrLanguage string

// Enum values for Scte27OcrLanguage
const (
	Scte27OcrLanguageDeu Scte27OcrLanguage = "DEU"
	Scte27OcrLanguageEng Scte27OcrLanguage = "ENG"
	Scte27OcrLanguageFra Scte27OcrLanguage = "FRA"
	Scte27OcrLanguageNld Scte27OcrLanguage = "NLD"
	Scte27OcrLanguagePor Scte27OcrLanguage = "POR"
	Scte27OcrLanguageSpa Scte27OcrLanguage = "SPA"
)

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

type Scte35AposNoRegionalBlackoutBehavior string

// Enum values for Scte35AposNoRegionalBlackoutBehavior
const (
	Scte35AposNoRegionalBlackoutBehaviorFollow Scte35AposNoRegionalBlackoutBehavior = "FOLLOW"
	Scte35AposNoRegionalBlackoutBehaviorIgnore Scte35AposNoRegionalBlackoutBehavior = "IGNORE"
)

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

type Scte35AposWebDeliveryAllowedBehavior string

// Enum values for Scte35AposWebDeliveryAllowedBehavior
const (
	Scte35AposWebDeliveryAllowedBehaviorFollow Scte35AposWebDeliveryAllowedBehavior = "FOLLOW"
	Scte35AposWebDeliveryAllowedBehaviorIgnore Scte35AposWebDeliveryAllowedBehavior = "IGNORE"
)

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

type Scte35ArchiveAllowedFlag string

// Enum values for Scte35ArchiveAllowedFlag
const (
	Scte35ArchiveAllowedFlagArchiveNotAllowed Scte35ArchiveAllowedFlag = "ARCHIVE_NOT_ALLOWED"
	Scte35ArchiveAllowedFlagArchiveAllowed    Scte35ArchiveAllowedFlag = "ARCHIVE_ALLOWED"
)

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

type Scte35DeviceRestrictions string

// Enum values for Scte35DeviceRestrictions
const (
	Scte35DeviceRestrictionsNone           Scte35DeviceRestrictions = "NONE"
	Scte35DeviceRestrictionsRestrictGroup0 Scte35DeviceRestrictions = "RESTRICT_GROUP0"
	Scte35DeviceRestrictionsRestrictGroup1 Scte35DeviceRestrictions = "RESTRICT_GROUP1"
	Scte35DeviceRestrictionsRestrictGroup2 Scte35DeviceRestrictions = "RESTRICT_GROUP2"
)

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

type Scte35InputMode string

// Enum values for Scte35InputMode
const (
	Scte35InputModeFixed        Scte35InputMode = "FIXED"
	Scte35InputModeFollowActive Scte35InputMode = "FOLLOW_ACTIVE"
)

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

type Scte35NoRegionalBlackoutFlag string

// Enum values for Scte35NoRegionalBlackoutFlag
const (
	Scte35NoRegionalBlackoutFlagRegionalBlackout   Scte35NoRegionalBlackoutFlag = "REGIONAL_BLACKOUT"
	Scte35NoRegionalBlackoutFlagNoRegionalBlackout Scte35NoRegionalBlackoutFlag = "NO_REGIONAL_BLACKOUT"
)

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

type Scte35SegmentationCancelIndicator string

// Enum values for Scte35SegmentationCancelIndicator
const (
	Scte35SegmentationCancelIndicatorSegmentationEventNotCanceled Scte35SegmentationCancelIndicator = "SEGMENTATION_EVENT_NOT_CANCELED"
	Scte35SegmentationCancelIndicatorSegmentationEventCanceled    Scte35SegmentationCancelIndicator = "SEGMENTATION_EVENT_CANCELED"
)

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

type Scte35SpliceInsertNoRegionalBlackoutBehavior string

// Enum values for Scte35SpliceInsertNoRegionalBlackoutBehavior
const (
	Scte35SpliceInsertNoRegionalBlackoutBehaviorFollow Scte35SpliceInsertNoRegionalBlackoutBehavior = "FOLLOW"
	Scte35SpliceInsertNoRegionalBlackoutBehaviorIgnore Scte35SpliceInsertNoRegionalBlackoutBehavior = "IGNORE"
)

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

type Scte35SpliceInsertWebDeliveryAllowedBehavior string

// Enum values for Scte35SpliceInsertWebDeliveryAllowedBehavior
const (
	Scte35SpliceInsertWebDeliveryAllowedBehaviorFollow Scte35SpliceInsertWebDeliveryAllowedBehavior = "FOLLOW"
	Scte35SpliceInsertWebDeliveryAllowedBehaviorIgnore Scte35SpliceInsertWebDeliveryAllowedBehavior = "IGNORE"
)

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

type Scte35WebDeliveryAllowedFlag string

// Enum values for Scte35WebDeliveryAllowedFlag
const (
	Scte35WebDeliveryAllowedFlagWebDeliveryNotAllowed Scte35WebDeliveryAllowedFlag = "WEB_DELIVERY_NOT_ALLOWED"
	Scte35WebDeliveryAllowedFlagWebDeliveryAllowed    Scte35WebDeliveryAllowedFlag = "WEB_DELIVERY_ALLOWED"
)

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

type SmoothGroupAudioOnlyTimecodeControl string

// Enum values for SmoothGroupAudioOnlyTimecodeControl
const (
	SmoothGroupAudioOnlyTimecodeControlPassthrough        SmoothGroupAudioOnlyTimecodeControl = "PASSTHROUGH"
	SmoothGroupAudioOnlyTimecodeControlUseConfiguredClock SmoothGroupAudioOnlyTimecodeControl = "USE_CONFIGURED_CLOCK"
)

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

type SmoothGroupCertificateMode string

// Enum values for SmoothGroupCertificateMode
const (
	SmoothGroupCertificateModeSelfSigned         SmoothGroupCertificateMode = "SELF_SIGNED"
	SmoothGroupCertificateModeVerifyAuthenticity SmoothGroupCertificateMode = "VERIFY_AUTHENTICITY"
)

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

type SmoothGroupEventIdMode string

// Enum values for SmoothGroupEventIdMode
const (
	SmoothGroupEventIdModeNoEventId     SmoothGroupEventIdMode = "NO_EVENT_ID"
	SmoothGroupEventIdModeUseConfigured SmoothGroupEventIdMode = "USE_CONFIGURED"
	SmoothGroupEventIdModeUseTimestamp  SmoothGroupEventIdMode = "USE_TIMESTAMP"
)

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

type SmoothGroupEventStopBehavior string

// Enum values for SmoothGroupEventStopBehavior
const (
	SmoothGroupEventStopBehaviorNone    SmoothGroupEventStopBehavior = "NONE"
	SmoothGroupEventStopBehaviorSendEos SmoothGroupEventStopBehavior = "SEND_EOS"
)

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

type SmoothGroupSegmentationMode string

// Enum values for SmoothGroupSegmentationMode
const (
	SmoothGroupSegmentationModeUseInputSegmentation SmoothGroupSegmentationMode = "USE_INPUT_SEGMENTATION"
	SmoothGroupSegmentationModeUseSegmentDuration   SmoothGroupSegmentationMode = "USE_SEGMENT_DURATION"
)

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

type SmoothGroupSparseTrackType string

// Enum values for SmoothGroupSparseTrackType
const (
	SmoothGroupSparseTrackTypeNone                      SmoothGroupSparseTrackType = "NONE"
	SmoothGroupSparseTrackTypeScte35                    SmoothGroupSparseTrackType = "SCTE_35"
	SmoothGroupSparseTrackTypeScte35WithoutSegmentation SmoothGroupSparseTrackType = "SCTE_35_WITHOUT_SEGMENTATION"
)

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

type SmoothGroupStreamManifestBehavior string

// Enum values for SmoothGroupStreamManifestBehavior
const (
	SmoothGroupStreamManifestBehaviorDoNotSend SmoothGroupStreamManifestBehavior = "DO_NOT_SEND"
	SmoothGroupStreamManifestBehaviorSend      SmoothGroupStreamManifestBehavior = "SEND"
)

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

type SmoothGroupTimestampOffsetMode string

// Enum values for SmoothGroupTimestampOffsetMode
const (
	SmoothGroupTimestampOffsetModeUseConfiguredOffset SmoothGroupTimestampOffsetMode = "USE_CONFIGURED_OFFSET"
	SmoothGroupTimestampOffsetModeUseEventStartDate   SmoothGroupTimestampOffsetMode = "USE_EVENT_START_DATE"
)

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

type Smpte2038DataPreference string

// Enum values for Smpte2038DataPreference
const (
	Smpte2038DataPreferenceIgnore Smpte2038DataPreference = "IGNORE"
	Smpte2038DataPreferencePrefer Smpte2038DataPreference = "PREFER"
)

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

type TemporalFilterPostFilterSharpening string

// Enum values for TemporalFilterPostFilterSharpening
const (
	TemporalFilterPostFilterSharpeningAuto     TemporalFilterPostFilterSharpening = "AUTO"
	TemporalFilterPostFilterSharpeningDisabled TemporalFilterPostFilterSharpening = "DISABLED"
	TemporalFilterPostFilterSharpeningEnabled  TemporalFilterPostFilterSharpening = "ENABLED"
)

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

type TemporalFilterStrength string

// Enum values for TemporalFilterStrength
const (
	TemporalFilterStrengthAuto       TemporalFilterStrength = "AUTO"
	TemporalFilterStrengthStrength1  TemporalFilterStrength = "STRENGTH_1"
	TemporalFilterStrengthStrength2  TemporalFilterStrength = "STRENGTH_2"
	TemporalFilterStrengthStrength3  TemporalFilterStrength = "STRENGTH_3"
	TemporalFilterStrengthStrength4  TemporalFilterStrength = "STRENGTH_4"
	TemporalFilterStrengthStrength5  TemporalFilterStrength = "STRENGTH_5"
	TemporalFilterStrengthStrength6  TemporalFilterStrength = "STRENGTH_6"
	TemporalFilterStrengthStrength7  TemporalFilterStrength = "STRENGTH_7"
	TemporalFilterStrengthStrength8  TemporalFilterStrength = "STRENGTH_8"
	TemporalFilterStrengthStrength9  TemporalFilterStrength = "STRENGTH_9"
	TemporalFilterStrengthStrength10 TemporalFilterStrength = "STRENGTH_10"
	TemporalFilterStrengthStrength11 TemporalFilterStrength = "STRENGTH_11"
	TemporalFilterStrengthStrength12 TemporalFilterStrength = "STRENGTH_12"
	TemporalFilterStrengthStrength13 TemporalFilterStrength = "STRENGTH_13"
	TemporalFilterStrengthStrength14 TemporalFilterStrength = "STRENGTH_14"
	TemporalFilterStrengthStrength15 TemporalFilterStrength = "STRENGTH_15"
	TemporalFilterStrengthStrength16 TemporalFilterStrength = "STRENGTH_16"
)

// Values returns all known values for TemporalFilterStrength. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (TemporalFilterStrength) Values() []TemporalFilterStrength {
	return []TemporalFilterStrength{
		"AUTO",
		"STRENGTH_1",
		"STRENGTH_2",
		"STRENGTH_3",
		"STRENGTH_4",
		"STRENGTH_5",
		"STRENGTH_6",
		"STRENGTH_7",
		"STRENGTH_8",
		"STRENGTH_9",
		"STRENGTH_10",
		"STRENGTH_11",
		"STRENGTH_12",
		"STRENGTH_13",
		"STRENGTH_14",
		"STRENGTH_15",
		"STRENGTH_16",
	}
}

type ThumbnailState string

// Enum values for ThumbnailState
const (
	ThumbnailStateAuto     ThumbnailState = "AUTO"
	ThumbnailStateDisabled ThumbnailState = "DISABLED"
)

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

type ThumbnailType string

// Enum values for ThumbnailType
const (
	ThumbnailTypeUnspecified   ThumbnailType = "UNSPECIFIED"
	ThumbnailTypeCurrentActive ThumbnailType = "CURRENT_ACTIVE"
)

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

type TimecodeBurninFontSize string

// Enum values for TimecodeBurninFontSize
const (
	TimecodeBurninFontSizeExtraSmall10 TimecodeBurninFontSize = "EXTRA_SMALL_10"
	TimecodeBurninFontSizeLarge48      TimecodeBurninFontSize = "LARGE_48"
	TimecodeBurninFontSizeMedium32     TimecodeBurninFontSize = "MEDIUM_32"
	TimecodeBurninFontSizeSmall16      TimecodeBurninFontSize = "SMALL_16"
)

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

type TimecodeBurninPosition string

// Enum values for TimecodeBurninPosition
const (
	TimecodeBurninPositionBottomCenter TimecodeBurninPosition = "BOTTOM_CENTER"
	TimecodeBurninPositionBottomLeft   TimecodeBurninPosition = "BOTTOM_LEFT"
	TimecodeBurninPositionBottomRight  TimecodeBurninPosition = "BOTTOM_RIGHT"
	TimecodeBurninPositionMiddleCenter TimecodeBurninPosition = "MIDDLE_CENTER"
	TimecodeBurninPositionMiddleLeft   TimecodeBurninPosition = "MIDDLE_LEFT"
	TimecodeBurninPositionMiddleRight  TimecodeBurninPosition = "MIDDLE_RIGHT"
	TimecodeBurninPositionTopCenter    TimecodeBurninPosition = "TOP_CENTER"
	TimecodeBurninPositionTopLeft      TimecodeBurninPosition = "TOP_LEFT"
	TimecodeBurninPositionTopRight     TimecodeBurninPosition = "TOP_RIGHT"
)

// Values returns all known values for TimecodeBurninPosition. Note that this can
// be expanded in the future, and so it is only as up to date as the client. The
// ordering of this slice is not guaranteed to be stable across updates.
func (TimecodeBurninPosition) Values() []TimecodeBurninPosition {
	return []TimecodeBurninPosition{
		"BOTTOM_CENTER",
		"BOTTOM_LEFT",
		"BOTTOM_RIGHT",
		"MIDDLE_CENTER",
		"MIDDLE_LEFT",
		"MIDDLE_RIGHT",
		"TOP_CENTER",
		"TOP_LEFT",
		"TOP_RIGHT",
	}
}

type TimecodeConfigSource string

// Enum values for TimecodeConfigSource
const (
	TimecodeConfigSourceEmbedded    TimecodeConfigSource = "EMBEDDED"
	TimecodeConfigSourceSystemclock TimecodeConfigSource = "SYSTEMCLOCK"
	TimecodeConfigSourceZerobased   TimecodeConfigSource = "ZEROBASED"
)

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

type TtmlDestinationStyleControl string

// Enum values for TtmlDestinationStyleControl
const (
	TtmlDestinationStyleControlPassthrough   TtmlDestinationStyleControl = "PASSTHROUGH"
	TtmlDestinationStyleControlUseConfigured TtmlDestinationStyleControl = "USE_CONFIGURED"
)

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

type UdpTimedMetadataId3Frame string

// Enum values for UdpTimedMetadataId3Frame
const (
	UdpTimedMetadataId3FrameNone UdpTimedMetadataId3Frame = "NONE"
	UdpTimedMetadataId3FramePriv UdpTimedMetadataId3Frame = "PRIV"
	UdpTimedMetadataId3FrameTdrl UdpTimedMetadataId3Frame = "TDRL"
)

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

type VideoDescriptionRespondToAfd string

// Enum values for VideoDescriptionRespondToAfd
const (
	VideoDescriptionRespondToAfdNone        VideoDescriptionRespondToAfd = "NONE"
	VideoDescriptionRespondToAfdPassthrough VideoDescriptionRespondToAfd = "PASSTHROUGH"
	VideoDescriptionRespondToAfdRespond     VideoDescriptionRespondToAfd = "RESPOND"
)

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

type VideoDescriptionScalingBehavior string

// Enum values for VideoDescriptionScalingBehavior
const (
	VideoDescriptionScalingBehaviorDefault         VideoDescriptionScalingBehavior = "DEFAULT"
	VideoDescriptionScalingBehaviorStretchToOutput VideoDescriptionScalingBehavior = "STRETCH_TO_OUTPUT"
)

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

type VideoSelectorColorSpace string

// Enum values for VideoSelectorColorSpace
const (
	VideoSelectorColorSpaceFollow  VideoSelectorColorSpace = "FOLLOW"
	VideoSelectorColorSpaceHdr10   VideoSelectorColorSpace = "HDR10"
	VideoSelectorColorSpaceHlg2020 VideoSelectorColorSpace = "HLG_2020"
	VideoSelectorColorSpaceRec601  VideoSelectorColorSpace = "REC_601"
	VideoSelectorColorSpaceRec709  VideoSelectorColorSpace = "REC_709"
)

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

type VideoSelectorColorSpaceUsage string

// Enum values for VideoSelectorColorSpaceUsage
const (
	VideoSelectorColorSpaceUsageFallback VideoSelectorColorSpaceUsage = "FALLBACK"
	VideoSelectorColorSpaceUsageForce    VideoSelectorColorSpaceUsage = "FORCE"
)

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

type WavCodingMode string

// Enum values for WavCodingMode
const (
	WavCodingModeCodingMode10 WavCodingMode = "CODING_MODE_1_0"
	WavCodingModeCodingMode20 WavCodingMode = "CODING_MODE_2_0"
	WavCodingModeCodingMode40 WavCodingMode = "CODING_MODE_4_0"
	WavCodingModeCodingMode80 WavCodingMode = "CODING_MODE_8_0"
)

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

type WebvttDestinationStyleControl string

// Enum values for WebvttDestinationStyleControl
const (
	WebvttDestinationStyleControlNoStyleData WebvttDestinationStyleControl = "NO_STYLE_DATA"
	WebvttDestinationStyleControlPassthrough WebvttDestinationStyleControl = "PASSTHROUGH"
)

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