Literals

Index > MediaConvert > Literals

Auto-generated documentation for MediaConvert type annotations stubs module mypy-boto3-mediaconvert.

AacAudioDescriptionBroadcasterMixType

# AacAudioDescriptionBroadcasterMixType usage example

from mypy_boto3_mediaconvert.literals import AacAudioDescriptionBroadcasterMixType

def get_value() -> AacAudioDescriptionBroadcasterMixType:
    return "BROADCASTER_MIXED_AD"

# AacAudioDescriptionBroadcasterMixType definition

AacAudioDescriptionBroadcasterMixType = Literal[
    "BROADCASTER_MIXED_AD",
    "NORMAL",
]

AacCodecProfileType

# AacCodecProfileType usage example

from mypy_boto3_mediaconvert.literals import AacCodecProfileType

def get_value() -> AacCodecProfileType:
    return "HEV1"

# AacCodecProfileType definition

AacCodecProfileType = Literal[
    "HEV1",
    "HEV2",
    "LC",
]

AacCodingModeType

# AacCodingModeType usage example

from mypy_boto3_mediaconvert.literals import AacCodingModeType

def get_value() -> AacCodingModeType:
    return "AD_RECEIVER_MIX"

# AacCodingModeType definition

AacCodingModeType = Literal[
    "AD_RECEIVER_MIX",
    "CODING_MODE_1_0",
    "CODING_MODE_1_1",
    "CODING_MODE_2_0",
    "CODING_MODE_5_1",
]

AacRateControlModeType

# AacRateControlModeType usage example

from mypy_boto3_mediaconvert.literals import AacRateControlModeType

def get_value() -> AacRateControlModeType:
    return "CBR"

# AacRateControlModeType definition

AacRateControlModeType = Literal[
    "CBR",
    "VBR",
]

AacRawFormatType

# AacRawFormatType usage example

from mypy_boto3_mediaconvert.literals import AacRawFormatType

def get_value() -> AacRawFormatType:
    return "LATM_LOAS"

# AacRawFormatType definition

AacRawFormatType = Literal[
    "LATM_LOAS",
    "NONE",
]

AacSpecificationType

# AacSpecificationType usage example

from mypy_boto3_mediaconvert.literals import AacSpecificationType

def get_value() -> AacSpecificationType:
    return "MPEG2"

# AacSpecificationType definition

AacSpecificationType = Literal[
    "MPEG2",
    "MPEG4",
]

AacVbrQualityType

# AacVbrQualityType usage example

from mypy_boto3_mediaconvert.literals import AacVbrQualityType

def get_value() -> AacVbrQualityType:
    return "HIGH"

# AacVbrQualityType definition

AacVbrQualityType = Literal[
    "HIGH",
    "LOW",
    "MEDIUM_HIGH",
    "MEDIUM_LOW",
]

Ac3BitstreamModeType

# Ac3BitstreamModeType usage example

from mypy_boto3_mediaconvert.literals import Ac3BitstreamModeType

def get_value() -> Ac3BitstreamModeType:
    return "COMMENTARY"

# Ac3BitstreamModeType definition

Ac3BitstreamModeType = Literal[
    "COMMENTARY",
    "COMPLETE_MAIN",
    "DIALOGUE",
    "EMERGENCY",
    "HEARING_IMPAIRED",
    "MUSIC_AND_EFFECTS",
    "VISUALLY_IMPAIRED",
    "VOICE_OVER",
]

Ac3CodingModeType

# Ac3CodingModeType usage example

from mypy_boto3_mediaconvert.literals import Ac3CodingModeType

def get_value() -> Ac3CodingModeType:
    return "CODING_MODE_1_0"

# Ac3CodingModeType definition

Ac3CodingModeType = Literal[
    "CODING_MODE_1_0",
    "CODING_MODE_1_1",
    "CODING_MODE_2_0",
    "CODING_MODE_3_2_LFE",
]

Ac3DynamicRangeCompressionLineType

# Ac3DynamicRangeCompressionLineType usage example

from mypy_boto3_mediaconvert.literals import Ac3DynamicRangeCompressionLineType

def get_value() -> Ac3DynamicRangeCompressionLineType:
    return "FILM_LIGHT"

# Ac3DynamicRangeCompressionLineType definition

Ac3DynamicRangeCompressionLineType = Literal[
    "FILM_LIGHT",
    "FILM_STANDARD",
    "MUSIC_LIGHT",
    "MUSIC_STANDARD",
    "NONE",
    "SPEECH",
]

Ac3DynamicRangeCompressionProfileType

# Ac3DynamicRangeCompressionProfileType usage example

from mypy_boto3_mediaconvert.literals import Ac3DynamicRangeCompressionProfileType

def get_value() -> Ac3DynamicRangeCompressionProfileType:
    return "FILM_STANDARD"

# Ac3DynamicRangeCompressionProfileType definition

Ac3DynamicRangeCompressionProfileType = Literal[
    "FILM_STANDARD",
    "NONE",
]

Ac3DynamicRangeCompressionRfType

# Ac3DynamicRangeCompressionRfType usage example

from mypy_boto3_mediaconvert.literals import Ac3DynamicRangeCompressionRfType

def get_value() -> Ac3DynamicRangeCompressionRfType:
    return "FILM_LIGHT"

# Ac3DynamicRangeCompressionRfType definition

Ac3DynamicRangeCompressionRfType = Literal[
    "FILM_LIGHT",
    "FILM_STANDARD",
    "MUSIC_LIGHT",
    "MUSIC_STANDARD",
    "NONE",
    "SPEECH",
]

Ac3LfeFilterType

# Ac3LfeFilterType usage example

from mypy_boto3_mediaconvert.literals import Ac3LfeFilterType

def get_value() -> Ac3LfeFilterType:
    return "DISABLED"

# Ac3LfeFilterType definition

Ac3LfeFilterType = Literal[
    "DISABLED",
    "ENABLED",
]

Ac3MetadataControlType

# Ac3MetadataControlType usage example

from mypy_boto3_mediaconvert.literals import Ac3MetadataControlType

def get_value() -> Ac3MetadataControlType:
    return "FOLLOW_INPUT"

# Ac3MetadataControlType definition

Ac3MetadataControlType = Literal[
    "FOLLOW_INPUT",
    "USE_CONFIGURED",
]

AccelerationModeType

# AccelerationModeType usage example

from mypy_boto3_mediaconvert.literals import AccelerationModeType

def get_value() -> AccelerationModeType:
    return "DISABLED"

# AccelerationModeType definition

AccelerationModeType = Literal[
    "DISABLED",
    "ENABLED",
    "PREFERRED",
]

AccelerationStatusType

# AccelerationStatusType usage example

from mypy_boto3_mediaconvert.literals import AccelerationStatusType

def get_value() -> AccelerationStatusType:
    return "ACCELERATED"

# AccelerationStatusType definition

AccelerationStatusType = Literal[
    "ACCELERATED",
    "IN_PROGRESS",
    "NOT_ACCELERATED",
    "NOT_APPLICABLE",
]

AdvancedInputFilterAddTextureType

# AdvancedInputFilterAddTextureType usage example

from mypy_boto3_mediaconvert.literals import AdvancedInputFilterAddTextureType

def get_value() -> AdvancedInputFilterAddTextureType:
    return "DISABLED"

# AdvancedInputFilterAddTextureType definition

AdvancedInputFilterAddTextureType = Literal[
    "DISABLED",
    "ENABLED",
]

AdvancedInputFilterSharpenType

# AdvancedInputFilterSharpenType usage example

from mypy_boto3_mediaconvert.literals import AdvancedInputFilterSharpenType

def get_value() -> AdvancedInputFilterSharpenType:
    return "HIGH"

# AdvancedInputFilterSharpenType definition

AdvancedInputFilterSharpenType = Literal[
    "HIGH",
    "LOW",
    "OFF",
]

AdvancedInputFilterType

# AdvancedInputFilterType usage example

from mypy_boto3_mediaconvert.literals import AdvancedInputFilterType

def get_value() -> AdvancedInputFilterType:
    return "DISABLED"

# AdvancedInputFilterType definition

AdvancedInputFilterType = Literal[
    "DISABLED",
    "ENABLED",
]

AfdSignalingType

# AfdSignalingType usage example

from mypy_boto3_mediaconvert.literals import AfdSignalingType

def get_value() -> AfdSignalingType:
    return "AUTO"

# AfdSignalingType definition

AfdSignalingType = Literal[
    "AUTO",
    "FIXED",
    "NONE",
]

AlphaBehaviorType

# AlphaBehaviorType usage example

from mypy_boto3_mediaconvert.literals import AlphaBehaviorType

def get_value() -> AlphaBehaviorType:
    return "DISCARD"

# AlphaBehaviorType definition

AlphaBehaviorType = Literal[
    "DISCARD",
    "REMAP_TO_LUMA",
]

AncillaryConvert608To708Type

# AncillaryConvert608To708Type usage example

from mypy_boto3_mediaconvert.literals import AncillaryConvert608To708Type

def get_value() -> AncillaryConvert608To708Type:
    return "DISABLED"

# AncillaryConvert608To708Type definition

AncillaryConvert608To708Type = Literal[
    "DISABLED",
    "UPCONVERT",
]

AncillaryTerminateCaptionsType

# AncillaryTerminateCaptionsType usage example

from mypy_boto3_mediaconvert.literals import AncillaryTerminateCaptionsType

def get_value() -> AncillaryTerminateCaptionsType:
    return "DISABLED"

# AncillaryTerminateCaptionsType definition

AncillaryTerminateCaptionsType = Literal[
    "DISABLED",
    "END_OF_INPUT",
]

AntiAliasType

# AntiAliasType usage example

from mypy_boto3_mediaconvert.literals import AntiAliasType

def get_value() -> AntiAliasType:
    return "DISABLED"

# AntiAliasType definition

AntiAliasType = Literal[
    "DISABLED",
    "ENABLED",
]

AudioChannelTagType

# AudioChannelTagType usage example

from mypy_boto3_mediaconvert.literals import AudioChannelTagType

def get_value() -> AudioChannelTagType:
    return "C"

# AudioChannelTagType definition

AudioChannelTagType = Literal[
    "C",
    "CS",
    "L",
    "LC",
    "LFE",
    "LS",
    "LSD",
    "R",
    "RC",
    "RS",
    "RSD",
    "TCS",
    "VHC",
    "VHL",
    "VHR",
]

AudioCodecType

# AudioCodecType usage example

from mypy_boto3_mediaconvert.literals import AudioCodecType

def get_value() -> AudioCodecType:
    return "AAC"

# AudioCodecType definition

AudioCodecType = Literal[
    "AAC",
    "AC3",
    "AIFF",
    "EAC3",
    "EAC3_ATMOS",
    "MP2",
    "MP3",
    "OPUS",
    "PASSTHROUGH",
    "VORBIS",
    "WAV",
]

AudioDefaultSelectionType

# AudioDefaultSelectionType usage example

from mypy_boto3_mediaconvert.literals import AudioDefaultSelectionType

def get_value() -> AudioDefaultSelectionType:
    return "DEFAULT"

# AudioDefaultSelectionType definition

AudioDefaultSelectionType = Literal[
    "DEFAULT",
    "NOT_DEFAULT",
]

AudioDurationCorrectionType

# AudioDurationCorrectionType usage example

from mypy_boto3_mediaconvert.literals import AudioDurationCorrectionType

def get_value() -> AudioDurationCorrectionType:
    return "AUTO"

# AudioDurationCorrectionType definition

AudioDurationCorrectionType = Literal[
    "AUTO",
    "DISABLED",
    "FRAME",
    "TRACK",
]

AudioLanguageCodeControlType

# AudioLanguageCodeControlType usage example

from mypy_boto3_mediaconvert.literals import AudioLanguageCodeControlType

def get_value() -> AudioLanguageCodeControlType:
    return "FOLLOW_INPUT"

# AudioLanguageCodeControlType definition

AudioLanguageCodeControlType = Literal[
    "FOLLOW_INPUT",
    "USE_CONFIGURED",
]

AudioNormalizationAlgorithmControlType

# AudioNormalizationAlgorithmControlType usage example

from mypy_boto3_mediaconvert.literals import AudioNormalizationAlgorithmControlType

def get_value() -> AudioNormalizationAlgorithmControlType:
    return "CORRECT_AUDIO"

# AudioNormalizationAlgorithmControlType definition

AudioNormalizationAlgorithmControlType = Literal[
    "CORRECT_AUDIO",
    "MEASURE_ONLY",
]

AudioNormalizationAlgorithmType

# AudioNormalizationAlgorithmType usage example

from mypy_boto3_mediaconvert.literals import AudioNormalizationAlgorithmType

def get_value() -> AudioNormalizationAlgorithmType:
    return "ITU_BS_1770_1"

# AudioNormalizationAlgorithmType definition

AudioNormalizationAlgorithmType = Literal[
    "ITU_BS_1770_1",
    "ITU_BS_1770_2",
    "ITU_BS_1770_3",
    "ITU_BS_1770_4",
]

AudioNormalizationLoudnessLoggingType

# AudioNormalizationLoudnessLoggingType usage example

from mypy_boto3_mediaconvert.literals import AudioNormalizationLoudnessLoggingType

def get_value() -> AudioNormalizationLoudnessLoggingType:
    return "DONT_LOG"

# AudioNormalizationLoudnessLoggingType definition

AudioNormalizationLoudnessLoggingType = Literal[
    "DONT_LOG",
    "LOG",
]

AudioNormalizationPeakCalculationType

# AudioNormalizationPeakCalculationType usage example

from mypy_boto3_mediaconvert.literals import AudioNormalizationPeakCalculationType

def get_value() -> AudioNormalizationPeakCalculationType:
    return "NONE"

# AudioNormalizationPeakCalculationType definition

AudioNormalizationPeakCalculationType = Literal[
    "NONE",
    "TRUE_PEAK",
]

AudioSelectorTypeType

# AudioSelectorTypeType usage example

from mypy_boto3_mediaconvert.literals import AudioSelectorTypeType

def get_value() -> AudioSelectorTypeType:
    return "HLS_RENDITION_GROUP"

# AudioSelectorTypeType definition

AudioSelectorTypeType = Literal[
    "HLS_RENDITION_GROUP",
    "LANGUAGE_CODE",
    "PID",
    "TRACK",
]

AudioTypeControlType

# AudioTypeControlType usage example

from mypy_boto3_mediaconvert.literals import AudioTypeControlType

def get_value() -> AudioTypeControlType:
    return "FOLLOW_INPUT"

# AudioTypeControlType definition

AudioTypeControlType = Literal[
    "FOLLOW_INPUT",
    "USE_CONFIGURED",
]

Av1AdaptiveQuantizationType

# Av1AdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import Av1AdaptiveQuantizationType

def get_value() -> Av1AdaptiveQuantizationType:
    return "HIGH"

# Av1AdaptiveQuantizationType definition

Av1AdaptiveQuantizationType = Literal[
    "HIGH",
    "HIGHER",
    "LOW",
    "MAX",
    "MEDIUM",
    "OFF",
]

Av1BitDepthType

# Av1BitDepthType usage example

from mypy_boto3_mediaconvert.literals import Av1BitDepthType

def get_value() -> Av1BitDepthType:
    return "BIT_10"

# Av1BitDepthType definition

Av1BitDepthType = Literal[
    "BIT_10",
    "BIT_8",
]

Av1FramerateControlType

# Av1FramerateControlType usage example

from mypy_boto3_mediaconvert.literals import Av1FramerateControlType

def get_value() -> Av1FramerateControlType:
    return "INITIALIZE_FROM_SOURCE"

# Av1FramerateControlType definition

Av1FramerateControlType = Literal[
    "INITIALIZE_FROM_SOURCE",
    "SPECIFIED",
]

Av1FramerateConversionAlgorithmType

# Av1FramerateConversionAlgorithmType usage example

from mypy_boto3_mediaconvert.literals import Av1FramerateConversionAlgorithmType

def get_value() -> Av1FramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"

# Av1FramerateConversionAlgorithmType definition

Av1FramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "FRAMEFORMER",
    "INTERPOLATE",
]

Av1RateControlModeType

# Av1RateControlModeType usage example

from mypy_boto3_mediaconvert.literals import Av1RateControlModeType

def get_value() -> Av1RateControlModeType:
    return "QVBR"

# Av1RateControlModeType definition

Av1RateControlModeType = Literal[
    "QVBR",
]

Av1SpatialAdaptiveQuantizationType

# Av1SpatialAdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import Av1SpatialAdaptiveQuantizationType

def get_value() -> Av1SpatialAdaptiveQuantizationType:
    return "DISABLED"

# Av1SpatialAdaptiveQuantizationType definition

Av1SpatialAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

AvcIntraClassType

# AvcIntraClassType usage example

from mypy_boto3_mediaconvert.literals import AvcIntraClassType

def get_value() -> AvcIntraClassType:
    return "CLASS_100"

# AvcIntraClassType definition

AvcIntraClassType = Literal[
    "CLASS_100",
    "CLASS_200",
    "CLASS_4K_2K",
    "CLASS_50",
]

AvcIntraFramerateControlType

# AvcIntraFramerateControlType usage example

from mypy_boto3_mediaconvert.literals import AvcIntraFramerateControlType

def get_value() -> AvcIntraFramerateControlType:
    return "INITIALIZE_FROM_SOURCE"

# AvcIntraFramerateControlType definition

AvcIntraFramerateControlType = Literal[
    "INITIALIZE_FROM_SOURCE",
    "SPECIFIED",
]

