// Code generated by private/model/cli/gen-api/main.go. DO NOT EDIT.

package medialive

// Aac Coding Mode
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"
)

func (enum AacCodingMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AacCodingMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Aac Input Type
type AacInputType string

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

func (enum AacInputType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AacInputType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Aac Profile
type AacProfile string

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

func (enum AacProfile) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AacProfile) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Aac Rate Control Mode
type AacRateControlMode string

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

func (enum AacRateControlMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AacRateControlMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Aac Raw Format
type AacRawFormat string

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

func (enum AacRawFormat) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AacRawFormat) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Aac Spec
type AacSpec string

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

func (enum AacSpec) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AacSpec) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Aac Vbr Quality
type AacVbrQuality string

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

func (enum AacVbrQuality) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AacVbrQuality) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Ac3 Bitstream Mode
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"
)

func (enum Ac3BitstreamMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Ac3BitstreamMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Ac3 Coding Mode
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"
)

func (enum Ac3CodingMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Ac3CodingMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Ac3 Drc Profile
type Ac3DrcProfile string

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

func (enum Ac3DrcProfile) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Ac3DrcProfile) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Ac3 Lfe Filter
type Ac3LfeFilter string

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

func (enum Ac3LfeFilter) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Ac3LfeFilter) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Ac3 Metadata Control
type Ac3MetadataControl string

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

func (enum Ac3MetadataControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Ac3MetadataControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Afd Signaling
type AfdSignaling string

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

func (enum AfdSignaling) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AfdSignaling) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Audio Description Audio Type Control
type AudioDescriptionAudioTypeControl string

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

func (enum AudioDescriptionAudioTypeControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AudioDescriptionAudioTypeControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Audio Description Language Code Control
type AudioDescriptionLanguageCodeControl string

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

func (enum AudioDescriptionLanguageCodeControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AudioDescriptionLanguageCodeControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Audio Language Selection Policy
type AudioLanguageSelectionPolicy string

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

func (enum AudioLanguageSelectionPolicy) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AudioLanguageSelectionPolicy) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Audio Normalization Algorithm
type AudioNormalizationAlgorithm string

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

func (enum AudioNormalizationAlgorithm) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AudioNormalizationAlgorithm) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Audio Normalization Algorithm Control
type AudioNormalizationAlgorithmControl string

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

func (enum AudioNormalizationAlgorithmControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AudioNormalizationAlgorithmControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Audio Only Hls Track Type
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"
)

func (enum AudioOnlyHlsTrackType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AudioOnlyHlsTrackType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Audio Type
type AudioType string

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

func (enum AudioType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AudioType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Authentication Scheme
type AuthenticationScheme string

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

func (enum AuthenticationScheme) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AuthenticationScheme) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Avail Blanking State
type AvailBlankingState string

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

func (enum AvailBlankingState) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum AvailBlankingState) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Blackout Slate Network End Blackout
type BlackoutSlateNetworkEndBlackout string

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

func (enum BlackoutSlateNetworkEndBlackout) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum BlackoutSlateNetworkEndBlackout) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Blackout Slate State
type BlackoutSlateState string

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

func (enum BlackoutSlateState) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum BlackoutSlateState) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Burn In Alignment
type BurnInAlignment string

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

func (enum BurnInAlignment) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum BurnInAlignment) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Burn In Background Color
type BurnInBackgroundColor string

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

func (enum BurnInBackgroundColor) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum BurnInBackgroundColor) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Burn In Font Color
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"
)

func (enum BurnInFontColor) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum BurnInFontColor) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Burn In Outline Color
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"
)

func (enum BurnInOutlineColor) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum BurnInOutlineColor) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Burn In Shadow Color
type BurnInShadowColor string

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

func (enum BurnInShadowColor) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum BurnInShadowColor) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Burn In Teletext Grid Control
type BurnInTeletextGridControl string

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

func (enum BurnInTeletextGridControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum BurnInTeletextGridControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// A standard channel has two encoding pipelines and a single pipeline channel
// only has one.
type ChannelClass string

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

func (enum ChannelClass) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ChannelClass) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

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

func (enum ChannelState) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ChannelState) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Dvb Sdt Output Sdt
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"
)

func (enum DvbSdtOutputSdt) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DvbSdtOutputSdt) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Dvb Sub Destination Alignment
type DvbSubDestinationAlignment string

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