AvcIntraFramerateConversionAlgorithmType

# AvcIntraFramerateConversionAlgorithmType usage example

from mypy_boto3_mediaconvert.literals import AvcIntraFramerateConversionAlgorithmType

def get_value() -> AvcIntraFramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"

# AvcIntraFramerateConversionAlgorithmType definition

AvcIntraFramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "FRAMEFORMER",
    "INTERPOLATE",
]

AvcIntraInterlaceModeType

# AvcIntraInterlaceModeType usage example

from mypy_boto3_mediaconvert.literals import AvcIntraInterlaceModeType

def get_value() -> AvcIntraInterlaceModeType:
    return "BOTTOM_FIELD"

# AvcIntraInterlaceModeType definition

AvcIntraInterlaceModeType = Literal[
    "BOTTOM_FIELD",
    "FOLLOW_BOTTOM_FIELD",
    "FOLLOW_TOP_FIELD",
    "PROGRESSIVE",
    "TOP_FIELD",
]

AvcIntraScanTypeConversionModeType

# AvcIntraScanTypeConversionModeType usage example

from mypy_boto3_mediaconvert.literals import AvcIntraScanTypeConversionModeType

def get_value() -> AvcIntraScanTypeConversionModeType:
    return "INTERLACED"

# AvcIntraScanTypeConversionModeType definition

AvcIntraScanTypeConversionModeType = Literal[
    "INTERLACED",
    "INTERLACED_OPTIMIZE",
]

AvcIntraSlowPalType

# AvcIntraSlowPalType usage example

from mypy_boto3_mediaconvert.literals import AvcIntraSlowPalType

def get_value() -> AvcIntraSlowPalType:
    return "DISABLED"

# AvcIntraSlowPalType definition

AvcIntraSlowPalType = Literal[
    "DISABLED",
    "ENABLED",
]

AvcIntraTelecineType

# AvcIntraTelecineType usage example

from mypy_boto3_mediaconvert.literals import AvcIntraTelecineType

def get_value() -> AvcIntraTelecineType:
    return "HARD"

# AvcIntraTelecineType definition

AvcIntraTelecineType = Literal[
    "HARD",
    "NONE",
]

AvcIntraUhdQualityTuningLevelType

# AvcIntraUhdQualityTuningLevelType usage example

from mypy_boto3_mediaconvert.literals import AvcIntraUhdQualityTuningLevelType

def get_value() -> AvcIntraUhdQualityTuningLevelType:
    return "MULTI_PASS"

# AvcIntraUhdQualityTuningLevelType definition

AvcIntraUhdQualityTuningLevelType = Literal[
    "MULTI_PASS",
    "SINGLE_PASS",
]

BandwidthReductionFilterSharpeningType

# BandwidthReductionFilterSharpeningType usage example

from mypy_boto3_mediaconvert.literals import BandwidthReductionFilterSharpeningType

def get_value() -> BandwidthReductionFilterSharpeningType:
    return "HIGH"

# BandwidthReductionFilterSharpeningType definition

BandwidthReductionFilterSharpeningType = Literal[
    "HIGH",
    "LOW",
    "MEDIUM",
    "OFF",
]

BandwidthReductionFilterStrengthType

# BandwidthReductionFilterStrengthType usage example

from mypy_boto3_mediaconvert.literals import BandwidthReductionFilterStrengthType

def get_value() -> BandwidthReductionFilterStrengthType:
    return "AUTO"

# BandwidthReductionFilterStrengthType definition

BandwidthReductionFilterStrengthType = Literal[
    "AUTO",
    "HIGH",
    "LOW",
    "MEDIUM",
    "OFF",
]

BillingTagsSourceType

# BillingTagsSourceType usage example

from mypy_boto3_mediaconvert.literals import BillingTagsSourceType

def get_value() -> BillingTagsSourceType:
    return "JOB"

# BillingTagsSourceType definition

BillingTagsSourceType = Literal[
    "JOB",
    "JOB_TEMPLATE",
    "PRESET",
    "QUEUE",
]

BurnInSubtitleStylePassthroughType

# BurnInSubtitleStylePassthroughType usage example

from mypy_boto3_mediaconvert.literals import BurnInSubtitleStylePassthroughType

def get_value() -> BurnInSubtitleStylePassthroughType:
    return "DISABLED"

# BurnInSubtitleStylePassthroughType definition

BurnInSubtitleStylePassthroughType = Literal[
    "DISABLED",
    "ENABLED",
]

BurninSubtitleAlignmentType

# BurninSubtitleAlignmentType usage example

from mypy_boto3_mediaconvert.literals import BurninSubtitleAlignmentType

def get_value() -> BurninSubtitleAlignmentType:
    return "AUTO"

# BurninSubtitleAlignmentType definition

BurninSubtitleAlignmentType = Literal[
    "AUTO",
    "CENTERED",
    "LEFT",
]

BurninSubtitleApplyFontColorType

# BurninSubtitleApplyFontColorType usage example

from mypy_boto3_mediaconvert.literals import BurninSubtitleApplyFontColorType

def get_value() -> BurninSubtitleApplyFontColorType:
    return "ALL_TEXT"

# BurninSubtitleApplyFontColorType definition

BurninSubtitleApplyFontColorType = Literal[
    "ALL_TEXT",
    "WHITE_TEXT_ONLY",
]

BurninSubtitleBackgroundColorType

# BurninSubtitleBackgroundColorType usage example

from mypy_boto3_mediaconvert.literals import BurninSubtitleBackgroundColorType

def get_value() -> BurninSubtitleBackgroundColorType:
    return "AUTO"

# BurninSubtitleBackgroundColorType definition

BurninSubtitleBackgroundColorType = Literal[
    "AUTO",
    "BLACK",
    "NONE",
    "WHITE",
]

BurninSubtitleFallbackFontType

# BurninSubtitleFallbackFontType usage example

from mypy_boto3_mediaconvert.literals import BurninSubtitleFallbackFontType

def get_value() -> BurninSubtitleFallbackFontType:
    return "BEST_MATCH"

# BurninSubtitleFallbackFontType definition

BurninSubtitleFallbackFontType = Literal[
    "BEST_MATCH",
    "MONOSPACED_SANSSERIF",
    "MONOSPACED_SERIF",
    "PROPORTIONAL_SANSSERIF",
    "PROPORTIONAL_SERIF",
]

BurninSubtitleFontColorType

# BurninSubtitleFontColorType usage example

from mypy_boto3_mediaconvert.literals import BurninSubtitleFontColorType

def get_value() -> BurninSubtitleFontColorType:
    return "AUTO"

# BurninSubtitleFontColorType definition

BurninSubtitleFontColorType = Literal[
    "AUTO",
    "BLACK",
    "BLUE",
    "GREEN",
    "HEX",
    "RED",
    "WHITE",
    "YELLOW",
]

BurninSubtitleOutlineColorType

# BurninSubtitleOutlineColorType usage example

from mypy_boto3_mediaconvert.literals import BurninSubtitleOutlineColorType

def get_value() -> BurninSubtitleOutlineColorType:
    return "AUTO"

# BurninSubtitleOutlineColorType definition

BurninSubtitleOutlineColorType = Literal[
    "AUTO",
    "BLACK",
    "BLUE",
    "GREEN",
    "RED",
    "WHITE",
    "YELLOW",
]

BurninSubtitleShadowColorType

# BurninSubtitleShadowColorType usage example

from mypy_boto3_mediaconvert.literals import BurninSubtitleShadowColorType

def get_value() -> BurninSubtitleShadowColorType:
    return "AUTO"

# BurninSubtitleShadowColorType definition

BurninSubtitleShadowColorType = Literal[
    "AUTO",
    "BLACK",
    "NONE",
    "WHITE",
]

BurninSubtitleTeletextSpacingType

# BurninSubtitleTeletextSpacingType usage example

from mypy_boto3_mediaconvert.literals import BurninSubtitleTeletextSpacingType

def get_value() -> BurninSubtitleTeletextSpacingType:
    return "AUTO"

# BurninSubtitleTeletextSpacingType definition

BurninSubtitleTeletextSpacingType = Literal[
    "AUTO",
    "FIXED_GRID",
    "PROPORTIONAL",
]

CaptionDestinationTypeType

# CaptionDestinationTypeType usage example

from mypy_boto3_mediaconvert.literals import CaptionDestinationTypeType

def get_value() -> CaptionDestinationTypeType:
    return "BURN_IN"

# CaptionDestinationTypeType definition

CaptionDestinationTypeType = Literal[
    "BURN_IN",
    "DVB_SUB",
    "EMBEDDED",
    "EMBEDDED_PLUS_SCTE20",
    "IMSC",
    "SCC",
    "SCTE20_PLUS_EMBEDDED",
    "SMI",
    "SRT",
    "TELETEXT",
    "TTML",
    "WEBVTT",
]

CaptionSourceConvertPaintOnToPopOnType

# CaptionSourceConvertPaintOnToPopOnType usage example

from mypy_boto3_mediaconvert.literals import CaptionSourceConvertPaintOnToPopOnType

def get_value() -> CaptionSourceConvertPaintOnToPopOnType:
    return "DISABLED"

# CaptionSourceConvertPaintOnToPopOnType definition

CaptionSourceConvertPaintOnToPopOnType = Literal[
    "DISABLED",
    "ENABLED",
]

CaptionSourceTypeType

# CaptionSourceTypeType usage example

from mypy_boto3_mediaconvert.literals import CaptionSourceTypeType

def get_value() -> CaptionSourceTypeType:
    return "ANCILLARY"

# CaptionSourceTypeType definition

CaptionSourceTypeType = Literal[
    "ANCILLARY",
    "DVB_SUB",
    "EMBEDDED",
    "IMSC",
    "NULL_SOURCE",
    "SCC",
    "SCTE20",
    "SMI",
    "SMPTE_TT",
    "SRT",
    "STL",
    "TELETEXT",
    "TTML",
    "WEBVTT",
]

CmafClientCacheType

# CmafClientCacheType usage example

from mypy_boto3_mediaconvert.literals import CmafClientCacheType

def get_value() -> CmafClientCacheType:
    return "DISABLED"

# CmafClientCacheType definition

CmafClientCacheType = Literal[
    "DISABLED",
    "ENABLED",
]

CmafCodecSpecificationType

# CmafCodecSpecificationType usage example

from mypy_boto3_mediaconvert.literals import CmafCodecSpecificationType

def get_value() -> CmafCodecSpecificationType:
    return "RFC_4281"

# CmafCodecSpecificationType definition

CmafCodecSpecificationType = Literal[
    "RFC_4281",
    "RFC_6381",
]

CmafEncryptionTypeType

# CmafEncryptionTypeType usage example

from mypy_boto3_mediaconvert.literals import CmafEncryptionTypeType

def get_value() -> CmafEncryptionTypeType:
    return "AES_CTR"

# CmafEncryptionTypeType definition

CmafEncryptionTypeType = Literal[
    "AES_CTR",
    "SAMPLE_AES",
]

CmafImageBasedTrickPlayType

# CmafImageBasedTrickPlayType usage example

from mypy_boto3_mediaconvert.literals import CmafImageBasedTrickPlayType

def get_value() -> CmafImageBasedTrickPlayType:
    return "ADVANCED"

# CmafImageBasedTrickPlayType definition

CmafImageBasedTrickPlayType = Literal[
    "ADVANCED",
    "NONE",
    "THUMBNAIL",
    "THUMBNAIL_AND_FULLFRAME",
]

CmafInitializationVectorInManifestType

# CmafInitializationVectorInManifestType usage example

from mypy_boto3_mediaconvert.literals import CmafInitializationVectorInManifestType

def get_value() -> CmafInitializationVectorInManifestType:
    return "EXCLUDE"

# CmafInitializationVectorInManifestType definition

CmafInitializationVectorInManifestType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

CmafIntervalCadenceType

# CmafIntervalCadenceType usage example

from mypy_boto3_mediaconvert.literals import CmafIntervalCadenceType

def get_value() -> CmafIntervalCadenceType:
    return "FOLLOW_CUSTOM"

# CmafIntervalCadenceType definition

CmafIntervalCadenceType = Literal[
    "FOLLOW_CUSTOM",
    "FOLLOW_IFRAME",
]

CmafKeyProviderTypeType

# CmafKeyProviderTypeType usage example

from mypy_boto3_mediaconvert.literals import CmafKeyProviderTypeType

def get_value() -> CmafKeyProviderTypeType:
    return "SPEKE"

# CmafKeyProviderTypeType definition

CmafKeyProviderTypeType = Literal[
    "SPEKE",
    "STATIC_KEY",
]

CmafManifestCompressionType

# CmafManifestCompressionType usage example

from mypy_boto3_mediaconvert.literals import CmafManifestCompressionType

def get_value() -> CmafManifestCompressionType:
    return "GZIP"

# CmafManifestCompressionType definition

CmafManifestCompressionType = Literal[
    "GZIP",
    "NONE",
]

CmafManifestDurationFormatType

# CmafManifestDurationFormatType usage example

from mypy_boto3_mediaconvert.literals import CmafManifestDurationFormatType

def get_value() -> CmafManifestDurationFormatType:
    return "FLOATING_POINT"

# CmafManifestDurationFormatType definition

CmafManifestDurationFormatType = Literal[
    "FLOATING_POINT",
    "INTEGER",
]

CmafMpdManifestBandwidthTypeType

# CmafMpdManifestBandwidthTypeType usage example

from mypy_boto3_mediaconvert.literals import CmafMpdManifestBandwidthTypeType

def get_value() -> CmafMpdManifestBandwidthTypeType:
    return "AVERAGE"

# CmafMpdManifestBandwidthTypeType definition

CmafMpdManifestBandwidthTypeType = Literal[
    "AVERAGE",
    "MAX",
]

CmafMpdProfileType

# CmafMpdProfileType usage example

from mypy_boto3_mediaconvert.literals import CmafMpdProfileType

def get_value() -> CmafMpdProfileType:
    return "MAIN_PROFILE"

# CmafMpdProfileType definition

CmafMpdProfileType = Literal[
    "MAIN_PROFILE",
    "ON_DEMAND_PROFILE",
]

CmafPtsOffsetHandlingForBFramesType

# CmafPtsOffsetHandlingForBFramesType usage example

from mypy_boto3_mediaconvert.literals import CmafPtsOffsetHandlingForBFramesType

def get_value() -> CmafPtsOffsetHandlingForBFramesType:
    return "MATCH_INITIAL_PTS"

# CmafPtsOffsetHandlingForBFramesType definition

CmafPtsOffsetHandlingForBFramesType = Literal[
    "MATCH_INITIAL_PTS",
    "ZERO_BASED",
]

CmafSegmentControlType

# CmafSegmentControlType usage example

from mypy_boto3_mediaconvert.literals import CmafSegmentControlType

def get_value() -> CmafSegmentControlType:
    return "SEGMENTED_FILES"

# CmafSegmentControlType definition

CmafSegmentControlType = Literal[
    "SEGMENTED_FILES",
    "SINGLE_FILE",
]

CmafSegmentLengthControlType

# CmafSegmentLengthControlType usage example

from mypy_boto3_mediaconvert.literals import CmafSegmentLengthControlType

def get_value() -> CmafSegmentLengthControlType:
    return "EXACT"

# CmafSegmentLengthControlType definition

CmafSegmentLengthControlType = Literal[
    "EXACT",
    "GOP_MULTIPLE",
]

CmafStreamInfResolutionType

# CmafStreamInfResolutionType usage example

from mypy_boto3_mediaconvert.literals import CmafStreamInfResolutionType

def get_value() -> CmafStreamInfResolutionType:
    return "EXCLUDE"

# CmafStreamInfResolutionType definition

CmafStreamInfResolutionType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

CmafTargetDurationCompatibilityModeType

# CmafTargetDurationCompatibilityModeType usage example

from mypy_boto3_mediaconvert.literals import CmafTargetDurationCompatibilityModeType

def get_value() -> CmafTargetDurationCompatibilityModeType:
    return "LEGACY"

# CmafTargetDurationCompatibilityModeType definition

CmafTargetDurationCompatibilityModeType = Literal[
    "LEGACY",
    "SPEC_COMPLIANT",
]

CmafVideoCompositionOffsetsType

# CmafVideoCompositionOffsetsType usage example

from mypy_boto3_mediaconvert.literals import CmafVideoCompositionOffsetsType

def get_value() -> CmafVideoCompositionOffsetsType:
    return "SIGNED"

# CmafVideoCompositionOffsetsType definition

CmafVideoCompositionOffsetsType = Literal[
    "SIGNED",
    "UNSIGNED",
]

CmafWriteDASHManifestType

# CmafWriteDASHManifestType usage example

from mypy_boto3_mediaconvert.literals import CmafWriteDASHManifestType

def get_value() -> CmafWriteDASHManifestType:
    return "DISABLED"

# CmafWriteDASHManifestType definition

CmafWriteDASHManifestType = Literal[
    "DISABLED",
    "ENABLED",
]

CmafWriteHLSManifestType

# CmafWriteHLSManifestType usage example

from mypy_boto3_mediaconvert.literals import CmafWriteHLSManifestType

def get_value() -> CmafWriteHLSManifestType:
    return "DISABLED"

# CmafWriteHLSManifestType definition

CmafWriteHLSManifestType = Literal[
    "DISABLED",
    "ENABLED",
]

CmafWriteSegmentTimelineInRepresentationType