func (enum DvbSubDestinationAlignment) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DvbSubDestinationAlignment) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Dvb Sub Destination Background Color
type DvbSubDestinationBackgroundColor string

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

func (enum DvbSubDestinationBackgroundColor) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DvbSubDestinationBackgroundColor) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Dvb Sub Destination Font Color
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"
)

func (enum DvbSubDestinationFontColor) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DvbSubDestinationFontColor) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Dvb Sub Destination Outline Color
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"
)

func (enum DvbSubDestinationOutlineColor) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DvbSubDestinationOutlineColor) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Dvb Sub Destination Shadow Color
type DvbSubDestinationShadowColor string

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

func (enum DvbSubDestinationShadowColor) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DvbSubDestinationShadowColor) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Dvb Sub Destination Teletext Grid Control
type DvbSubDestinationTeletextGridControl string

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

func (enum DvbSubDestinationTeletextGridControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum DvbSubDestinationTeletextGridControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Eac3 Attenuation Control
type Eac3AttenuationControl string

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

func (enum Eac3AttenuationControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Eac3AttenuationControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Eac3 Bitstream Mode
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"
)

func (enum Eac3BitstreamMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Eac3BitstreamMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Eac3 Coding Mode
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"
)

func (enum Eac3CodingMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Eac3CodingMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Eac3 Dc Filter
type Eac3DcFilter string

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

func (enum Eac3DcFilter) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Eac3DcFilter) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Eac3 Drc Line
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"
)

func (enum Eac3DrcLine) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Eac3DrcLine) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Eac3 Drc Rf
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"
)

func (enum Eac3DrcRf) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Eac3DrcRf) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Eac3 Lfe Control
type Eac3LfeControl string

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

func (enum Eac3LfeControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Eac3LfeControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Eac3 Lfe Filter
type Eac3LfeFilter string

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

func (enum Eac3LfeFilter) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Eac3LfeFilter) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Eac3 Metadata Control
type Eac3MetadataControl string

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

func (enum Eac3MetadataControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Eac3MetadataControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Eac3 Passthrough Control
type Eac3PassthroughControl string

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

func (enum Eac3PassthroughControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Eac3PassthroughControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Eac3 Phase Control
type Eac3PhaseControl string

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

func (enum Eac3PhaseControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Eac3PhaseControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Eac3 Stereo Downmix
type Eac3StereoDownmix string

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

func (enum Eac3StereoDownmix) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Eac3StereoDownmix) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Eac3 Surround Ex Mode
type Eac3SurroundExMode string

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

func (enum Eac3SurroundExMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Eac3SurroundExMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Eac3 Surround Mode
type Eac3SurroundMode string

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

func (enum Eac3SurroundMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Eac3SurroundMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Embedded Convert608 To708
type EmbeddedConvert608To708 string

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

func (enum EmbeddedConvert608To708) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum EmbeddedConvert608To708) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Embedded Scte20 Detection
type EmbeddedScte20Detection string

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

func (enum EmbeddedScte20Detection) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum EmbeddedScte20Detection) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Fec Output Include Fec
type FecOutputIncludeFec string

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

func (enum FecOutputIncludeFec) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum FecOutputIncludeFec) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

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

func (enum FixedAfd) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum FixedAfd) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Follow reference point.
type FollowPoint string

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

func (enum FollowPoint) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum FollowPoint) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Global Configuration Input End Action
type GlobalConfigurationInputEndAction string

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

func (enum GlobalConfigurationInputEndAction) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum GlobalConfigurationInputEndAction) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Global Configuration Low Framerate Inputs
type GlobalConfigurationLowFramerateInputs string

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

func (enum GlobalConfigurationLowFramerateInputs) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum GlobalConfigurationLowFramerateInputs) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Global Configuration Output Locking Mode
type GlobalConfigurationOutputLockingMode string

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

func (enum GlobalConfigurationOutputLockingMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum GlobalConfigurationOutputLockingMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Global Configuration Output Timing Source
type GlobalConfigurationOutputTimingSource string

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

func (enum GlobalConfigurationOutputTimingSource) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum GlobalConfigurationOutputTimingSource) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Adaptive Quantization
type H264AdaptiveQuantization string

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

func (enum H264AdaptiveQuantization) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264AdaptiveQuantization) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Color Metadata
type H264ColorMetadata string

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

func (enum H264ColorMetadata) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264ColorMetadata) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Entropy Encoding
type H264EntropyEncoding string

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