# CmafWriteSegmentTimelineInRepresentationType usage example

from mypy_boto3_mediaconvert.literals import CmafWriteSegmentTimelineInRepresentationType

def get_value() -> CmafWriteSegmentTimelineInRepresentationType:
    return "DISABLED"

# CmafWriteSegmentTimelineInRepresentationType definition

CmafWriteSegmentTimelineInRepresentationType = Literal[
    "DISABLED",
    "ENABLED",
]

CmfcAudioDurationType

# CmfcAudioDurationType usage example

from mypy_boto3_mediaconvert.literals import CmfcAudioDurationType

def get_value() -> CmfcAudioDurationType:
    return "DEFAULT_CODEC_DURATION"

# CmfcAudioDurationType definition

CmfcAudioDurationType = Literal[
    "DEFAULT_CODEC_DURATION",
    "MATCH_VIDEO_DURATION",
]

CmfcAudioTrackTypeType

# CmfcAudioTrackTypeType usage example

from mypy_boto3_mediaconvert.literals import CmfcAudioTrackTypeType

def get_value() -> CmfcAudioTrackTypeType:
    return "ALTERNATE_AUDIO_AUTO_SELECT"

# CmfcAudioTrackTypeType definition

CmfcAudioTrackTypeType = Literal[
    "ALTERNATE_AUDIO_AUTO_SELECT",
    "ALTERNATE_AUDIO_AUTO_SELECT_DEFAULT",
    "ALTERNATE_AUDIO_NOT_AUTO_SELECT",
]

CmfcDescriptiveVideoServiceFlagType

# CmfcDescriptiveVideoServiceFlagType usage example

from mypy_boto3_mediaconvert.literals import CmfcDescriptiveVideoServiceFlagType

def get_value() -> CmfcDescriptiveVideoServiceFlagType:
    return "DONT_FLAG"

# CmfcDescriptiveVideoServiceFlagType definition

CmfcDescriptiveVideoServiceFlagType = Literal[
    "DONT_FLAG",
    "FLAG",
]

CmfcIFrameOnlyManifestType

# CmfcIFrameOnlyManifestType usage example

from mypy_boto3_mediaconvert.literals import CmfcIFrameOnlyManifestType

def get_value() -> CmfcIFrameOnlyManifestType:
    return "EXCLUDE"

# CmfcIFrameOnlyManifestType definition

CmfcIFrameOnlyManifestType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

CmfcKlvMetadataType

# CmfcKlvMetadataType usage example

from mypy_boto3_mediaconvert.literals import CmfcKlvMetadataType

def get_value() -> CmfcKlvMetadataType:
    return "NONE"

# CmfcKlvMetadataType definition

CmfcKlvMetadataType = Literal[
    "NONE",
    "PASSTHROUGH",
]

CmfcManifestMetadataSignalingType

# CmfcManifestMetadataSignalingType usage example

from mypy_boto3_mediaconvert.literals import CmfcManifestMetadataSignalingType

def get_value() -> CmfcManifestMetadataSignalingType:
    return "DISABLED"

# CmfcManifestMetadataSignalingType definition

CmfcManifestMetadataSignalingType = Literal[
    "DISABLED",
    "ENABLED",
]

CmfcScte35EsamType

# CmfcScte35EsamType usage example

from mypy_boto3_mediaconvert.literals import CmfcScte35EsamType

def get_value() -> CmfcScte35EsamType:
    return "INSERT"

# CmfcScte35EsamType definition

CmfcScte35EsamType = Literal[
    "INSERT",
    "NONE",
]

CmfcScte35SourceType

# CmfcScte35SourceType usage example

from mypy_boto3_mediaconvert.literals import CmfcScte35SourceType

def get_value() -> CmfcScte35SourceType:
    return "NONE"

# CmfcScte35SourceType definition

CmfcScte35SourceType = Literal[
    "NONE",
    "PASSTHROUGH",
]

CmfcTimedMetadataBoxVersionType

# CmfcTimedMetadataBoxVersionType usage example

from mypy_boto3_mediaconvert.literals import CmfcTimedMetadataBoxVersionType

def get_value() -> CmfcTimedMetadataBoxVersionType:
    return "VERSION_0"

# CmfcTimedMetadataBoxVersionType definition

CmfcTimedMetadataBoxVersionType = Literal[
    "VERSION_0",
    "VERSION_1",
]

CmfcTimedMetadataType

# CmfcTimedMetadataType usage example

from mypy_boto3_mediaconvert.literals import CmfcTimedMetadataType

def get_value() -> CmfcTimedMetadataType:
    return "NONE"

# CmfcTimedMetadataType definition

CmfcTimedMetadataType = Literal[
    "NONE",
    "PASSTHROUGH",
]

ColorMetadataType

# ColorMetadataType usage example

from mypy_boto3_mediaconvert.literals import ColorMetadataType

def get_value() -> ColorMetadataType:
    return "IGNORE"

# ColorMetadataType definition

ColorMetadataType = Literal[
    "IGNORE",
    "INSERT",
]

ColorSpaceConversionType

# ColorSpaceConversionType usage example

from mypy_boto3_mediaconvert.literals import ColorSpaceConversionType

def get_value() -> ColorSpaceConversionType:
    return "FORCE_601"

# ColorSpaceConversionType definition

ColorSpaceConversionType = Literal[
    "FORCE_601",
    "FORCE_709",
    "FORCE_HDR10",
    "FORCE_HLG_2020",
    "FORCE_P3D65_HDR",
    "FORCE_P3D65_SDR",
    "FORCE_P3DCI",
    "NONE",
]

ColorSpaceType

# ColorSpaceType usage example

from mypy_boto3_mediaconvert.literals import ColorSpaceType

def get_value() -> ColorSpaceType:
    return "FOLLOW"

# ColorSpaceType definition

ColorSpaceType = Literal[
    "FOLLOW",
    "HDR10",
    "HLG_2020",
    "P3D65_HDR",
    "P3D65_SDR",
    "P3DCI",
    "REC_601",
    "REC_709",
]

ColorSpaceUsageType

# ColorSpaceUsageType usage example

from mypy_boto3_mediaconvert.literals import ColorSpaceUsageType

def get_value() -> ColorSpaceUsageType:
    return "FALLBACK"

# ColorSpaceUsageType definition

ColorSpaceUsageType = Literal[
    "FALLBACK",
    "FORCE",
]

CommitmentType

# CommitmentType usage example

from mypy_boto3_mediaconvert.literals import CommitmentType

def get_value() -> CommitmentType:
    return "ONE_YEAR"

# CommitmentType definition

CommitmentType = Literal[
    "ONE_YEAR",
]

ContainerTypeType

# ContainerTypeType usage example

from mypy_boto3_mediaconvert.literals import ContainerTypeType

def get_value() -> ContainerTypeType:
    return "CMFC"

# ContainerTypeType definition

ContainerTypeType = Literal[
    "CMFC",
    "F4V",
    "ISMV",
    "M2TS",
    "M3U8",
    "MOV",
    "MP4",
    "MPD",
    "MXF",
    "RAW",
    "WEBM",
]

CopyProtectionActionType

# CopyProtectionActionType usage example

from mypy_boto3_mediaconvert.literals import CopyProtectionActionType

def get_value() -> CopyProtectionActionType:
    return "PASSTHROUGH"

# CopyProtectionActionType definition

CopyProtectionActionType = Literal[
    "PASSTHROUGH",
    "STRIP",
]

DashIsoGroupAudioChannelConfigSchemeIdUriType

# DashIsoGroupAudioChannelConfigSchemeIdUriType usage example

from mypy_boto3_mediaconvert.literals import DashIsoGroupAudioChannelConfigSchemeIdUriType

def get_value() -> DashIsoGroupAudioChannelConfigSchemeIdUriType:
    return "DOLBY_CHANNEL_CONFIGURATION"

# DashIsoGroupAudioChannelConfigSchemeIdUriType definition

DashIsoGroupAudioChannelConfigSchemeIdUriType = Literal[
    "DOLBY_CHANNEL_CONFIGURATION",
    "MPEG_CHANNEL_CONFIGURATION",
]

DashIsoHbbtvComplianceType

# DashIsoHbbtvComplianceType usage example

from mypy_boto3_mediaconvert.literals import DashIsoHbbtvComplianceType

def get_value() -> DashIsoHbbtvComplianceType:
    return "HBBTV_1_5"

# DashIsoHbbtvComplianceType definition

DashIsoHbbtvComplianceType = Literal[
    "HBBTV_1_5",
    "NONE",
]

DashIsoImageBasedTrickPlayType

# DashIsoImageBasedTrickPlayType usage example

from mypy_boto3_mediaconvert.literals import DashIsoImageBasedTrickPlayType

def get_value() -> DashIsoImageBasedTrickPlayType:
    return "ADVANCED"

# DashIsoImageBasedTrickPlayType definition

DashIsoImageBasedTrickPlayType = Literal[
    "ADVANCED",
    "NONE",
    "THUMBNAIL",
    "THUMBNAIL_AND_FULLFRAME",
]

DashIsoIntervalCadenceType

# DashIsoIntervalCadenceType usage example

from mypy_boto3_mediaconvert.literals import DashIsoIntervalCadenceType

def get_value() -> DashIsoIntervalCadenceType:
    return "FOLLOW_CUSTOM"

# DashIsoIntervalCadenceType definition

DashIsoIntervalCadenceType = Literal[
    "FOLLOW_CUSTOM",
    "FOLLOW_IFRAME",
]

DashIsoMpdManifestBandwidthTypeType

# DashIsoMpdManifestBandwidthTypeType usage example

from mypy_boto3_mediaconvert.literals import DashIsoMpdManifestBandwidthTypeType

def get_value() -> DashIsoMpdManifestBandwidthTypeType:
    return "AVERAGE"

# DashIsoMpdManifestBandwidthTypeType definition

DashIsoMpdManifestBandwidthTypeType = Literal[
    "AVERAGE",
    "MAX",
]

DashIsoMpdProfileType

# DashIsoMpdProfileType usage example

from mypy_boto3_mediaconvert.literals import DashIsoMpdProfileType

def get_value() -> DashIsoMpdProfileType:
    return "MAIN_PROFILE"

# DashIsoMpdProfileType definition

DashIsoMpdProfileType = Literal[
    "MAIN_PROFILE",
    "ON_DEMAND_PROFILE",
]

DashIsoPlaybackDeviceCompatibilityType

# DashIsoPlaybackDeviceCompatibilityType usage example

from mypy_boto3_mediaconvert.literals import DashIsoPlaybackDeviceCompatibilityType

def get_value() -> DashIsoPlaybackDeviceCompatibilityType:
    return "CENC_V1"

# DashIsoPlaybackDeviceCompatibilityType definition

DashIsoPlaybackDeviceCompatibilityType = Literal[
    "CENC_V1",
    "UNENCRYPTED_SEI",
]

DashIsoPtsOffsetHandlingForBFramesType

# DashIsoPtsOffsetHandlingForBFramesType usage example

from mypy_boto3_mediaconvert.literals import DashIsoPtsOffsetHandlingForBFramesType

def get_value() -> DashIsoPtsOffsetHandlingForBFramesType:
    return "MATCH_INITIAL_PTS"

# DashIsoPtsOffsetHandlingForBFramesType definition

DashIsoPtsOffsetHandlingForBFramesType = Literal[
    "MATCH_INITIAL_PTS",
    "ZERO_BASED",
]

DashIsoSegmentControlType

# DashIsoSegmentControlType usage example

from mypy_boto3_mediaconvert.literals import DashIsoSegmentControlType

def get_value() -> DashIsoSegmentControlType:
    return "SEGMENTED_FILES"

# DashIsoSegmentControlType definition

DashIsoSegmentControlType = Literal[
    "SEGMENTED_FILES",
    "SINGLE_FILE",
]

DashIsoSegmentLengthControlType

# DashIsoSegmentLengthControlType usage example

from mypy_boto3_mediaconvert.literals import DashIsoSegmentLengthControlType

def get_value() -> DashIsoSegmentLengthControlType:
    return "EXACT"

# DashIsoSegmentLengthControlType definition

DashIsoSegmentLengthControlType = Literal[
    "EXACT",
    "GOP_MULTIPLE",
]

DashIsoVideoCompositionOffsetsType

# DashIsoVideoCompositionOffsetsType usage example

from mypy_boto3_mediaconvert.literals import DashIsoVideoCompositionOffsetsType

def get_value() -> DashIsoVideoCompositionOffsetsType:
    return "SIGNED"

# DashIsoVideoCompositionOffsetsType definition

DashIsoVideoCompositionOffsetsType = Literal[
    "SIGNED",
    "UNSIGNED",
]

DashIsoWriteSegmentTimelineInRepresentationType

# DashIsoWriteSegmentTimelineInRepresentationType usage example

from mypy_boto3_mediaconvert.literals import DashIsoWriteSegmentTimelineInRepresentationType

def get_value() -> DashIsoWriteSegmentTimelineInRepresentationType:
    return "DISABLED"

# DashIsoWriteSegmentTimelineInRepresentationType definition

DashIsoWriteSegmentTimelineInRepresentationType = Literal[
    "DISABLED",
    "ENABLED",
]

DashManifestStyleType

# DashManifestStyleType usage example

from mypy_boto3_mediaconvert.literals import DashManifestStyleType

def get_value() -> DashManifestStyleType:
    return "BASIC"

# DashManifestStyleType definition

DashManifestStyleType = Literal[
    "BASIC",
    "COMPACT",
    "DISTINCT",
]

DecryptionModeType

# DecryptionModeType usage example

from mypy_boto3_mediaconvert.literals import DecryptionModeType

def get_value() -> DecryptionModeType:
    return "AES_CBC"

# DecryptionModeType definition

DecryptionModeType = Literal[
    "AES_CBC",
    "AES_CTR",
    "AES_GCM",
]

DeinterlaceAlgorithmType

# DeinterlaceAlgorithmType usage example

from mypy_boto3_mediaconvert.literals import DeinterlaceAlgorithmType

def get_value() -> DeinterlaceAlgorithmType:
    return "BLEND"

# DeinterlaceAlgorithmType definition

DeinterlaceAlgorithmType = Literal[
    "BLEND",
    "BLEND_TICKER",
    "INTERPOLATE",
    "INTERPOLATE_TICKER",
    "LINEAR_INTERPOLATION",
]

DeinterlacerControlType

# DeinterlacerControlType usage example

from mypy_boto3_mediaconvert.literals import DeinterlacerControlType

def get_value() -> DeinterlacerControlType:
    return "FORCE_ALL_FRAMES"

# DeinterlacerControlType definition

DeinterlacerControlType = Literal[
    "FORCE_ALL_FRAMES",
    "NORMAL",
]

DeinterlacerModeType

# DeinterlacerModeType usage example

from mypy_boto3_mediaconvert.literals import DeinterlacerModeType

def get_value() -> DeinterlacerModeType:
    return "ADAPTIVE"

# DeinterlacerModeType definition

DeinterlacerModeType = Literal[
    "ADAPTIVE",
    "DEINTERLACE",
    "INVERSE_TELECINE",
]

DescribeEndpointsModeType

# DescribeEndpointsModeType usage example

from mypy_boto3_mediaconvert.literals import DescribeEndpointsModeType

def get_value() -> DescribeEndpointsModeType:
    return "DEFAULT"

# DescribeEndpointsModeType definition

DescribeEndpointsModeType = Literal[
    "DEFAULT",
    "GET_ONLY",
]

DescribeEndpointsPaginatorName

# DescribeEndpointsPaginatorName usage example

from mypy_boto3_mediaconvert.literals import DescribeEndpointsPaginatorName

def get_value() -> DescribeEndpointsPaginatorName:
    return "describe_endpoints"

# DescribeEndpointsPaginatorName definition

DescribeEndpointsPaginatorName = Literal[
    "describe_endpoints",
]

DolbyVisionLevel6ModeType

# DolbyVisionLevel6ModeType usage example

from mypy_boto3_mediaconvert.literals import DolbyVisionLevel6ModeType

def get_value() -> DolbyVisionLevel6ModeType:
    return "PASSTHROUGH"

# DolbyVisionLevel6ModeType definition

DolbyVisionLevel6ModeType = Literal[
    "PASSTHROUGH",
    "RECALCULATE",
    "SPECIFY",
]

DolbyVisionMappingType

# DolbyVisionMappingType usage example

from mypy_boto3_mediaconvert.literals import DolbyVisionMappingType

def get_value() -> DolbyVisionMappingType:
    return "HDR10_1000"

# DolbyVisionMappingType definition

DolbyVisionMappingType = Literal[
    "HDR10_1000",
    "HDR10_NOMAP",
]

DolbyVisionProfileType

# DolbyVisionProfileType usage example

from mypy_boto3_mediaconvert.literals import DolbyVisionProfileType

def get_value() -> DolbyVisionProfileType:
    return "PROFILE_5"

# DolbyVisionProfileType definition

DolbyVisionProfileType = Literal[
    "PROFILE_5",
    "PROFILE_8_1",
]

DropFrameTimecodeType

# DropFrameTimecodeType usage example

from mypy_boto3_mediaconvert.literals import DropFrameTimecodeType

def get_value() -> DropFrameTimecodeType:
    return "DISABLED"

# DropFrameTimecodeType definition

DropFrameTimecodeType = Literal[
    "DISABLED",
    "ENABLED",
]

DvbSubSubtitleFallbackFontType

# DvbSubSubtitleFallbackFontType usage example

from mypy_boto3_mediaconvert.literals import DvbSubSubtitleFallbackFontType

def get_value() -> DvbSubSubtitleFallbackFontType:
    return "BEST_MATCH"

# DvbSubSubtitleFallbackFontType definition

DvbSubSubtitleFallbackFontType = Literal[
    "BEST_MATCH",
    "MONOSPACED_SANSSERIF",
    "MONOSPACED_SERIF",
    "PROPORTIONAL_SANSSERIF",
    "PROPORTIONAL_SERIF",
]

DvbSubtitleAlignmentType

# DvbSubtitleAlignmentType usage example

from mypy_boto3_mediaconvert.literals import DvbSubtitleAlignmentType

def get_value() -> DvbSubtitleAlignmentType:
    return "AUTO"

# DvbSubtitleAlignmentType definition

DvbSubtitleAlignmentType = Literal[
    "AUTO",
    "CENTERED",
    "LEFT",
]

DvbSubtitleApplyFontColorType

# DvbSubtitleApplyFontColorType usage example

from mypy_boto3_mediaconvert.literals import DvbSubtitleApplyFontColorType

def get_value() -> DvbSubtitleApplyFontColorType:
    return "ALL_TEXT"

# DvbSubtitleApplyFontColorType definition

DvbSubtitleApplyFontColorType = Literal[
    "ALL_TEXT",
    "WHITE_TEXT_ONLY",
]

DvbSubtitleBackgroundColorType

# DvbSubtitleBackgroundColorType usage example

from mypy_boto3_mediaconvert.literals import DvbSubtitleBackgroundColorType

def get_value() -> DvbSubtitleBackgroundColorType:
    return "AUTO"

# DvbSubtitleBackgroundColorType definition

DvbSubtitleBackgroundColorType = Literal[
    "AUTO",
    "BLACK",
    "NONE",
    "WHITE",
]

DvbSubtitleFontColorType

# DvbSubtitleFontColorType usage example

from mypy_boto3_mediaconvert.literals import DvbSubtitleFontColorType

def get_value() -> DvbSubtitleFontColorType:
    return "AUTO"

# DvbSubtitleFontColorType definition

DvbSubtitleFontColorType = Literal[
    "AUTO",
    "BLACK",
    "BLUE",
    "GREEN",
    "HEX",
    "RED",
    "WHITE",
    "YELLOW",
]

DvbSubtitleOutlineColorType

# DvbSubtitleOutlineColorType usage example

from mypy_boto3_mediaconvert.literals import DvbSubtitleOutlineColorType

def get_value() -> DvbSubtitleOutlineColorType:
    return "AUTO"

# DvbSubtitleOutlineColorType definition

DvbSubtitleOutlineColorType = Literal[
    "AUTO",
    "BLACK",
    "BLUE",
    "GREEN",
    "RED",
    "WHITE",
    "YELLOW",
]

DvbSubtitleShadowColorType

# DvbSubtitleShadowColorType usage example

from mypy_boto3_mediaconvert.literals import DvbSubtitleShadowColorType

def get_value() -> DvbSubtitleShadowColorType:
    return "AUTO"

# DvbSubtitleShadowColorType definition

DvbSubtitleShadowColorType = Literal[
    "AUTO",
    "BLACK",
    "NONE",
    "WHITE",
]

DvbSubtitleStylePassthroughType

# DvbSubtitleStylePassthroughType usage example

from mypy_boto3_mediaconvert.literals import DvbSubtitleStylePassthroughType

def get_value() -> DvbSubtitleStylePassthroughType:
    return "DISABLED"

# DvbSubtitleStylePassthroughType definition

DvbSubtitleStylePassthroughType = Literal[
    "DISABLED",
    "ENABLED",
]

DvbSubtitleTeletextSpacingType

# DvbSubtitleTeletextSpacingType usage example

from mypy_boto3_mediaconvert.literals import DvbSubtitleTeletextSpacingType

def get_value() -> DvbSubtitleTeletextSpacingType:
    return "AUTO"

# DvbSubtitleTeletextSpacingType definition

DvbSubtitleTeletextSpacingType = Literal[
    "AUTO",
    "FIXED_GRID",
    "PROPORTIONAL",
]

DvbSubtitlingTypeType

# DvbSubtitlingTypeType usage example

from mypy_boto3_mediaconvert.literals import DvbSubtitlingTypeType

def get_value() -> DvbSubtitlingTypeType:
    return "HEARING_IMPAIRED"

# DvbSubtitlingTypeType definition

DvbSubtitlingTypeType = Literal[
    "HEARING_IMPAIRED",
    "STANDARD",
]

DvbddsHandlingType

# DvbddsHandlingType usage example

from mypy_boto3_mediaconvert.literals import DvbddsHandlingType

def get_value() -> DvbddsHandlingType:
    return "NONE"

# DvbddsHandlingType definition

DvbddsHandlingType = Literal[
    "NO_DISPLAY_WINDOW",
    "NONE",
    "SPECIFIED",
]

Eac3AtmosBitstreamModeType

# Eac3AtmosBitstreamModeType usage example

from mypy_boto3_mediaconvert.literals import Eac3AtmosBitstreamModeType

def get_value() -> Eac3AtmosBitstreamModeType:
    return "COMPLETE_MAIN"

# Eac3AtmosBitstreamModeType definition

Eac3AtmosBitstreamModeType = Literal[
    "COMPLETE_MAIN",
]

Eac3AtmosCodingModeType

# Eac3AtmosCodingModeType usage example

from mypy_boto3_mediaconvert.literals import Eac3AtmosCodingModeType

def get_value() -> Eac3AtmosCodingModeType:
    return "CODING_MODE_5_1_4"

# Eac3AtmosCodingModeType definition

Eac3AtmosCodingModeType = Literal[
    "CODING_MODE_5_1_4",
    "CODING_MODE_7_1_4",
    "CODING_MODE_9_1_6",
    "CODING_MODE_AUTO",
]

Eac3AtmosDialogueIntelligenceType

# Eac3AtmosDialogueIntelligenceType usage example

from mypy_boto3_mediaconvert.literals import Eac3AtmosDialogueIntelligenceType

def get_value() -> Eac3AtmosDialogueIntelligenceType:
    return "DISABLED"

# Eac3AtmosDialogueIntelligenceType definition

Eac3AtmosDialogueIntelligenceType = Literal[
    "DISABLED",
    "ENABLED",
]

Eac3AtmosDownmixControlType

# Eac3AtmosDownmixControlType usage example

from mypy_boto3_mediaconvert.literals import Eac3AtmosDownmixControlType

def get_value() -> Eac3AtmosDownmixControlType:
    return "INITIALIZE_FROM_SOURCE"

# Eac3AtmosDownmixControlType definition

Eac3AtmosDownmixControlType = Literal[
    "INITIALIZE_FROM_SOURCE",
    "SPECIFIED",
]

Eac3AtmosDynamicRangeCompressionLineType

# Eac3AtmosDynamicRangeCompressionLineType usage example

from mypy_boto3_mediaconvert.literals import Eac3AtmosDynamicRangeCompressionLineType

def get_value() -> Eac3AtmosDynamicRangeCompressionLineType:
    return "FILM_LIGHT"

# Eac3AtmosDynamicRangeCompressionLineType definition

Eac3AtmosDynamicRangeCompressionLineType = Literal[
    "FILM_LIGHT",
    "FILM_STANDARD",
    "MUSIC_LIGHT",
    "MUSIC_STANDARD",
    "NONE",
    "SPEECH",
]

Eac3AtmosDynamicRangeCompressionRfType

# Eac3AtmosDynamicRangeCompressionRfType usage example

from mypy_boto3_mediaconvert.literals import Eac3AtmosDynamicRangeCompressionRfType

def get_value() -> Eac3AtmosDynamicRangeCompressionRfType:
    return "FILM_LIGHT"

# Eac3AtmosDynamicRangeCompressionRfType definition

Eac3AtmosDynamicRangeCompressionRfType = Literal[
    "FILM_LIGHT",
    "FILM_STANDARD",
    "MUSIC_LIGHT",
    "MUSIC_STANDARD",
    "NONE",
    "SPEECH",
]

Eac3AtmosDynamicRangeControlType

# Eac3AtmosDynamicRangeControlType usage example

from mypy_boto3_mediaconvert.literals import Eac3AtmosDynamicRangeControlType

def get_value() -> Eac3AtmosDynamicRangeControlType:
    return "INITIALIZE_FROM_SOURCE"

# Eac3AtmosDynamicRangeControlType definition

Eac3AtmosDynamicRangeControlType = Literal[
    "INITIALIZE_FROM_SOURCE",
    "SPECIFIED",
]

Eac3AtmosMeteringModeType

# Eac3AtmosMeteringModeType usage example

from mypy_boto3_mediaconvert.literals import Eac3AtmosMeteringModeType

def get_value() -> Eac3AtmosMeteringModeType:
    return "ITU_BS_1770_1"

# Eac3AtmosMeteringModeType definition

Eac3AtmosMeteringModeType = Literal[
    "ITU_BS_1770_1",
    "ITU_BS_1770_2",
    "ITU_BS_1770_3",
    "ITU_BS_1770_4",
    "LEQ_A",
]

Eac3AtmosStereoDownmixType

# Eac3AtmosStereoDownmixType usage example

from mypy_boto3_mediaconvert.literals import Eac3AtmosStereoDownmixType

def get_value() -> Eac3AtmosStereoDownmixType:
    return "DPL2"

# Eac3AtmosStereoDownmixType definition

Eac3AtmosStereoDownmixType = Literal[
    "DPL2",
    "NOT_INDICATED",
    "STEREO",
    "SURROUND",
]

Eac3AtmosSurroundExModeType

# Eac3AtmosSurroundExModeType usage example

from mypy_boto3_mediaconvert.literals import Eac3AtmosSurroundExModeType

def get_value() -> Eac3AtmosSurroundExModeType:
    return "DISABLED"

# Eac3AtmosSurroundExModeType definition

Eac3AtmosSurroundExModeType = Literal[
    "DISABLED",
    "ENABLED",
    "NOT_INDICATED",
]

Eac3AttenuationControlType

# Eac3AttenuationControlType usage example

from mypy_boto3_mediaconvert.literals import Eac3AttenuationControlType

def get_value() -> Eac3AttenuationControlType:
    return "ATTENUATE_3_DB"

# Eac3AttenuationControlType definition

Eac3AttenuationControlType = Literal[
    "ATTENUATE_3_DB",
    "NONE",
]

Eac3BitstreamModeType

# Eac3BitstreamModeType usage example

from mypy_boto3_mediaconvert.literals import Eac3BitstreamModeType

def get_value() -> Eac3BitstreamModeType:
    return "COMMENTARY"

# Eac3BitstreamModeType definition

Eac3BitstreamModeType = Literal[
    "COMMENTARY",
    "COMPLETE_MAIN",
    "EMERGENCY",
    "HEARING_IMPAIRED",
    "VISUALLY_IMPAIRED",
]

Eac3CodingModeType

# Eac3CodingModeType usage example

from mypy_boto3_mediaconvert.literals import Eac3CodingModeType

def get_value() -> Eac3CodingModeType:
    return "CODING_MODE_1_0"

# Eac3CodingModeType definition

Eac3CodingModeType = Literal[
    "CODING_MODE_1_0",
    "CODING_MODE_2_0",
    "CODING_MODE_3_2",
]

Eac3DcFilterType

# Eac3DcFilterType usage example

from mypy_boto3_mediaconvert.literals import Eac3DcFilterType

def get_value() -> Eac3DcFilterType:
    return "DISABLED"

# Eac3DcFilterType definition

Eac3DcFilterType = Literal[
    "DISABLED",
    "ENABLED",
]

Eac3DynamicRangeCompressionLineType

# Eac3DynamicRangeCompressionLineType usage example

from mypy_boto3_mediaconvert.literals import Eac3DynamicRangeCompressionLineType

def get_value() -> Eac3DynamicRangeCompressionLineType:
    return "FILM_LIGHT"

# Eac3DynamicRangeCompressionLineType definition

Eac3DynamicRangeCompressionLineType = Literal[
    "FILM_LIGHT",
    "FILM_STANDARD",
    "MUSIC_LIGHT",
    "MUSIC_STANDARD",
    "NONE",
    "SPEECH",
]

Eac3DynamicRangeCompressionRfType

# Eac3DynamicRangeCompressionRfType usage example

from mypy_boto3_mediaconvert.literals import Eac3DynamicRangeCompressionRfType

def get_value() -> Eac3DynamicRangeCompressionRfType:
    return "FILM_LIGHT"

# Eac3DynamicRangeCompressionRfType definition

Eac3DynamicRangeCompressionRfType = Literal[
    "FILM_LIGHT",
    "FILM_STANDARD",
    "MUSIC_LIGHT",
    "MUSIC_STANDARD",
    "NONE",
    "SPEECH",
]

Eac3LfeControlType

# Eac3LfeControlType usage example

from mypy_boto3_mediaconvert.literals import Eac3LfeControlType

def get_value() -> Eac3LfeControlType:
    return "LFE"

# Eac3LfeControlType definition

Eac3LfeControlType = Literal[
    "LFE",
    "NO_LFE",
]

Eac3LfeFilterType

# Eac3LfeFilterType usage example

from mypy_boto3_mediaconvert.literals import Eac3LfeFilterType

def get_value() -> Eac3LfeFilterType:
    return "DISABLED"

# Eac3LfeFilterType definition

Eac3LfeFilterType = Literal[
    "DISABLED",
    "ENABLED",
]

Eac3MetadataControlType

# Eac3MetadataControlType usage example

from mypy_boto3_mediaconvert.literals import Eac3MetadataControlType

def get_value() -> Eac3MetadataControlType:
    return "FOLLOW_INPUT"

# Eac3MetadataControlType definition

Eac3MetadataControlType = Literal[
    "FOLLOW_INPUT",
    "USE_CONFIGURED",
]

Eac3PassthroughControlType

# Eac3PassthroughControlType usage example

from mypy_boto3_mediaconvert.literals import Eac3PassthroughControlType

def get_value() -> Eac3PassthroughControlType:
    return "NO_PASSTHROUGH"

# Eac3PassthroughControlType definition

Eac3PassthroughControlType = Literal[
    "NO_PASSTHROUGH",
    "WHEN_POSSIBLE",
]

Eac3PhaseControlType

# Eac3PhaseControlType usage example

from mypy_boto3_mediaconvert.literals import Eac3PhaseControlType

def get_value() -> Eac3PhaseControlType:
    return "NO_SHIFT"

# Eac3PhaseControlType definition

Eac3PhaseControlType = Literal[
    "NO_SHIFT",
    "SHIFT_90_DEGREES",
]

Eac3StereoDownmixType

# Eac3StereoDownmixType usage example

from mypy_boto3_mediaconvert.literals import Eac3StereoDownmixType

def get_value() -> Eac3StereoDownmixType:
    return "DPL2"

# Eac3StereoDownmixType definition

Eac3StereoDownmixType = Literal[
    "DPL2",
    "LO_RO",
    "LT_RT",
    "NOT_INDICATED",
]

Eac3SurroundExModeType

# Eac3SurroundExModeType usage example

from mypy_boto3_mediaconvert.literals import Eac3SurroundExModeType

def get_value() -> Eac3SurroundExModeType:
    return "DISABLED"

# Eac3SurroundExModeType definition

Eac3SurroundExModeType = Literal[
    "DISABLED",
    "ENABLED",
    "NOT_INDICATED",
]

Eac3SurroundModeType

# Eac3SurroundModeType usage example

from mypy_boto3_mediaconvert.literals import Eac3SurroundModeType

def get_value() -> Eac3SurroundModeType:
    return "DISABLED"

# Eac3SurroundModeType definition

Eac3SurroundModeType = Literal[
    "DISABLED",
    "ENABLED",
    "NOT_INDICATED",
]

EmbeddedConvert608To708Type

# EmbeddedConvert608To708Type usage example

from mypy_boto3_mediaconvert.literals import EmbeddedConvert608To708Type

def get_value() -> EmbeddedConvert608To708Type:
    return "DISABLED"

# EmbeddedConvert608To708Type definition

EmbeddedConvert608To708Type = Literal[
    "DISABLED",
    "UPCONVERT",
]

EmbeddedTerminateCaptionsType

# EmbeddedTerminateCaptionsType usage example

from mypy_boto3_mediaconvert.literals import EmbeddedTerminateCaptionsType

def get_value() -> EmbeddedTerminateCaptionsType:
    return "DISABLED"

# EmbeddedTerminateCaptionsType definition

EmbeddedTerminateCaptionsType = Literal[
    "DISABLED",
    "END_OF_INPUT",
]

EmbeddedTimecodeOverrideType

# EmbeddedTimecodeOverrideType usage example

from mypy_boto3_mediaconvert.literals import EmbeddedTimecodeOverrideType

def get_value() -> EmbeddedTimecodeOverrideType:
    return "NONE"

# EmbeddedTimecodeOverrideType definition

EmbeddedTimecodeOverrideType = Literal[
    "NONE",
    "USE_MDPM",
]

F4vMoovPlacementType

# F4vMoovPlacementType usage example

from mypy_boto3_mediaconvert.literals import F4vMoovPlacementType

def get_value() -> F4vMoovPlacementType:
    return "NORMAL"

# F4vMoovPlacementType definition

F4vMoovPlacementType = Literal[
    "NORMAL",
    "PROGRESSIVE_DOWNLOAD",
]

FileSourceConvert608To708Type