func (enum H264EntropyEncoding) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264EntropyEncoding) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Flicker Aq
type H264FlickerAq string

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

func (enum H264FlickerAq) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264FlickerAq) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Framerate Control
type H264FramerateControl string

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

func (enum H264FramerateControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264FramerateControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Gop BReference
type H264GopBReference string

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

func (enum H264GopBReference) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264GopBReference) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Gop Size Units
type H264GopSizeUnits string

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

func (enum H264GopSizeUnits) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264GopSizeUnits) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

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

func (enum H264Level) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264Level) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Look Ahead Rate Control
type H264LookAheadRateControl string

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

func (enum H264LookAheadRateControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264LookAheadRateControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Par Control
type H264ParControl string

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

func (enum H264ParControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264ParControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

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

func (enum H264Profile) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264Profile) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Rate Control Mode
type H264RateControlMode string

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

func (enum H264RateControlMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264RateControlMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Scan Type
type H264ScanType string

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

func (enum H264ScanType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264ScanType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Scene Change Detect
type H264SceneChangeDetect string

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

func (enum H264SceneChangeDetect) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264SceneChangeDetect) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Spatial Aq
type H264SpatialAq string

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

func (enum H264SpatialAq) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264SpatialAq) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Sub Gop Length
type H264SubGopLength string

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

func (enum H264SubGopLength) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264SubGopLength) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Syntax
type H264Syntax string

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

func (enum H264Syntax) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264Syntax) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Temporal Aq
type H264TemporalAq string

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

func (enum H264TemporalAq) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264TemporalAq) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H264 Timecode Insertion Behavior
type H264TimecodeInsertionBehavior string

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

func (enum H264TimecodeInsertionBehavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H264TimecodeInsertionBehavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H265 Adaptive Quantization
type H265AdaptiveQuantization string

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

func (enum H265AdaptiveQuantization) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H265AdaptiveQuantization) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H265 Alternative Transfer Function
type H265AlternativeTransferFunction string

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

func (enum H265AlternativeTransferFunction) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H265AlternativeTransferFunction) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H265 Color Metadata
type H265ColorMetadata string

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

func (enum H265ColorMetadata) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H265ColorMetadata) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H265 Flicker Aq
type H265FlickerAq string

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

func (enum H265FlickerAq) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H265FlickerAq) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H265 Gop Size Units
type H265GopSizeUnits string

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

func (enum H265GopSizeUnits) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H265GopSizeUnits) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

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

func (enum H265Level) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H265Level) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H265 Look Ahead Rate Control
type H265LookAheadRateControl string

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

func (enum H265LookAheadRateControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H265LookAheadRateControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H265 Profile
type H265Profile string

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

func (enum H265Profile) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H265Profile) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H265 Rate Control Mode
type H265RateControlMode string

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

func (enum H265RateControlMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H265RateControlMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H265 Scan Type
type H265ScanType string

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

func (enum H265ScanType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H265ScanType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H265 Scene Change Detect
type H265SceneChangeDetect string

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

func (enum H265SceneChangeDetect) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H265SceneChangeDetect) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H265 Tier
type H265Tier string

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

func (enum H265Tier) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H265Tier) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// H265 Timecode Insertion Behavior
type H265TimecodeInsertionBehavior string

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

func (enum H265TimecodeInsertionBehavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum H265TimecodeInsertionBehavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Ad Markers
type HlsAdMarkers string

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

func (enum HlsAdMarkers) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsAdMarkers) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Akamai Http Transfer Mode
type HlsAkamaiHttpTransferMode string

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

func (enum HlsAkamaiHttpTransferMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsAkamaiHttpTransferMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Caption Language Setting
type HlsCaptionLanguageSetting string

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

func (enum HlsCaptionLanguageSetting) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsCaptionLanguageSetting) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Client Cache
type HlsClientCache string

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

func (enum HlsClientCache) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsClientCache) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Codec Specification
type HlsCodecSpecification string

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

func (enum HlsCodecSpecification) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsCodecSpecification) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Directory Structure
type HlsDirectoryStructure string

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

func (enum HlsDirectoryStructure) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsDirectoryStructure) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Encryption Type
type HlsEncryptionType string

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

func (enum HlsEncryptionType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsEncryptionType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Iv In Manifest
type HlsIvInManifest string

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

func (enum HlsIvInManifest) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsIvInManifest) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Iv Source
type HlsIvSource string

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