# FileSourceConvert608To708Type usage example

from mypy_boto3_mediaconvert.literals import FileSourceConvert608To708Type

def get_value() -> FileSourceConvert608To708Type:
    return "DISABLED"

# FileSourceConvert608To708Type definition

FileSourceConvert608To708Type = Literal[
    "DISABLED",
    "UPCONVERT",
]

FileSourceTimeDeltaUnitsType

# FileSourceTimeDeltaUnitsType usage example

from mypy_boto3_mediaconvert.literals import FileSourceTimeDeltaUnitsType

def get_value() -> FileSourceTimeDeltaUnitsType:
    return "MILLISECONDS"

# FileSourceTimeDeltaUnitsType definition

FileSourceTimeDeltaUnitsType = Literal[
    "MILLISECONDS",
    "SECONDS",
]

FontScriptType

# FontScriptType usage example

from mypy_boto3_mediaconvert.literals import FontScriptType

def get_value() -> FontScriptType:
    return "AUTOMATIC"

# FontScriptType definition

FontScriptType = Literal[
    "AUTOMATIC",
    "HANS",
    "HANT",
]

H264AdaptiveQuantizationType

# H264AdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import H264AdaptiveQuantizationType

def get_value() -> H264AdaptiveQuantizationType:
    return "AUTO"

# H264AdaptiveQuantizationType definition

H264AdaptiveQuantizationType = Literal[
    "AUTO",
    "HIGH",
    "HIGHER",
    "LOW",
    "MAX",
    "MEDIUM",
    "OFF",
]

H264CodecLevelType

# H264CodecLevelType usage example

from mypy_boto3_mediaconvert.literals import H264CodecLevelType

def get_value() -> H264CodecLevelType:
    return "AUTO"

# H264CodecLevelType definition

H264CodecLevelType = Literal[
    "AUTO",
    "LEVEL_1",
    "LEVEL_1_1",
    "LEVEL_1_2",
    "LEVEL_1_3",
    "LEVEL_2",
    "LEVEL_2_1",
    "LEVEL_2_2",
    "LEVEL_3",
    "LEVEL_3_1",
    "LEVEL_3_2",
    "LEVEL_4",
    "LEVEL_4_1",
    "LEVEL_4_2",
    "LEVEL_5",
    "LEVEL_5_1",
    "LEVEL_5_2",
]

H264CodecProfileType

# H264CodecProfileType usage example

from mypy_boto3_mediaconvert.literals import H264CodecProfileType

def get_value() -> H264CodecProfileType:
    return "BASELINE"

# H264CodecProfileType definition

H264CodecProfileType = Literal[
    "BASELINE",
    "HIGH",
    "HIGH_10BIT",
    "HIGH_422",
    "HIGH_422_10BIT",
    "MAIN",
]

H264DynamicSubGopType

# H264DynamicSubGopType usage example

from mypy_boto3_mediaconvert.literals import H264DynamicSubGopType

def get_value() -> H264DynamicSubGopType:
    return "ADAPTIVE"

# H264DynamicSubGopType definition

H264DynamicSubGopType = Literal[
    "ADAPTIVE",
    "STATIC",
]

H264EntropyEncodingType

# H264EntropyEncodingType usage example

from mypy_boto3_mediaconvert.literals import H264EntropyEncodingType

def get_value() -> H264EntropyEncodingType:
    return "CABAC"

# H264EntropyEncodingType definition

H264EntropyEncodingType = Literal[
    "CABAC",
    "CAVLC",
]

H264FieldEncodingType

# H264FieldEncodingType usage example

from mypy_boto3_mediaconvert.literals import H264FieldEncodingType

def get_value() -> H264FieldEncodingType:
    return "FORCE_FIELD"

# H264FieldEncodingType definition

H264FieldEncodingType = Literal[
    "FORCE_FIELD",
    "MBAFF",
    "PAFF",
]

H264FlickerAdaptiveQuantizationType

# H264FlickerAdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import H264FlickerAdaptiveQuantizationType

def get_value() -> H264FlickerAdaptiveQuantizationType:
    return "DISABLED"

# H264FlickerAdaptiveQuantizationType definition

H264FlickerAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

H264FramerateControlType

# H264FramerateControlType usage example

from mypy_boto3_mediaconvert.literals import H264FramerateControlType

def get_value() -> H264FramerateControlType:
    return "INITIALIZE_FROM_SOURCE"

# H264FramerateControlType definition

H264FramerateControlType = Literal[
    "INITIALIZE_FROM_SOURCE",
    "SPECIFIED",
]

H264FramerateConversionAlgorithmType

# H264FramerateConversionAlgorithmType usage example

from mypy_boto3_mediaconvert.literals import H264FramerateConversionAlgorithmType

def get_value() -> H264FramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"

# H264FramerateConversionAlgorithmType definition

H264FramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "FRAMEFORMER",
    "INTERPOLATE",
]

H264GopBReferenceType

# H264GopBReferenceType usage example

from mypy_boto3_mediaconvert.literals import H264GopBReferenceType

def get_value() -> H264GopBReferenceType:
    return "DISABLED"

# H264GopBReferenceType definition

H264GopBReferenceType = Literal[
    "DISABLED",
    "ENABLED",
]

H264GopSizeUnitsType

# H264GopSizeUnitsType usage example

from mypy_boto3_mediaconvert.literals import H264GopSizeUnitsType

def get_value() -> H264GopSizeUnitsType:
    return "AUTO"

# H264GopSizeUnitsType definition

H264GopSizeUnitsType = Literal[
    "AUTO",
    "FRAMES",
    "SECONDS",
]

H264InterlaceModeType

# H264InterlaceModeType usage example

from mypy_boto3_mediaconvert.literals import H264InterlaceModeType

def get_value() -> H264InterlaceModeType:
    return "BOTTOM_FIELD"

# H264InterlaceModeType definition

H264InterlaceModeType = Literal[
    "BOTTOM_FIELD",
    "FOLLOW_BOTTOM_FIELD",
    "FOLLOW_TOP_FIELD",
    "PROGRESSIVE",
    "TOP_FIELD",
]

H264ParControlType

# H264ParControlType usage example

from mypy_boto3_mediaconvert.literals import H264ParControlType

def get_value() -> H264ParControlType:
    return "INITIALIZE_FROM_SOURCE"

# H264ParControlType definition

H264ParControlType = Literal[
    "INITIALIZE_FROM_SOURCE",
    "SPECIFIED",
]

H264QualityTuningLevelType

# H264QualityTuningLevelType usage example

from mypy_boto3_mediaconvert.literals import H264QualityTuningLevelType

def get_value() -> H264QualityTuningLevelType:
    return "MULTI_PASS_HQ"

# H264QualityTuningLevelType definition

H264QualityTuningLevelType = Literal[
    "MULTI_PASS_HQ",
    "SINGLE_PASS",
    "SINGLE_PASS_HQ",
]

H264RateControlModeType

# H264RateControlModeType usage example

from mypy_boto3_mediaconvert.literals import H264RateControlModeType

def get_value() -> H264RateControlModeType:
    return "CBR"

# H264RateControlModeType definition

H264RateControlModeType = Literal[
    "CBR",
    "QVBR",
    "VBR",
]

H264RepeatPpsType

# H264RepeatPpsType usage example

from mypy_boto3_mediaconvert.literals import H264RepeatPpsType

def get_value() -> H264RepeatPpsType:
    return "DISABLED"

# H264RepeatPpsType definition

H264RepeatPpsType = Literal[
    "DISABLED",
    "ENABLED",
]

H264ScanTypeConversionModeType

# H264ScanTypeConversionModeType usage example

from mypy_boto3_mediaconvert.literals import H264ScanTypeConversionModeType

def get_value() -> H264ScanTypeConversionModeType:
    return "INTERLACED"

# H264ScanTypeConversionModeType definition

H264ScanTypeConversionModeType = Literal[
    "INTERLACED",
    "INTERLACED_OPTIMIZE",
]

H264SceneChangeDetectType

# H264SceneChangeDetectType usage example

from mypy_boto3_mediaconvert.literals import H264SceneChangeDetectType

def get_value() -> H264SceneChangeDetectType:
    return "DISABLED"

# H264SceneChangeDetectType definition

H264SceneChangeDetectType = Literal[
    "DISABLED",
    "ENABLED",
    "TRANSITION_DETECTION",
]

H264SlowPalType

# H264SlowPalType usage example

from mypy_boto3_mediaconvert.literals import H264SlowPalType

def get_value() -> H264SlowPalType:
    return "DISABLED"

# H264SlowPalType definition

H264SlowPalType = Literal[
    "DISABLED",
    "ENABLED",
]

H264SpatialAdaptiveQuantizationType

# H264SpatialAdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import H264SpatialAdaptiveQuantizationType

def get_value() -> H264SpatialAdaptiveQuantizationType:
    return "DISABLED"

# H264SpatialAdaptiveQuantizationType definition

H264SpatialAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

H264SyntaxType

# H264SyntaxType usage example

from mypy_boto3_mediaconvert.literals import H264SyntaxType

def get_value() -> H264SyntaxType:
    return "DEFAULT"

# H264SyntaxType definition

H264SyntaxType = Literal[
    "DEFAULT",
    "RP2027",
]

H264TelecineType

# H264TelecineType usage example

from mypy_boto3_mediaconvert.literals import H264TelecineType

def get_value() -> H264TelecineType:
    return "HARD"

# H264TelecineType definition

H264TelecineType = Literal[
    "HARD",
    "NONE",
    "SOFT",
]

H264TemporalAdaptiveQuantizationType

# H264TemporalAdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import H264TemporalAdaptiveQuantizationType

def get_value() -> H264TemporalAdaptiveQuantizationType:
    return "DISABLED"

# H264TemporalAdaptiveQuantizationType definition

H264TemporalAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

H264UnregisteredSeiTimecodeType

# H264UnregisteredSeiTimecodeType usage example

from mypy_boto3_mediaconvert.literals import H264UnregisteredSeiTimecodeType

def get_value() -> H264UnregisteredSeiTimecodeType:
    return "DISABLED"

# H264UnregisteredSeiTimecodeType definition

H264UnregisteredSeiTimecodeType = Literal[
    "DISABLED",
    "ENABLED",
]

H265AdaptiveQuantizationType

# H265AdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import H265AdaptiveQuantizationType

def get_value() -> H265AdaptiveQuantizationType:
    return "AUTO"

# H265AdaptiveQuantizationType definition

H265AdaptiveQuantizationType = Literal[
    "AUTO",
    "HIGH",
    "HIGHER",
    "LOW",
    "MAX",
    "MEDIUM",
    "OFF",
]

H265AlternateTransferFunctionSeiType

# H265AlternateTransferFunctionSeiType usage example

from mypy_boto3_mediaconvert.literals import H265AlternateTransferFunctionSeiType

def get_value() -> H265AlternateTransferFunctionSeiType:
    return "DISABLED"

# H265AlternateTransferFunctionSeiType definition

H265AlternateTransferFunctionSeiType = Literal[
    "DISABLED",
    "ENABLED",
]

H265CodecLevelType

# H265CodecLevelType usage example

from mypy_boto3_mediaconvert.literals import H265CodecLevelType

def get_value() -> H265CodecLevelType:
    return "AUTO"

# H265CodecLevelType definition

H265CodecLevelType = Literal[
    "AUTO",
    "LEVEL_1",
    "LEVEL_2",
    "LEVEL_2_1",
    "LEVEL_3",
    "LEVEL_3_1",
    "LEVEL_4",
    "LEVEL_4_1",
    "LEVEL_5",
    "LEVEL_5_1",
    "LEVEL_5_2",
    "LEVEL_6",
    "LEVEL_6_1",
    "LEVEL_6_2",
]

H265CodecProfileType

# H265CodecProfileType usage example

from mypy_boto3_mediaconvert.literals import H265CodecProfileType

def get_value() -> H265CodecProfileType:
    return "MAIN10_HIGH"

# H265CodecProfileType definition

H265CodecProfileType = Literal[
    "MAIN10_HIGH",
    "MAIN10_MAIN",
    "MAIN_422_10BIT_HIGH",
    "MAIN_422_10BIT_MAIN",
    "MAIN_422_8BIT_HIGH",
    "MAIN_422_8BIT_MAIN",
    "MAIN_HIGH",
    "MAIN_MAIN",
]

H265DynamicSubGopType

# H265DynamicSubGopType usage example

from mypy_boto3_mediaconvert.literals import H265DynamicSubGopType

def get_value() -> H265DynamicSubGopType:
    return "ADAPTIVE"

# H265DynamicSubGopType definition

H265DynamicSubGopType = Literal[
    "ADAPTIVE",
    "STATIC",
]

H265FlickerAdaptiveQuantizationType

# H265FlickerAdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import H265FlickerAdaptiveQuantizationType

def get_value() -> H265FlickerAdaptiveQuantizationType:
    return "DISABLED"

# H265FlickerAdaptiveQuantizationType definition

H265FlickerAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

H265FramerateControlType

# H265FramerateControlType usage example

from mypy_boto3_mediaconvert.literals import H265FramerateControlType

def get_value() -> H265FramerateControlType:
    return "INITIALIZE_FROM_SOURCE"

# H265FramerateControlType definition

H265FramerateControlType = Literal[
    "INITIALIZE_FROM_SOURCE",
    "SPECIFIED",
]

H265FramerateConversionAlgorithmType

# H265FramerateConversionAlgorithmType usage example

from mypy_boto3_mediaconvert.literals import H265FramerateConversionAlgorithmType

def get_value() -> H265FramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"

# H265FramerateConversionAlgorithmType definition

H265FramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "FRAMEFORMER",
    "INTERPOLATE",
]

H265GopBReferenceType

# H265GopBReferenceType usage example

from mypy_boto3_mediaconvert.literals import H265GopBReferenceType

def get_value() -> H265GopBReferenceType:
    return "DISABLED"

# H265GopBReferenceType definition

H265GopBReferenceType = Literal[
    "DISABLED",
    "ENABLED",
]

H265GopSizeUnitsType

# H265GopSizeUnitsType usage example

from mypy_boto3_mediaconvert.literals import H265GopSizeUnitsType

def get_value() -> H265GopSizeUnitsType:
    return "AUTO"

# H265GopSizeUnitsType definition

H265GopSizeUnitsType = Literal[
    "AUTO",
    "FRAMES",
    "SECONDS",
]

H265InterlaceModeType

# H265InterlaceModeType usage example

from mypy_boto3_mediaconvert.literals import H265InterlaceModeType

def get_value() -> H265InterlaceModeType:
    return "BOTTOM_FIELD"

# H265InterlaceModeType definition

H265InterlaceModeType = Literal[
    "BOTTOM_FIELD",
    "FOLLOW_BOTTOM_FIELD",
    "FOLLOW_TOP_FIELD",
    "PROGRESSIVE",
    "TOP_FIELD",
]

H265ParControlType

# H265ParControlType usage example

from mypy_boto3_mediaconvert.literals import H265ParControlType

def get_value() -> H265ParControlType:
    return "INITIALIZE_FROM_SOURCE"

# H265ParControlType definition

H265ParControlType = Literal[
    "INITIALIZE_FROM_SOURCE",
    "SPECIFIED",
]

H265QualityTuningLevelType

# H265QualityTuningLevelType usage example

from mypy_boto3_mediaconvert.literals import H265QualityTuningLevelType

def get_value() -> H265QualityTuningLevelType:
    return "MULTI_PASS_HQ"

# H265QualityTuningLevelType definition

H265QualityTuningLevelType = Literal[
    "MULTI_PASS_HQ",
    "SINGLE_PASS",
    "SINGLE_PASS_HQ",
]

H265RateControlModeType

# H265RateControlModeType usage example

from mypy_boto3_mediaconvert.literals import H265RateControlModeType

def get_value() -> H265RateControlModeType:
    return "CBR"

# H265RateControlModeType definition

H265RateControlModeType = Literal[
    "CBR",
    "QVBR",
    "VBR",
]

H265SampleAdaptiveOffsetFilterModeType

# H265SampleAdaptiveOffsetFilterModeType usage example

from mypy_boto3_mediaconvert.literals import H265SampleAdaptiveOffsetFilterModeType

def get_value() -> H265SampleAdaptiveOffsetFilterModeType:
    return "ADAPTIVE"

# H265SampleAdaptiveOffsetFilterModeType definition

H265SampleAdaptiveOffsetFilterModeType = Literal[
    "ADAPTIVE",
    "DEFAULT",
    "OFF",
]

H265ScanTypeConversionModeType

# H265ScanTypeConversionModeType usage example

from mypy_boto3_mediaconvert.literals import H265ScanTypeConversionModeType

def get_value() -> H265ScanTypeConversionModeType:
    return "INTERLACED"

# H265ScanTypeConversionModeType definition

H265ScanTypeConversionModeType = Literal[
    "INTERLACED",
    "INTERLACED_OPTIMIZE",
]

H265SceneChangeDetectType

# H265SceneChangeDetectType usage example

from mypy_boto3_mediaconvert.literals import H265SceneChangeDetectType

def get_value() -> H265SceneChangeDetectType:
    return "DISABLED"

# H265SceneChangeDetectType definition

H265SceneChangeDetectType = Literal[
    "DISABLED",
    "ENABLED",
    "TRANSITION_DETECTION",
]

H265SlowPalType

# H265SlowPalType usage example

from mypy_boto3_mediaconvert.literals import H265SlowPalType

def get_value() -> H265SlowPalType:
    return "DISABLED"

# H265SlowPalType definition

H265SlowPalType = Literal[
    "DISABLED",
    "ENABLED",
]

H265SpatialAdaptiveQuantizationType

# H265SpatialAdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import H265SpatialAdaptiveQuantizationType

def get_value() -> H265SpatialAdaptiveQuantizationType:
    return "DISABLED"

# H265SpatialAdaptiveQuantizationType definition

H265SpatialAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

H265TelecineType

# H265TelecineType usage example

from mypy_boto3_mediaconvert.literals import H265TelecineType

def get_value() -> H265TelecineType:
    return "HARD"

# H265TelecineType definition

H265TelecineType = Literal[
    "HARD",
    "NONE",
    "SOFT",
]

H265TemporalAdaptiveQuantizationType

# H265TemporalAdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import H265TemporalAdaptiveQuantizationType

def get_value() -> H265TemporalAdaptiveQuantizationType:
    return "DISABLED"

# H265TemporalAdaptiveQuantizationType definition

H265TemporalAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

H265TemporalIdsType

# H265TemporalIdsType usage example

from mypy_boto3_mediaconvert.literals import H265TemporalIdsType

def get_value() -> H265TemporalIdsType:
    return "DISABLED"

# H265TemporalIdsType definition

H265TemporalIdsType = Literal[
    "DISABLED",
    "ENABLED",
]

H265TilesType

# H265TilesType usage example

from mypy_boto3_mediaconvert.literals import H265TilesType

def get_value() -> H265TilesType:
    return "DISABLED"

# H265TilesType definition

H265TilesType = Literal[
    "DISABLED",
    "ENABLED",
]

H265UnregisteredSeiTimecodeType

# H265UnregisteredSeiTimecodeType usage example

from mypy_boto3_mediaconvert.literals import H265UnregisteredSeiTimecodeType

def get_value() -> H265UnregisteredSeiTimecodeType:
    return "DISABLED"

# H265UnregisteredSeiTimecodeType definition

H265UnregisteredSeiTimecodeType = Literal[
    "DISABLED",
    "ENABLED",
]

H265WriteMp4PackagingTypeType

# H265WriteMp4PackagingTypeType usage example

from mypy_boto3_mediaconvert.literals import H265WriteMp4PackagingTypeType

def get_value() -> H265WriteMp4PackagingTypeType:
    return "HEV1"

# H265WriteMp4PackagingTypeType definition

H265WriteMp4PackagingTypeType = Literal[
    "HEV1",
    "HVC1",
]

HDRToSDRToneMapperType

# HDRToSDRToneMapperType usage example

from mypy_boto3_mediaconvert.literals import HDRToSDRToneMapperType

def get_value() -> HDRToSDRToneMapperType:
    return "PRESERVE_DETAILS"

# HDRToSDRToneMapperType definition

HDRToSDRToneMapperType = Literal[
    "PRESERVE_DETAILS",
    "VIBRANT",
]

HlsAdMarkersType

# HlsAdMarkersType usage example

from mypy_boto3_mediaconvert.literals import HlsAdMarkersType

def get_value() -> HlsAdMarkersType:
    return "ELEMENTAL"

# HlsAdMarkersType definition

HlsAdMarkersType = Literal[
    "ELEMENTAL",
    "ELEMENTAL_SCTE35",
]

HlsAudioOnlyContainerType

# HlsAudioOnlyContainerType usage example

from mypy_boto3_mediaconvert.literals import HlsAudioOnlyContainerType

def get_value() -> HlsAudioOnlyContainerType:
    return "AUTOMATIC"

# HlsAudioOnlyContainerType definition

HlsAudioOnlyContainerType = Literal[
    "AUTOMATIC",
    "M2TS",
]

HlsAudioOnlyHeaderType

# HlsAudioOnlyHeaderType usage example

from mypy_boto3_mediaconvert.literals import HlsAudioOnlyHeaderType

def get_value() -> HlsAudioOnlyHeaderType:
    return "EXCLUDE"

# HlsAudioOnlyHeaderType definition

HlsAudioOnlyHeaderType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

HlsAudioTrackTypeType

# HlsAudioTrackTypeType usage example

from mypy_boto3_mediaconvert.literals import HlsAudioTrackTypeType

def get_value() -> HlsAudioTrackTypeType:
    return "ALTERNATE_AUDIO_AUTO_SELECT"

# HlsAudioTrackTypeType definition

HlsAudioTrackTypeType = Literal[
    "ALTERNATE_AUDIO_AUTO_SELECT",
    "ALTERNATE_AUDIO_AUTO_SELECT_DEFAULT",
    "ALTERNATE_AUDIO_NOT_AUTO_SELECT",
    "AUDIO_ONLY_VARIANT_STREAM",
]

HlsCaptionLanguageSettingType

# HlsCaptionLanguageSettingType usage example

from mypy_boto3_mediaconvert.literals import HlsCaptionLanguageSettingType

def get_value() -> HlsCaptionLanguageSettingType:
    return "INSERT"

# HlsCaptionLanguageSettingType definition

HlsCaptionLanguageSettingType = Literal[
    "INSERT",
    "NONE",
    "OMIT",
]

HlsCaptionSegmentLengthControlType

# HlsCaptionSegmentLengthControlType usage example

from mypy_boto3_mediaconvert.literals import HlsCaptionSegmentLengthControlType

def get_value() -> HlsCaptionSegmentLengthControlType:
    return "LARGE_SEGMENTS"

# HlsCaptionSegmentLengthControlType definition

HlsCaptionSegmentLengthControlType = Literal[
    "LARGE_SEGMENTS",
    "MATCH_VIDEO",
]

HlsClientCacheType

# HlsClientCacheType usage example

from mypy_boto3_mediaconvert.literals import HlsClientCacheType

def get_value() -> HlsClientCacheType:
    return "DISABLED"

# HlsClientCacheType definition

HlsClientCacheType = Literal[
    "DISABLED",
    "ENABLED",
]

HlsCodecSpecificationType

# HlsCodecSpecificationType usage example

from mypy_boto3_mediaconvert.literals import HlsCodecSpecificationType

def get_value() -> HlsCodecSpecificationType:
    return "RFC_4281"

# HlsCodecSpecificationType definition

HlsCodecSpecificationType = Literal[
    "RFC_4281",
    "RFC_6381",
]

HlsDescriptiveVideoServiceFlagType

# HlsDescriptiveVideoServiceFlagType usage example

from mypy_boto3_mediaconvert.literals import HlsDescriptiveVideoServiceFlagType

def get_value() -> HlsDescriptiveVideoServiceFlagType:
    return "DONT_FLAG"

# HlsDescriptiveVideoServiceFlagType definition

HlsDescriptiveVideoServiceFlagType = Literal[
    "DONT_FLAG",
    "FLAG",
]

HlsDirectoryStructureType

# HlsDirectoryStructureType usage example

from mypy_boto3_mediaconvert.literals import HlsDirectoryStructureType

def get_value() -> HlsDirectoryStructureType:
    return "SINGLE_DIRECTORY"

# HlsDirectoryStructureType definition

HlsDirectoryStructureType = Literal[
    "SINGLE_DIRECTORY",
    "SUBDIRECTORY_PER_STREAM",
]

HlsEncryptionTypeType

# HlsEncryptionTypeType usage example

from mypy_boto3_mediaconvert.literals import HlsEncryptionTypeType

def get_value() -> HlsEncryptionTypeType:
    return "AES128"

# HlsEncryptionTypeType definition

HlsEncryptionTypeType = Literal[
    "AES128",
    "SAMPLE_AES",
]

HlsIFrameOnlyManifestType

# HlsIFrameOnlyManifestType usage example

from mypy_boto3_mediaconvert.literals import HlsIFrameOnlyManifestType

def get_value() -> HlsIFrameOnlyManifestType:
    return "EXCLUDE"

# HlsIFrameOnlyManifestType definition

HlsIFrameOnlyManifestType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

HlsImageBasedTrickPlayType

# HlsImageBasedTrickPlayType usage example

from mypy_boto3_mediaconvert.literals import HlsImageBasedTrickPlayType

def get_value() -> HlsImageBasedTrickPlayType:
    return "ADVANCED"

# HlsImageBasedTrickPlayType definition

HlsImageBasedTrickPlayType = Literal[
    "ADVANCED",
    "NONE",
    "THUMBNAIL",
    "THUMBNAIL_AND_FULLFRAME",
]

HlsInitializationVectorInManifestType

# HlsInitializationVectorInManifestType usage example

from mypy_boto3_mediaconvert.literals import HlsInitializationVectorInManifestType

def get_value() -> HlsInitializationVectorInManifestType:
    return "EXCLUDE"

# HlsInitializationVectorInManifestType definition

HlsInitializationVectorInManifestType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

HlsIntervalCadenceType

# HlsIntervalCadenceType usage example

from mypy_boto3_mediaconvert.literals import HlsIntervalCadenceType

def get_value() -> HlsIntervalCadenceType:
    return "FOLLOW_CUSTOM"

# HlsIntervalCadenceType definition

HlsIntervalCadenceType = Literal[
    "FOLLOW_CUSTOM",
    "FOLLOW_IFRAME",
]

HlsKeyProviderTypeType

# HlsKeyProviderTypeType usage example

from mypy_boto3_mediaconvert.literals import HlsKeyProviderTypeType

def get_value() -> HlsKeyProviderTypeType:
    return "SPEKE"

# HlsKeyProviderTypeType definition

HlsKeyProviderTypeType = Literal[
    "SPEKE",
    "STATIC_KEY",
]

HlsManifestCompressionType

# HlsManifestCompressionType usage example

from mypy_boto3_mediaconvert.literals import HlsManifestCompressionType

def get_value() -> HlsManifestCompressionType:
    return "GZIP"

# HlsManifestCompressionType definition

HlsManifestCompressionType = Literal[
    "GZIP",
    "NONE",
]

HlsManifestDurationFormatType

# HlsManifestDurationFormatType usage example

from mypy_boto3_mediaconvert.literals import HlsManifestDurationFormatType

def get_value() -> HlsManifestDurationFormatType:
    return "FLOATING_POINT"

# HlsManifestDurationFormatType definition

HlsManifestDurationFormatType = Literal[
    "FLOATING_POINT",
    "INTEGER",
]

HlsOfflineEncryptedType

# HlsOfflineEncryptedType usage example

from mypy_boto3_mediaconvert.literals import HlsOfflineEncryptedType

def get_value() -> HlsOfflineEncryptedType:
    return "DISABLED"

# HlsOfflineEncryptedType definition

HlsOfflineEncryptedType = Literal[
    "DISABLED",
    "ENABLED",
]

HlsOutputSelectionType

# HlsOutputSelectionType usage example

from mypy_boto3_mediaconvert.literals import HlsOutputSelectionType

def get_value() -> HlsOutputSelectionType:
    return "MANIFESTS_AND_SEGMENTS"

# HlsOutputSelectionType definition

HlsOutputSelectionType = Literal[
    "MANIFESTS_AND_SEGMENTS",
    "SEGMENTS_ONLY",
]

HlsProgramDateTimeType

# HlsProgramDateTimeType usage example

from mypy_boto3_mediaconvert.literals import HlsProgramDateTimeType

def get_value() -> HlsProgramDateTimeType:
    return "EXCLUDE"

# HlsProgramDateTimeType definition

HlsProgramDateTimeType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

HlsSegmentControlType

# HlsSegmentControlType usage example

from mypy_boto3_mediaconvert.literals import HlsSegmentControlType

def get_value() -> HlsSegmentControlType:
    return "SEGMENTED_FILES"

# HlsSegmentControlType definition

HlsSegmentControlType = Literal[
    "SEGMENTED_FILES",
    "SINGLE_FILE",
]

HlsSegmentLengthControlType

# HlsSegmentLengthControlType usage example

from mypy_boto3_mediaconvert.literals import HlsSegmentLengthControlType

def get_value() -> HlsSegmentLengthControlType:
    return "EXACT"

# HlsSegmentLengthControlType definition

HlsSegmentLengthControlType = Literal[
    "EXACT",
    "GOP_MULTIPLE",
]

HlsStreamInfResolutionType

# HlsStreamInfResolutionType usage example

from mypy_boto3_mediaconvert.literals import HlsStreamInfResolutionType

def get_value() -> HlsStreamInfResolutionType:
    return "EXCLUDE"

# HlsStreamInfResolutionType definition

HlsStreamInfResolutionType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

HlsTargetDurationCompatibilityModeType

# HlsTargetDurationCompatibilityModeType usage example

from mypy_boto3_mediaconvert.literals import HlsTargetDurationCompatibilityModeType

def get_value() -> HlsTargetDurationCompatibilityModeType:
    return "LEGACY"

# HlsTargetDurationCompatibilityModeType definition

HlsTargetDurationCompatibilityModeType = Literal[
    "LEGACY",
    "SPEC_COMPLIANT",
]

HlsTimedMetadataId3FrameType

# HlsTimedMetadataId3FrameType usage example

from mypy_boto3_mediaconvert.literals import HlsTimedMetadataId3FrameType

def get_value() -> HlsTimedMetadataId3FrameType:
    return "NONE"

# HlsTimedMetadataId3FrameType definition

HlsTimedMetadataId3FrameType = Literal[
    "NONE",
    "PRIV",
    "TDRL",
]

ImscAccessibilitySubsType

# ImscAccessibilitySubsType usage example

from mypy_boto3_mediaconvert.literals import ImscAccessibilitySubsType

def get_value() -> ImscAccessibilitySubsType:
    return "DISABLED"

# ImscAccessibilitySubsType definition

ImscAccessibilitySubsType = Literal[
    "DISABLED",
    "ENABLED",
]

ImscStylePassthroughType

# ImscStylePassthroughType usage example

from mypy_boto3_mediaconvert.literals import ImscStylePassthroughType

def get_value() -> ImscStylePassthroughType:
    return "DISABLED"

# ImscStylePassthroughType definition

ImscStylePassthroughType = Literal[
    "DISABLED",
    "ENABLED",
]

InputDeblockFilterType

# InputDeblockFilterType usage example

from mypy_boto3_mediaconvert.literals import InputDeblockFilterType

def get_value() -> InputDeblockFilterType:
    return "DISABLED"

# InputDeblockFilterType definition

InputDeblockFilterType = Literal[
    "DISABLED",
    "ENABLED",
]

InputDenoiseFilterType

# InputDenoiseFilterType usage example

from mypy_boto3_mediaconvert.literals import InputDenoiseFilterType

def get_value() -> InputDenoiseFilterType:
    return "DISABLED"

# InputDenoiseFilterType definition

InputDenoiseFilterType = Literal[
    "DISABLED",
    "ENABLED",
]

InputFilterEnableType

# InputFilterEnableType usage example

from mypy_boto3_mediaconvert.literals import InputFilterEnableType

def get_value() -> InputFilterEnableType:
    return "AUTO"

# InputFilterEnableType definition

InputFilterEnableType = Literal[
    "AUTO",
    "DISABLE",
    "FORCE",
]

InputPolicyType

# InputPolicyType usage example

from mypy_boto3_mediaconvert.literals import InputPolicyType

def get_value() -> InputPolicyType:
    return "ALLOWED"

# InputPolicyType definition

InputPolicyType = Literal[
    "ALLOWED",
    "DISALLOWED",
]

InputPsiControlType

# InputPsiControlType usage example

from mypy_boto3_mediaconvert.literals import InputPsiControlType

def get_value() -> InputPsiControlType:
    return "IGNORE_PSI"

# InputPsiControlType definition

InputPsiControlType = Literal[
    "IGNORE_PSI",
    "USE_PSI",
]

InputRotateType

# InputRotateType usage example

from mypy_boto3_mediaconvert.literals import InputRotateType

def get_value() -> InputRotateType:
    return "AUTO"

# InputRotateType definition

InputRotateType = Literal[
    "AUTO",
    "DEGREE_0",
    "DEGREES_180",
    "DEGREES_270",
    "DEGREES_90",
]

InputSampleRangeType

# InputSampleRangeType usage example

from mypy_boto3_mediaconvert.literals import InputSampleRangeType

def get_value() -> InputSampleRangeType:
    return "FOLLOW"

# InputSampleRangeType definition

InputSampleRangeType = Literal[
    "FOLLOW",
    "FULL_RANGE",
    "LIMITED_RANGE",
]

InputScanTypeType

# InputScanTypeType usage example

from mypy_boto3_mediaconvert.literals import InputScanTypeType

def get_value() -> InputScanTypeType:
    return "AUTO"

# InputScanTypeType definition

InputScanTypeType = Literal[
    "AUTO",
    "PSF",
]

InputTimecodeSourceType

# InputTimecodeSourceType usage example

from mypy_boto3_mediaconvert.literals import InputTimecodeSourceType

def get_value() -> InputTimecodeSourceType:
    return "EMBEDDED"

# InputTimecodeSourceType definition

InputTimecodeSourceType = Literal[
    "EMBEDDED",
    "SPECIFIEDSTART",
    "ZEROBASED",
]

JobPhaseType

# JobPhaseType usage example

from mypy_boto3_mediaconvert.literals import JobPhaseType

def get_value() -> JobPhaseType:
    return "PROBING"

# JobPhaseType definition

JobPhaseType = Literal[
    "PROBING",
    "TRANSCODING",
    "UPLOADING",
]

JobStatusType

# JobStatusType usage example

from mypy_boto3_mediaconvert.literals import JobStatusType