func (enum HlsIvSource) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsIvSource) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Manifest Compression
type HlsManifestCompression string

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

func (enum HlsManifestCompression) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsManifestCompression) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Manifest Duration Format
type HlsManifestDurationFormat string

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

func (enum HlsManifestDurationFormat) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsManifestDurationFormat) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Media Store Storage Class
type HlsMediaStoreStorageClass string

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

func (enum HlsMediaStoreStorageClass) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsMediaStoreStorageClass) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Mode
type HlsMode string

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

func (enum HlsMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Output Selection
type HlsOutputSelection string

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

func (enum HlsOutputSelection) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsOutputSelection) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Program Date Time
type HlsProgramDateTime string

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

func (enum HlsProgramDateTime) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsProgramDateTime) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Redundant Manifest
type HlsRedundantManifest string

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

func (enum HlsRedundantManifest) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsRedundantManifest) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Segmentation Mode
type HlsSegmentationMode string

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

func (enum HlsSegmentationMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsSegmentationMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Stream Inf Resolution
type HlsStreamInfResolution string

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

func (enum HlsStreamInfResolution) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsStreamInfResolution) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Timed Metadata Id3 Frame
type HlsTimedMetadataId3Frame string

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

func (enum HlsTimedMetadataId3Frame) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsTimedMetadataId3Frame) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Ts File Mode
type HlsTsFileMode string

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

func (enum HlsTsFileMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsTsFileMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Hls Webdav Http Transfer Mode
type HlsWebdavHttpTransferMode string

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

func (enum HlsWebdavHttpTransferMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum HlsWebdavHttpTransferMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// When set to "standard", an I-Frame only playlist will be written out for
// each video output in the output group. This I-Frame only playlist will contain
// byte range offsets pointing to the I-frame(s) in each segment.
type IFrameOnlyPlaylistType string

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

func (enum IFrameOnlyPlaylistType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum IFrameOnlyPlaylistType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// A standard input has two sources and a single pipeline input only has one.
type InputClass string

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

func (enum InputClass) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputClass) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// codec in increasing order of complexity
type InputCodec string

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

func (enum InputCodec) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputCodec) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Input Deblock Filter
type InputDeblockFilter string

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

func (enum InputDeblockFilter) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputDeblockFilter) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Input Denoise Filter
type InputDenoiseFilter string

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

func (enum InputDenoiseFilter) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputDenoiseFilter) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Input Filter
type InputFilter string

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

func (enum InputFilter) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputFilter) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Input Loss Action For Hls Out
type InputLossActionForHlsOut string

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

func (enum InputLossActionForHlsOut) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputLossActionForHlsOut) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Input Loss Action For Ms Smooth Out
type InputLossActionForMsSmoothOut string

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

func (enum InputLossActionForMsSmoothOut) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputLossActionForMsSmoothOut) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Input Loss Action For Rtmp Out
type InputLossActionForRtmpOut string

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

func (enum InputLossActionForRtmpOut) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputLossActionForRtmpOut) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Input Loss Action For Udp Out
type InputLossActionForUdpOut string

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

func (enum InputLossActionForUdpOut) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputLossActionForUdpOut) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Input Loss Image Type
type InputLossImageType string

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

func (enum InputLossImageType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputLossImageType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Maximum input bitrate in megabits per second. Bitrates up to 50 Mbps are
// supported currently.
type InputMaximumBitrate string

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

func (enum InputMaximumBitrate) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputMaximumBitrate) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Input resolution based on lines of vertical resolution in the input; SD is
// less than 720 lines, HD is 720 to 1080 lines, UHD is greater than 1080 lines
type InputResolution string

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

func (enum InputResolution) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputResolution) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type InputSecurityGroupState string

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

func (enum InputSecurityGroupState) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputSecurityGroupState) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Input Source End Behavior
type InputSourceEndBehavior string

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

func (enum InputSourceEndBehavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputSourceEndBehavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// There are two types of input sources, static and dynamic. If an input source
// is dynamic you canchange the source url of the input dynamically using an
// input switch action. However, the only input typeto support a dynamic url
// at this time is MP4_FILE. By default all input sources are static.
type InputSourceType string

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

func (enum InputSourceType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputSourceType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

type InputState string

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

func (enum InputState) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputState) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// To clip the file, you must specify the timecode for the start and end of
// the clip. Specify EMBEDDED to use the timecode embedded in the source content.
// The embedded timecode must exist in the source content, otherwise MediaLive
// will output black frames until it reaches the end of the source. Specify
// ZEROBASED to use a timecode that assumes that the first frame in the file
// has the timestamp 00:00:00.00. There is no default for this field, you must
// specify a value.
type InputTimecodeSource string

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

func (enum InputTimecodeSource) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputTimecodeSource) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

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