def get_value() -> JobStatusType:
    return "CANCELED"

# JobStatusType definition

JobStatusType = Literal[
    "CANCELED",
    "COMPLETE",
    "ERROR",
    "PROGRESSING",
    "SUBMITTED",
]

JobTemplateListByType

# JobTemplateListByType usage example

from mypy_boto3_mediaconvert.literals import JobTemplateListByType

def get_value() -> JobTemplateListByType:
    return "CREATION_DATE"

# JobTemplateListByType definition

JobTemplateListByType = Literal[
    "CREATION_DATE",
    "NAME",
    "SYSTEM",
]

LanguageCodeType

# LanguageCodeType usage example

from mypy_boto3_mediaconvert.literals import LanguageCodeType

def get_value() -> LanguageCodeType:
    return "AAR"

# LanguageCodeType definition

LanguageCodeType = Literal[
    "AAR",
    "ABK",
    "AFR",
    "AKA",
    "AMH",
    "ARA",
    "ARG",
    "ASM",
    "AVA",
    "AVE",
    "AYM",
    "AZE",
    "BAK",
    "BAM",
    "BEL",
    "BEN",
    "BIH",
    "BIS",
    "BOD",
    "BOS",
    "BRE",
    "BUL",
    "CAT",
    "CES",
    "CHA",
    "CHE",
    "CHU",
    "CHV",
    "COR",
    "COS",
    "CRE",
    "CYM",
    "DAN",
    "DEU",
    "DIV",
    "DZO",
    "ELL",
    "ENG",
    "ENM",
    "EPO",
    "EST",
    "EUS",
    "EWE",
    "FAO",
    "FAS",
    "FIJ",
    "FIN",
    "FRA",
    "FRM",
    "FRY",
    "FUL",
    "GER",
    "GLA",
    "GLE",
    "GLG",
    "GLV",
    "GRN",
    "GUJ",
    "HAT",
    "HAU",
    "HEB",
    "HER",
    "HIN",
    "HMO",
    "HRV",
    "HUN",
    "HYE",
    "IBO",
    "IDO",
    "III",
    "IKU",
    "ILE",
    "INA",
    "IND",
    "IPK",
    "ISL",
    "ITA",
    "JAV",
    "JPN",
    "KAL",
    "KAN",
    "KAS",
    "KAT",
    "KAU",
    "KAZ",
    "KHM",
    "KIK",
    "KIN",
    "KIR",
    "KOM",
    "KON",
    "KOR",
    "KUA",
    "KUR",
    "LAO",
    "LAT",
    "LAV",
    "LIM",
    "LIN",
    "LIT",
    "LTZ",
    "LUB",
    "LUG",
    "MAH",
    "MAL",
    "MAR",
    "MKD",
    "MLG",
    "MLT",
    "MON",
    "MRI",
    "MSA",
    "MYA",
    "NAU",
    "NAV",
    "NBL",
    "NDE",
    "NDO",
    "NEP",
    "NLD",
    "NNO",
    "NOB",
    "NOR",
    "NYA",
    "OCI",
    "OJI",
    "ORI",
    "ORJ",
    "ORM",
    "OSS",
    "PAN",
    "PLI",
    "POL",
    "POR",
    "PUS",
    "QAA",
    "QPC",
    "QUE",
    "ROH",
    "RON",
    "RUN",
    "RUS",
    "SAG",
    "SAN",
    "SIN",
    "SLK",
    "SLV",
    "SME",
    "SMO",
    "SNA",
    "SND",
    "SOM",
    "SOT",
    "SPA",
    "SQI",
    "SRB",
    "SRD",
    "SRP",
    "SSW",
    "SUN",
    "SWA",
    "SWE",
    "TAH",
    "TAM",
    "TAT",
    "TEL",
    "TGK",
    "TGL",
    "THA",
    "TIR",
    "TNG",
    "TON",
    "TSN",
    "TSO",
    "TUK",
    "TUR",
    "TWI",
    "UIG",
    "UKR",
    "URD",
    "UZB",
    "VEN",
    "VIE",
    "VOL",
    "WLN",
    "WOL",
    "XHO",
    "YID",
    "YOR",
    "ZHA",
    "ZHO",
    "ZUL",
]

ListJobTemplatesPaginatorName

# ListJobTemplatesPaginatorName usage example

from mypy_boto3_mediaconvert.literals import ListJobTemplatesPaginatorName

def get_value() -> ListJobTemplatesPaginatorName:
    return "list_job_templates"

# ListJobTemplatesPaginatorName definition

ListJobTemplatesPaginatorName = Literal[
    "list_job_templates",
]

ListJobsPaginatorName

# ListJobsPaginatorName usage example

from mypy_boto3_mediaconvert.literals import ListJobsPaginatorName

def get_value() -> ListJobsPaginatorName:
    return "list_jobs"

# ListJobsPaginatorName definition

ListJobsPaginatorName = Literal[
    "list_jobs",
]

ListPresetsPaginatorName

# ListPresetsPaginatorName usage example

from mypy_boto3_mediaconvert.literals import ListPresetsPaginatorName

def get_value() -> ListPresetsPaginatorName:
    return "list_presets"

# ListPresetsPaginatorName definition

ListPresetsPaginatorName = Literal[
    "list_presets",
]

ListQueuesPaginatorName

# ListQueuesPaginatorName usage example

from mypy_boto3_mediaconvert.literals import ListQueuesPaginatorName

def get_value() -> ListQueuesPaginatorName:
    return "list_queues"

# ListQueuesPaginatorName definition

ListQueuesPaginatorName = Literal[
    "list_queues",
]

M2tsAudioBufferModelType

# M2tsAudioBufferModelType usage example

from mypy_boto3_mediaconvert.literals import M2tsAudioBufferModelType

def get_value() -> M2tsAudioBufferModelType:
    return "ATSC"

# M2tsAudioBufferModelType definition

M2tsAudioBufferModelType = Literal[
    "ATSC",
    "DVB",
]

M2tsAudioDurationType

# M2tsAudioDurationType usage example

from mypy_boto3_mediaconvert.literals import M2tsAudioDurationType

def get_value() -> M2tsAudioDurationType:
    return "DEFAULT_CODEC_DURATION"

# M2tsAudioDurationType definition

M2tsAudioDurationType = Literal[
    "DEFAULT_CODEC_DURATION",
    "MATCH_VIDEO_DURATION",
]

M2tsBufferModelType

# M2tsBufferModelType usage example

from mypy_boto3_mediaconvert.literals import M2tsBufferModelType

def get_value() -> M2tsBufferModelType:
    return "MULTIPLEX"

# M2tsBufferModelType definition

M2tsBufferModelType = Literal[
    "MULTIPLEX",
    "NONE",
]

M2tsDataPtsControlType

# M2tsDataPtsControlType usage example

from mypy_boto3_mediaconvert.literals import M2tsDataPtsControlType

def get_value() -> M2tsDataPtsControlType:
    return "ALIGN_TO_VIDEO"

# M2tsDataPtsControlType definition

M2tsDataPtsControlType = Literal[
    "ALIGN_TO_VIDEO",
    "AUTO",
]

M2tsEbpAudioIntervalType

# M2tsEbpAudioIntervalType usage example

from mypy_boto3_mediaconvert.literals import M2tsEbpAudioIntervalType

def get_value() -> M2tsEbpAudioIntervalType:
    return "VIDEO_AND_FIXED_INTERVALS"

# M2tsEbpAudioIntervalType definition

M2tsEbpAudioIntervalType = Literal[
    "VIDEO_AND_FIXED_INTERVALS",
    "VIDEO_INTERVAL",
]

M2tsEbpPlacementType

# M2tsEbpPlacementType usage example

from mypy_boto3_mediaconvert.literals import M2tsEbpPlacementType

def get_value() -> M2tsEbpPlacementType:
    return "VIDEO_AND_AUDIO_PIDS"

# M2tsEbpPlacementType definition

M2tsEbpPlacementType = Literal[
    "VIDEO_AND_AUDIO_PIDS",
    "VIDEO_PID",
]

M2tsEsRateInPesType

# M2tsEsRateInPesType usage example

from mypy_boto3_mediaconvert.literals import M2tsEsRateInPesType

def get_value() -> M2tsEsRateInPesType:
    return "EXCLUDE"

# M2tsEsRateInPesType definition

M2tsEsRateInPesType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

M2tsForceTsVideoEbpOrderType

# M2tsForceTsVideoEbpOrderType usage example

from mypy_boto3_mediaconvert.literals import M2tsForceTsVideoEbpOrderType

def get_value() -> M2tsForceTsVideoEbpOrderType:
    return "DEFAULT"

# M2tsForceTsVideoEbpOrderType definition

M2tsForceTsVideoEbpOrderType = Literal[
    "DEFAULT",
    "FORCE",
]

M2tsKlvMetadataType

# M2tsKlvMetadataType usage example

from mypy_boto3_mediaconvert.literals import M2tsKlvMetadataType

def get_value() -> M2tsKlvMetadataType:
    return "NONE"

# M2tsKlvMetadataType definition

M2tsKlvMetadataType = Literal[
    "NONE",
    "PASSTHROUGH",
]

M2tsNielsenId3Type

# M2tsNielsenId3Type usage example

from mypy_boto3_mediaconvert.literals import M2tsNielsenId3Type

def get_value() -> M2tsNielsenId3Type:
    return "INSERT"

# M2tsNielsenId3Type definition

M2tsNielsenId3Type = Literal[
    "INSERT",
    "NONE",
]

M2tsPcrControlType

# M2tsPcrControlType usage example

from mypy_boto3_mediaconvert.literals import M2tsPcrControlType

def get_value() -> M2tsPcrControlType:
    return "CONFIGURED_PCR_PERIOD"

# M2tsPcrControlType definition

M2tsPcrControlType = Literal[
    "CONFIGURED_PCR_PERIOD",
    "PCR_EVERY_PES_PACKET",
]

M2tsRateModeType

# M2tsRateModeType usage example

from mypy_boto3_mediaconvert.literals import M2tsRateModeType

def get_value() -> M2tsRateModeType:
    return "CBR"

# M2tsRateModeType definition

M2tsRateModeType = Literal[
    "CBR",
    "VBR",
]

M2tsScte35SourceType

# M2tsScte35SourceType usage example

from mypy_boto3_mediaconvert.literals import M2tsScte35SourceType

def get_value() -> M2tsScte35SourceType:
    return "NONE"

# M2tsScte35SourceType definition

M2tsScte35SourceType = Literal[
    "NONE",
    "PASSTHROUGH",
]

M2tsSegmentationMarkersType

# M2tsSegmentationMarkersType usage example

from mypy_boto3_mediaconvert.literals import M2tsSegmentationMarkersType

def get_value() -> M2tsSegmentationMarkersType:
    return "EBP"

# M2tsSegmentationMarkersType definition

M2tsSegmentationMarkersType = Literal[
    "EBP",
    "EBP_LEGACY",
    "NONE",
    "PSI_SEGSTART",
    "RAI_ADAPT",
    "RAI_SEGSTART",
]

M2tsSegmentationStyleType

# M2tsSegmentationStyleType usage example

from mypy_boto3_mediaconvert.literals import M2tsSegmentationStyleType

def get_value() -> M2tsSegmentationStyleType:
    return "MAINTAIN_CADENCE"

# M2tsSegmentationStyleType definition

M2tsSegmentationStyleType = Literal[
    "MAINTAIN_CADENCE",
    "RESET_CADENCE",
]

M3u8AudioDurationType

# M3u8AudioDurationType usage example

from mypy_boto3_mediaconvert.literals import M3u8AudioDurationType

def get_value() -> M3u8AudioDurationType:
    return "DEFAULT_CODEC_DURATION"

# M3u8AudioDurationType definition

M3u8AudioDurationType = Literal[
    "DEFAULT_CODEC_DURATION",
    "MATCH_VIDEO_DURATION",
]

M3u8DataPtsControlType

# M3u8DataPtsControlType usage example

from mypy_boto3_mediaconvert.literals import M3u8DataPtsControlType

def get_value() -> M3u8DataPtsControlType:
    return "ALIGN_TO_VIDEO"

# M3u8DataPtsControlType definition

M3u8DataPtsControlType = Literal[
    "ALIGN_TO_VIDEO",
    "AUTO",
]

M3u8NielsenId3Type

# M3u8NielsenId3Type usage example

from mypy_boto3_mediaconvert.literals import M3u8NielsenId3Type

def get_value() -> M3u8NielsenId3Type:
    return "INSERT"

# M3u8NielsenId3Type definition

M3u8NielsenId3Type = Literal[
    "INSERT",
    "NONE",
]

M3u8PcrControlType

# M3u8PcrControlType usage example

from mypy_boto3_mediaconvert.literals import M3u8PcrControlType

def get_value() -> M3u8PcrControlType:
    return "CONFIGURED_PCR_PERIOD"

# M3u8PcrControlType definition

M3u8PcrControlType = Literal[
    "CONFIGURED_PCR_PERIOD",
    "PCR_EVERY_PES_PACKET",
]

M3u8Scte35SourceType

# M3u8Scte35SourceType usage example

from mypy_boto3_mediaconvert.literals import M3u8Scte35SourceType

def get_value() -> M3u8Scte35SourceType:
    return "NONE"

# M3u8Scte35SourceType definition

M3u8Scte35SourceType = Literal[
    "NONE",
    "PASSTHROUGH",
]

MotionImageInsertionModeType

# MotionImageInsertionModeType usage example

from mypy_boto3_mediaconvert.literals import MotionImageInsertionModeType

def get_value() -> MotionImageInsertionModeType:
    return "MOV"

# MotionImageInsertionModeType definition

MotionImageInsertionModeType = Literal[
    "MOV",
    "PNG",
]

MotionImagePlaybackType

# MotionImagePlaybackType usage example

from mypy_boto3_mediaconvert.literals import MotionImagePlaybackType

def get_value() -> MotionImagePlaybackType:
    return "ONCE"

# MotionImagePlaybackType definition

MotionImagePlaybackType = Literal[
    "ONCE",
    "REPEAT",
]

MovClapAtomType

# MovClapAtomType usage example

from mypy_boto3_mediaconvert.literals import MovClapAtomType

def get_value() -> MovClapAtomType:
    return "EXCLUDE"

# MovClapAtomType definition

MovClapAtomType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

MovCslgAtomType

# MovCslgAtomType usage example

from mypy_boto3_mediaconvert.literals import MovCslgAtomType

def get_value() -> MovCslgAtomType:
    return "EXCLUDE"

# MovCslgAtomType definition

MovCslgAtomType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

MovMpeg2FourCCControlType

# MovMpeg2FourCCControlType usage example

from mypy_boto3_mediaconvert.literals import MovMpeg2FourCCControlType

def get_value() -> MovMpeg2FourCCControlType:
    return "MPEG"

# MovMpeg2FourCCControlType definition

MovMpeg2FourCCControlType = Literal[
    "MPEG",
    "XDCAM",
]

MovPaddingControlType

# MovPaddingControlType usage example

from mypy_boto3_mediaconvert.literals import MovPaddingControlType

def get_value() -> MovPaddingControlType:
    return "NONE"

# MovPaddingControlType definition

MovPaddingControlType = Literal[
    "NONE",
    "OMNEON",
]

MovReferenceType

# MovReferenceType usage example

from mypy_boto3_mediaconvert.literals import MovReferenceType

def get_value() -> MovReferenceType:
    return "EXTERNAL"

# MovReferenceType definition

MovReferenceType = Literal[
    "EXTERNAL",
    "SELF_CONTAINED",
]

Mp3RateControlModeType

# Mp3RateControlModeType usage example

from mypy_boto3_mediaconvert.literals import Mp3RateControlModeType

def get_value() -> Mp3RateControlModeType:
    return "CBR"

# Mp3RateControlModeType definition

Mp3RateControlModeType = Literal[
    "CBR",
    "VBR",
]

Mp4CslgAtomType

# Mp4CslgAtomType usage example

from mypy_boto3_mediaconvert.literals import Mp4CslgAtomType

def get_value() -> Mp4CslgAtomType:
    return "EXCLUDE"

# Mp4CslgAtomType definition

Mp4CslgAtomType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

Mp4FreeSpaceBoxType

# Mp4FreeSpaceBoxType usage example

from mypy_boto3_mediaconvert.literals import Mp4FreeSpaceBoxType

def get_value() -> Mp4FreeSpaceBoxType:
    return "EXCLUDE"

# Mp4FreeSpaceBoxType definition

Mp4FreeSpaceBoxType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

Mp4MoovPlacementType

# Mp4MoovPlacementType usage example

from mypy_boto3_mediaconvert.literals import Mp4MoovPlacementType

def get_value() -> Mp4MoovPlacementType:
    return "NORMAL"

# Mp4MoovPlacementType definition

Mp4MoovPlacementType = Literal[
    "NORMAL",
    "PROGRESSIVE_DOWNLOAD",
]

MpdAccessibilityCaptionHintsType

# MpdAccessibilityCaptionHintsType usage example

from mypy_boto3_mediaconvert.literals import MpdAccessibilityCaptionHintsType

def get_value() -> MpdAccessibilityCaptionHintsType:
    return "EXCLUDE"

# MpdAccessibilityCaptionHintsType definition

MpdAccessibilityCaptionHintsType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

MpdAudioDurationType

# MpdAudioDurationType usage example

from mypy_boto3_mediaconvert.literals import MpdAudioDurationType

def get_value() -> MpdAudioDurationType:
    return "DEFAULT_CODEC_DURATION"