func (enum InputType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum InputType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// If you specify a StopTimecode in an input (in order to clip the file), you
// can specify if you want the clip to exclude (the default) or include the
// frame specified by the timecode.
type LastFrameClippingBehavior string

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

func (enum LastFrameClippingBehavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum LastFrameClippingBehavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// The log level the user wants for their channel.
type LogLevel string

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

func (enum LogLevel) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum LogLevel) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Absent Input Audio Behavior
type M2tsAbsentInputAudioBehavior string

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

func (enum M2tsAbsentInputAudioBehavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsAbsentInputAudioBehavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Arib
type M2tsArib string

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

func (enum M2tsArib) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsArib) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Arib Captions Pid Control
type M2tsAribCaptionsPidControl string

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

func (enum M2tsAribCaptionsPidControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsAribCaptionsPidControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Audio Buffer Model
type M2tsAudioBufferModel string

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

func (enum M2tsAudioBufferModel) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsAudioBufferModel) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Audio Interval
type M2tsAudioInterval string

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

func (enum M2tsAudioInterval) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsAudioInterval) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Audio Stream Type
type M2tsAudioStreamType string

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

func (enum M2tsAudioStreamType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsAudioStreamType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Buffer Model
type M2tsBufferModel string

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

func (enum M2tsBufferModel) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsBufferModel) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Cc Descriptor
type M2tsCcDescriptor string

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

func (enum M2tsCcDescriptor) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsCcDescriptor) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Ebif Control
type M2tsEbifControl string

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

func (enum M2tsEbifControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsEbifControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Ebp Placement
type M2tsEbpPlacement string

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

func (enum M2tsEbpPlacement) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsEbpPlacement) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Es Rate In Pes
type M2tsEsRateInPes string

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

func (enum M2tsEsRateInPes) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsEsRateInPes) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Klv
type M2tsKlv string

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

func (enum M2tsKlv) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsKlv) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Nielsen Id3 Behavior
type M2tsNielsenId3Behavior string

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

func (enum M2tsNielsenId3Behavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsNielsenId3Behavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Pcr Control
type M2tsPcrControl string

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

func (enum M2tsPcrControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsPcrControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Rate Mode
type M2tsRateMode string

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

func (enum M2tsRateMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsRateMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Scte35 Control
type M2tsScte35Control string

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

func (enum M2tsScte35Control) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsScte35Control) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Segmentation Markers
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"
)

func (enum M2tsSegmentationMarkers) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsSegmentationMarkers) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Segmentation Style
type M2tsSegmentationStyle string

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

func (enum M2tsSegmentationStyle) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsSegmentationStyle) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M2ts Timed Metadata Behavior
type M2tsTimedMetadataBehavior string

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

func (enum M2tsTimedMetadataBehavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M2tsTimedMetadataBehavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M3u8 Nielsen Id3 Behavior
type M3u8NielsenId3Behavior string

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

func (enum M3u8NielsenId3Behavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M3u8NielsenId3Behavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M3u8 Pcr Control
type M3u8PcrControl string

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

func (enum M3u8PcrControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M3u8PcrControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M3u8 Scte35 Behavior
type M3u8Scte35Behavior string

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

func (enum M3u8Scte35Behavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M3u8Scte35Behavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// M3u8 Timed Metadata Behavior
type M3u8TimedMetadataBehavior string

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

func (enum M3u8TimedMetadataBehavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum M3u8TimedMetadataBehavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Mp2 Coding Mode
type Mp2CodingMode string

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

func (enum Mp2CodingMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Mp2CodingMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Ms Smooth H265 Packaging Type
type MsSmoothH265PackagingType string

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

func (enum MsSmoothH265PackagingType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum MsSmoothH265PackagingType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// The current state of the multiplex.
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"
)

func (enum MultiplexState) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum MultiplexState) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Network Input Server Validation
type NetworkInputServerValidation string

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

func (enum NetworkInputServerValidation) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NetworkInputServerValidation) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// State of Nielsen PCM to ID3 tagging
type NielsenPcmToId3TaggingState string

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

func (enum NielsenPcmToId3TaggingState) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum NielsenPcmToId3TaggingState) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Units for duration, e.g. 'MONTHS'
type OfferingDurationUnits string

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

func (enum OfferingDurationUnits) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum OfferingDurationUnits) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Offering type, e.g. 'NO_UPFRONT'
type OfferingType string

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

func (enum OfferingType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum OfferingType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Pipeline ID
type PipelineId string

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

func (enum PipelineId) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum PipelineId) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Codec, 'MPEG2', 'AVC', 'HEVC', or 'AUDIO'
type ReservationCodec string

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

func (enum ReservationCodec) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ReservationCodec) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Maximum bitrate in megabits per second
type ReservationMaximumBitrate string

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

func (enum ReservationMaximumBitrate) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ReservationMaximumBitrate) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Maximum framerate in frames per second (Outputs only)
type ReservationMaximumFramerate string

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

func (enum ReservationMaximumFramerate) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ReservationMaximumFramerate) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Resolution based on lines of vertical resolution; SD is less than 720 lines,
// HD is 720 to 1080 lines, FHD is 1080 lines, UHD is greater than 1080 lines
type ReservationResolution string

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

func (enum ReservationResolution) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ReservationResolution) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Resource type, 'INPUT', 'OUTPUT', 'MULTIPLEX', or 'CHANNEL'
type ReservationResourceType string

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

func (enum ReservationResourceType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ReservationResourceType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Special features, 'ADVANCED_AUDIO' or 'AUDIO_NORMALIZATION'
type ReservationSpecialFeature string

// Enum values for ReservationSpecialFeature
const (
	ReservationSpecialFeatureAdvancedAudio      ReservationSpecialFeature = "ADVANCED_AUDIO"
	ReservationSpecialFeatureAudioNormalization ReservationSpecialFeature = "AUDIO_NORMALIZATION"
)

func (enum ReservationSpecialFeature) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ReservationSpecialFeature) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Current reservation state
type ReservationState string

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

func (enum ReservationState) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ReservationState) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Video quality, e.g. 'STANDARD' (Outputs only)
type ReservationVideoQuality string

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

func (enum ReservationVideoQuality) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum ReservationVideoQuality) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Rtmp Cache Full Behavior
type RtmpCacheFullBehavior string

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

func (enum RtmpCacheFullBehavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum RtmpCacheFullBehavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Rtmp Caption Data
type RtmpCaptionData string

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

func (enum RtmpCaptionData) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum RtmpCaptionData) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Rtmp Output Certificate Mode
type RtmpOutputCertificateMode string

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

func (enum RtmpOutputCertificateMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum RtmpOutputCertificateMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Scte20 Convert608 To708
type Scte20Convert608To708 string

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

func (enum Scte20Convert608To708) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Scte20Convert608To708) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Scte35 Apos No Regional Blackout Behavior
type Scte35AposNoRegionalBlackoutBehavior string

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

func (enum Scte35AposNoRegionalBlackoutBehavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Scte35AposNoRegionalBlackoutBehavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Scte35 Apos Web Delivery Allowed Behavior
type Scte35AposWebDeliveryAllowedBehavior string

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

func (enum Scte35AposWebDeliveryAllowedBehavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Scte35AposWebDeliveryAllowedBehavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Corresponds to the archive_allowed parameter. A value of ARCHIVE_NOT_ALLOWED
// corresponds to 0 (false) in the SCTE-35 specification. If you include one
// of the "restriction" flags then you must include all four of them.
type Scte35ArchiveAllowedFlag string

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

func (enum Scte35ArchiveAllowedFlag) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Scte35ArchiveAllowedFlag) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Corresponds to the device_restrictions parameter in a segmentation_descriptor.
// If you include one of the "restriction" flags then you must include all four
// of them.
type Scte35DeviceRestrictions string

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

func (enum Scte35DeviceRestrictions) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Scte35DeviceRestrictions) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Corresponds to the no_regional_blackout_flag parameter. A value of REGIONAL_BLACKOUT
// corresponds to 0 (false) in the SCTE-35 specification. If you include one
// of the "restriction" flags then you must include all four of them.
type Scte35NoRegionalBlackoutFlag string

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