# MpdAudioDurationType definition

MpdAudioDurationType = Literal[
    "DEFAULT_CODEC_DURATION",
    "MATCH_VIDEO_DURATION",
]

MpdCaptionContainerTypeType

# MpdCaptionContainerTypeType usage example

from mypy_boto3_mediaconvert.literals import MpdCaptionContainerTypeType

def get_value() -> MpdCaptionContainerTypeType:
    return "FRAGMENTED_MP4"

# MpdCaptionContainerTypeType definition

MpdCaptionContainerTypeType = Literal[
    "FRAGMENTED_MP4",
    "RAW",
]

MpdKlvMetadataType

# MpdKlvMetadataType usage example

from mypy_boto3_mediaconvert.literals import MpdKlvMetadataType

def get_value() -> MpdKlvMetadataType:
    return "NONE"

# MpdKlvMetadataType definition

MpdKlvMetadataType = Literal[
    "NONE",
    "PASSTHROUGH",
]

MpdManifestMetadataSignalingType

# MpdManifestMetadataSignalingType usage example

from mypy_boto3_mediaconvert.literals import MpdManifestMetadataSignalingType

def get_value() -> MpdManifestMetadataSignalingType:
    return "DISABLED"

# MpdManifestMetadataSignalingType definition

MpdManifestMetadataSignalingType = Literal[
    "DISABLED",
    "ENABLED",
]

MpdScte35EsamType

# MpdScte35EsamType usage example

from mypy_boto3_mediaconvert.literals import MpdScte35EsamType

def get_value() -> MpdScte35EsamType:
    return "INSERT"

# MpdScte35EsamType definition

MpdScte35EsamType = Literal[
    "INSERT",
    "NONE",
]

MpdScte35SourceType

# MpdScte35SourceType usage example

from mypy_boto3_mediaconvert.literals import MpdScte35SourceType

def get_value() -> MpdScte35SourceType:
    return "NONE"

# MpdScte35SourceType definition

MpdScte35SourceType = Literal[
    "NONE",
    "PASSTHROUGH",
]

MpdTimedMetadataBoxVersionType

# MpdTimedMetadataBoxVersionType usage example

from mypy_boto3_mediaconvert.literals import MpdTimedMetadataBoxVersionType

def get_value() -> MpdTimedMetadataBoxVersionType:
    return "VERSION_0"

# MpdTimedMetadataBoxVersionType definition

MpdTimedMetadataBoxVersionType = Literal[
    "VERSION_0",
    "VERSION_1",
]

MpdTimedMetadataType

# MpdTimedMetadataType usage example

from mypy_boto3_mediaconvert.literals import MpdTimedMetadataType

def get_value() -> MpdTimedMetadataType:
    return "NONE"

# MpdTimedMetadataType definition

MpdTimedMetadataType = Literal[
    "NONE",
    "PASSTHROUGH",
]

Mpeg2AdaptiveQuantizationType

# Mpeg2AdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2AdaptiveQuantizationType

def get_value() -> Mpeg2AdaptiveQuantizationType:
    return "HIGH"

# Mpeg2AdaptiveQuantizationType definition

Mpeg2AdaptiveQuantizationType = Literal[
    "HIGH",
    "LOW",
    "MEDIUM",
    "OFF",
]

Mpeg2CodecLevelType

# Mpeg2CodecLevelType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2CodecLevelType

def get_value() -> Mpeg2CodecLevelType:
    return "AUTO"

# Mpeg2CodecLevelType definition

Mpeg2CodecLevelType = Literal[
    "AUTO",
    "HIGH",
    "HIGH1440",
    "LOW",
    "MAIN",
]

Mpeg2CodecProfileType

# Mpeg2CodecProfileType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2CodecProfileType

def get_value() -> Mpeg2CodecProfileType:
    return "MAIN"

# Mpeg2CodecProfileType definition

Mpeg2CodecProfileType = Literal[
    "MAIN",
    "PROFILE_422",
]

Mpeg2DynamicSubGopType

# Mpeg2DynamicSubGopType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2DynamicSubGopType

def get_value() -> Mpeg2DynamicSubGopType:
    return "ADAPTIVE"

# Mpeg2DynamicSubGopType definition

Mpeg2DynamicSubGopType = Literal[
    "ADAPTIVE",
    "STATIC",
]

Mpeg2FramerateControlType

# Mpeg2FramerateControlType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2FramerateControlType

def get_value() -> Mpeg2FramerateControlType:
    return "INITIALIZE_FROM_SOURCE"

# Mpeg2FramerateControlType definition

Mpeg2FramerateControlType = Literal[
    "INITIALIZE_FROM_SOURCE",
    "SPECIFIED",
]

Mpeg2FramerateConversionAlgorithmType

# Mpeg2FramerateConversionAlgorithmType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2FramerateConversionAlgorithmType

def get_value() -> Mpeg2FramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"

# Mpeg2FramerateConversionAlgorithmType definition

Mpeg2FramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "FRAMEFORMER",
    "INTERPOLATE",
]

Mpeg2GopSizeUnitsType

# Mpeg2GopSizeUnitsType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2GopSizeUnitsType

def get_value() -> Mpeg2GopSizeUnitsType:
    return "FRAMES"

# Mpeg2GopSizeUnitsType definition

Mpeg2GopSizeUnitsType = Literal[
    "FRAMES",
    "SECONDS",
]

Mpeg2InterlaceModeType

# Mpeg2InterlaceModeType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2InterlaceModeType

def get_value() -> Mpeg2InterlaceModeType:
    return "BOTTOM_FIELD"

# Mpeg2InterlaceModeType definition

Mpeg2InterlaceModeType = Literal[
    "BOTTOM_FIELD",
    "FOLLOW_BOTTOM_FIELD",
    "FOLLOW_TOP_FIELD",
    "PROGRESSIVE",
    "TOP_FIELD",
]

Mpeg2IntraDcPrecisionType

# Mpeg2IntraDcPrecisionType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2IntraDcPrecisionType

def get_value() -> Mpeg2IntraDcPrecisionType:
    return "AUTO"

# Mpeg2IntraDcPrecisionType definition

Mpeg2IntraDcPrecisionType = Literal[
    "AUTO",
    "INTRA_DC_PRECISION_10",
    "INTRA_DC_PRECISION_11",
    "INTRA_DC_PRECISION_8",
    "INTRA_DC_PRECISION_9",
]

Mpeg2ParControlType

# Mpeg2ParControlType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2ParControlType

def get_value() -> Mpeg2ParControlType:
    return "INITIALIZE_FROM_SOURCE"

# Mpeg2ParControlType definition

Mpeg2ParControlType = Literal[
    "INITIALIZE_FROM_SOURCE",
    "SPECIFIED",
]

Mpeg2QualityTuningLevelType

# Mpeg2QualityTuningLevelType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2QualityTuningLevelType

def get_value() -> Mpeg2QualityTuningLevelType:
    return "MULTI_PASS"

# Mpeg2QualityTuningLevelType definition

Mpeg2QualityTuningLevelType = Literal[
    "MULTI_PASS",
    "SINGLE_PASS",
]

Mpeg2RateControlModeType

# Mpeg2RateControlModeType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2RateControlModeType

def get_value() -> Mpeg2RateControlModeType:
    return "CBR"

# Mpeg2RateControlModeType definition

Mpeg2RateControlModeType = Literal[
    "CBR",
    "VBR",
]

Mpeg2ScanTypeConversionModeType

# Mpeg2ScanTypeConversionModeType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2ScanTypeConversionModeType

def get_value() -> Mpeg2ScanTypeConversionModeType:
    return "INTERLACED"

# Mpeg2ScanTypeConversionModeType definition

Mpeg2ScanTypeConversionModeType = Literal[
    "INTERLACED",
    "INTERLACED_OPTIMIZE",
]

Mpeg2SceneChangeDetectType

# Mpeg2SceneChangeDetectType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2SceneChangeDetectType

def get_value() -> Mpeg2SceneChangeDetectType:
    return "DISABLED"

# Mpeg2SceneChangeDetectType definition

Mpeg2SceneChangeDetectType = Literal[
    "DISABLED",
    "ENABLED",
]

Mpeg2SlowPalType

# Mpeg2SlowPalType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2SlowPalType

def get_value() -> Mpeg2SlowPalType:
    return "DISABLED"

# Mpeg2SlowPalType definition

Mpeg2SlowPalType = Literal[
    "DISABLED",
    "ENABLED",
]

Mpeg2SpatialAdaptiveQuantizationType

# Mpeg2SpatialAdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2SpatialAdaptiveQuantizationType

def get_value() -> Mpeg2SpatialAdaptiveQuantizationType:
    return "DISABLED"

# Mpeg2SpatialAdaptiveQuantizationType definition

Mpeg2SpatialAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

Mpeg2SyntaxType

# Mpeg2SyntaxType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2SyntaxType

def get_value() -> Mpeg2SyntaxType:
    return "DEFAULT"

# Mpeg2SyntaxType definition

Mpeg2SyntaxType = Literal[
    "D_10",
    "DEFAULT",
]

Mpeg2TelecineType

# Mpeg2TelecineType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2TelecineType

def get_value() -> Mpeg2TelecineType:
    return "HARD"

# Mpeg2TelecineType definition

Mpeg2TelecineType = Literal[
    "HARD",
    "NONE",
    "SOFT",
]

Mpeg2TemporalAdaptiveQuantizationType

# Mpeg2TemporalAdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import Mpeg2TemporalAdaptiveQuantizationType

def get_value() -> Mpeg2TemporalAdaptiveQuantizationType:
    return "DISABLED"

# Mpeg2TemporalAdaptiveQuantizationType definition

Mpeg2TemporalAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

MsSmoothAudioDeduplicationType

# MsSmoothAudioDeduplicationType usage example

from mypy_boto3_mediaconvert.literals import MsSmoothAudioDeduplicationType

def get_value() -> MsSmoothAudioDeduplicationType:
    return "COMBINE_DUPLICATE_STREAMS"

# MsSmoothAudioDeduplicationType definition

MsSmoothAudioDeduplicationType = Literal[
    "COMBINE_DUPLICATE_STREAMS",
    "NONE",
]

MsSmoothFragmentLengthControlType

# MsSmoothFragmentLengthControlType usage example

from mypy_boto3_mediaconvert.literals import MsSmoothFragmentLengthControlType

def get_value() -> MsSmoothFragmentLengthControlType:
    return "EXACT"

# MsSmoothFragmentLengthControlType definition

MsSmoothFragmentLengthControlType = Literal[
    "EXACT",
    "GOP_MULTIPLE",
]

MsSmoothManifestEncodingType

# MsSmoothManifestEncodingType usage example

from mypy_boto3_mediaconvert.literals import MsSmoothManifestEncodingType

def get_value() -> MsSmoothManifestEncodingType:
    return "UTF16"

# MsSmoothManifestEncodingType definition

MsSmoothManifestEncodingType = Literal[
    "UTF16",
    "UTF8",
]

MxfAfdSignalingType

# MxfAfdSignalingType usage example

from mypy_boto3_mediaconvert.literals import MxfAfdSignalingType

def get_value() -> MxfAfdSignalingType:
    return "COPY_FROM_VIDEO"

# MxfAfdSignalingType definition

MxfAfdSignalingType = Literal[
    "COPY_FROM_VIDEO",
    "NO_COPY",
]

MxfProfileType

# MxfProfileType usage example

from mypy_boto3_mediaconvert.literals import MxfProfileType

def get_value() -> MxfProfileType:
    return "D_10"

# MxfProfileType definition

MxfProfileType = Literal[
    "D_10",
    "OP1A",
    "XAVC",
    "XDCAM",
    "XDCAM_RDD9",
]

MxfXavcDurationModeType

# MxfXavcDurationModeType usage example

from mypy_boto3_mediaconvert.literals import MxfXavcDurationModeType

def get_value() -> MxfXavcDurationModeType:
    return "ALLOW_ANY_DURATION"

# MxfXavcDurationModeType definition

MxfXavcDurationModeType = Literal[
    "ALLOW_ANY_DURATION",
    "DROP_FRAMES_FOR_COMPLIANCE",
]

NielsenActiveWatermarkProcessTypeType

# NielsenActiveWatermarkProcessTypeType usage example

from mypy_boto3_mediaconvert.literals import NielsenActiveWatermarkProcessTypeType

def get_value() -> NielsenActiveWatermarkProcessTypeType:
    return "CBET"

# NielsenActiveWatermarkProcessTypeType definition

NielsenActiveWatermarkProcessTypeType = Literal[
    "CBET",
    "NAES2_AND_NW",
    "NAES2_AND_NW_AND_CBET",
]

NielsenSourceWatermarkStatusTypeType

# NielsenSourceWatermarkStatusTypeType usage example

from mypy_boto3_mediaconvert.literals import NielsenSourceWatermarkStatusTypeType

def get_value() -> NielsenSourceWatermarkStatusTypeType:
    return "CLEAN"

# NielsenSourceWatermarkStatusTypeType definition

NielsenSourceWatermarkStatusTypeType = Literal[
    "CLEAN",
    "WATERMARKED",
]

NielsenUniqueTicPerAudioTrackTypeType

# NielsenUniqueTicPerAudioTrackTypeType usage example

from mypy_boto3_mediaconvert.literals import NielsenUniqueTicPerAudioTrackTypeType

def get_value() -> NielsenUniqueTicPerAudioTrackTypeType:
    return "RESERVE_UNIQUE_TICS_PER_TRACK"

# NielsenUniqueTicPerAudioTrackTypeType definition

NielsenUniqueTicPerAudioTrackTypeType = Literal[
    "RESERVE_UNIQUE_TICS_PER_TRACK",
    "SAME_TICS_PER_TRACK",
]

NoiseFilterPostTemporalSharpeningStrengthType

# NoiseFilterPostTemporalSharpeningStrengthType usage example

from mypy_boto3_mediaconvert.literals import NoiseFilterPostTemporalSharpeningStrengthType

def get_value() -> NoiseFilterPostTemporalSharpeningStrengthType:
    return "HIGH"

# NoiseFilterPostTemporalSharpeningStrengthType definition

NoiseFilterPostTemporalSharpeningStrengthType = Literal[
    "HIGH",
    "LOW",
    "MEDIUM",
]

NoiseFilterPostTemporalSharpeningType

# NoiseFilterPostTemporalSharpeningType usage example

from mypy_boto3_mediaconvert.literals import NoiseFilterPostTemporalSharpeningType

def get_value() -> NoiseFilterPostTemporalSharpeningType:
    return "AUTO"

# NoiseFilterPostTemporalSharpeningType definition

NoiseFilterPostTemporalSharpeningType = Literal[
    "AUTO",
    "DISABLED",
    "ENABLED",
]

NoiseReducerFilterType

# NoiseReducerFilterType usage example

from mypy_boto3_mediaconvert.literals import NoiseReducerFilterType

def get_value() -> NoiseReducerFilterType:
    return "BILATERAL"

# NoiseReducerFilterType definition

NoiseReducerFilterType = Literal[
    "BILATERAL",
    "CONSERVE",
    "GAUSSIAN",
    "LANCZOS",
    "MEAN",
    "SHARPEN",
    "SPATIAL",
    "TEMPORAL",
]

OrderType

# OrderType usage example

from mypy_boto3_mediaconvert.literals import OrderType

def get_value() -> OrderType:
    return "ASCENDING"

# OrderType definition

OrderType = Literal[
    "ASCENDING",
    "DESCENDING",
]

OutputGroupTypeType

# OutputGroupTypeType usage example

from mypy_boto3_mediaconvert.literals import OutputGroupTypeType

def get_value() -> OutputGroupTypeType:
    return "CMAF_GROUP_SETTINGS"

# OutputGroupTypeType definition

OutputGroupTypeType = Literal[
    "CMAF_GROUP_SETTINGS",
    "DASH_ISO_GROUP_SETTINGS",
    "FILE_GROUP_SETTINGS",
    "HLS_GROUP_SETTINGS",
    "MS_SMOOTH_GROUP_SETTINGS",
]

OutputSdtType

# OutputSdtType usage example

from mypy_boto3_mediaconvert.literals import OutputSdtType

def get_value() -> OutputSdtType:
    return "SDT_FOLLOW"

# OutputSdtType definition

OutputSdtType = Literal[
    "SDT_FOLLOW",
    "SDT_FOLLOW_IF_PRESENT",
    "SDT_MANUAL",
    "SDT_NONE",
]

PadVideoType

# PadVideoType usage example

from mypy_boto3_mediaconvert.literals import PadVideoType

def get_value() -> PadVideoType:
    return "BLACK"

# PadVideoType definition

PadVideoType = Literal[
    "BLACK",
    "DISABLED",
]

PresetListByType

# PresetListByType usage example

from mypy_boto3_mediaconvert.literals import PresetListByType

def get_value() -> PresetListByType:
    return "CREATION_DATE"

# PresetListByType definition

PresetListByType = Literal[
    "CREATION_DATE",
    "NAME",
    "SYSTEM",
]

PricingPlanType

# PricingPlanType usage example

from mypy_boto3_mediaconvert.literals import PricingPlanType

def get_value() -> PricingPlanType:
    return "ON_DEMAND"

# PricingPlanType definition

PricingPlanType = Literal[
    "ON_DEMAND",
    "RESERVED",
]

ProresChromaSamplingType

# ProresChromaSamplingType usage example

from mypy_boto3_mediaconvert.literals import ProresChromaSampli