func (enum Scte35NoRegionalBlackoutFlag) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Scte35NoRegionalBlackoutFlag) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Corresponds to SCTE-35 segmentation_event_cancel_indicator. SEGMENTATION_EVENT_NOT_CANCELED
// corresponds to 0 in the SCTE-35 specification and indicates that this is
// an insertion request. SEGMENTATION_EVENT_CANCELED corresponds to 1 in the
// SCTE-35 specification and indicates that this is a cancelation request, in
// which case complete this field and the existing event ID to cancel.
type Scte35SegmentationCancelIndicator string

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

func (enum Scte35SegmentationCancelIndicator) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Scte35SegmentationCancelIndicator) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Scte35 Splice Insert No Regional Blackout Behavior
type Scte35SpliceInsertNoRegionalBlackoutBehavior string

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

func (enum Scte35SpliceInsertNoRegionalBlackoutBehavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Scte35SpliceInsertNoRegionalBlackoutBehavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Scte35 Splice Insert Web Delivery Allowed Behavior
type Scte35SpliceInsertWebDeliveryAllowedBehavior string

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

func (enum Scte35SpliceInsertWebDeliveryAllowedBehavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Scte35SpliceInsertWebDeliveryAllowedBehavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Corresponds to the web_delivery_allowed_flag parameter. A value of WEB_DELIVERY_NOT_ALLOWED
// corresponds to 0 (false) in the SCTE-35 specification. If you include one
// of the "restriction" flags then you must include all four of them.
type Scte35WebDeliveryAllowedFlag string

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

func (enum Scte35WebDeliveryAllowedFlag) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum Scte35WebDeliveryAllowedFlag) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Smooth Group Audio Only Timecode Control
type SmoothGroupAudioOnlyTimecodeControl string

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

func (enum SmoothGroupAudioOnlyTimecodeControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SmoothGroupAudioOnlyTimecodeControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Smooth Group Certificate Mode
type SmoothGroupCertificateMode string

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

func (enum SmoothGroupCertificateMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SmoothGroupCertificateMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Smooth Group Event Id Mode
type SmoothGroupEventIdMode string

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

func (enum SmoothGroupEventIdMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SmoothGroupEventIdMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Smooth Group Event Stop Behavior
type SmoothGroupEventStopBehavior string

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

func (enum SmoothGroupEventStopBehavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SmoothGroupEventStopBehavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Smooth Group Segmentation Mode
type SmoothGroupSegmentationMode string

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

func (enum SmoothGroupSegmentationMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SmoothGroupSegmentationMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Smooth Group Sparse Track Type
type SmoothGroupSparseTrackType string

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

func (enum SmoothGroupSparseTrackType) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SmoothGroupSparseTrackType) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Smooth Group Stream Manifest Behavior
type SmoothGroupStreamManifestBehavior string

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

func (enum SmoothGroupStreamManifestBehavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SmoothGroupStreamManifestBehavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Smooth Group Timestamp Offset Mode
type SmoothGroupTimestampOffsetMode string

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

func (enum SmoothGroupTimestampOffsetMode) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum SmoothGroupTimestampOffsetMode) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Timecode Config Source
type TimecodeConfigSource string

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

func (enum TimecodeConfigSource) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum TimecodeConfigSource) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Ttml Destination Style Control
type TtmlDestinationStyleControl string

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

func (enum TtmlDestinationStyleControl) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum TtmlDestinationStyleControl) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Udp Timed Metadata Id3 Frame
type UdpTimedMetadataId3Frame string

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

func (enum UdpTimedMetadataId3Frame) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum UdpTimedMetadataId3Frame) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Video Description Respond To Afd
type VideoDescriptionRespondToAfd string

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

func (enum VideoDescriptionRespondToAfd) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum VideoDescriptionRespondToAfd) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Video Description Scaling Behavior
type VideoDescriptionScalingBehavior string

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

func (enum VideoDescriptionScalingBehavior) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum VideoDescriptionScalingBehavior) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Video Selector Color Space
type VideoSelectorColorSpace string

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

func (enum VideoSelectorColorSpace) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum VideoSelectorColorSpace) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}

// Video Selector Color Space Usage
type VideoSelectorColorSpaceUsage string

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

func (enum VideoSelectorColorSpaceUsage) MarshalValue() (string, error) {
	return string(enum), nil
}

func (enum VideoSelectorColorSpaceUsage) MarshalValueBuf(b []byte) ([]byte, error) {
	b = b[0:0]
	return append(b, enum...), nil
}
