Skip to content

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",
    "HI",
    "L",
    "LC",
    "LFE",
    "LFE2",
    "LS",
    "LSD",
    "LT",
    "LW",
    "M",
    "NAR",
    "R",
    "RC",
    "RS",
    "RSD",
    "RSL",
    "RSR",
    "RT",
    "RW",
    "TBC",
    "TBL",
    "TBR",
    "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",
    "FLAC",
    "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",
    "FORCE",
    "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",
]

Av1FilmGrainSynthesisType#

# Av1FilmGrainSynthesisType usage example

from mypy_boto3_mediaconvert.literals import Av1FilmGrainSynthesisType

def get_value() -> Av1FilmGrainSynthesisType:
    return "DISABLED"
# Av1FilmGrainSynthesisType definition

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

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",
]

CaptionSourceByteRateLimitType#

# CaptionSourceByteRateLimitType usage example

from mypy_boto3_mediaconvert.literals import CaptionSourceByteRateLimitType

def get_value() -> CaptionSourceByteRateLimitType:
    return "DISABLED"
# CaptionSourceByteRateLimitType definition

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

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",
    "AUDIO_ONLY_VARIANT_STREAM",
]

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",
    "OGG",
    "RAW",
    "WEBM",
    "Y4M",
]

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",
]

H264EndOfStreamMarkersType#

# H264EndOfStreamMarkersType usage example

from mypy_boto3_mediaconvert.literals import H264EndOfStreamMarkersType

def get_value() -> H264EndOfStreamMarkersType:
    return "INCLUDE"
# H264EndOfStreamMarkersType definition

H264EndOfStreamMarkersType = Literal[
    "INCLUDE",
    "SUPPRESS",
]

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",
]

H264SaliencyAwareEncodingType#

# H264SaliencyAwareEncodingType usage example

from mypy_boto3_mediaconvert.literals import H264SaliencyAwareEncodingType

def get_value() -> H264SaliencyAwareEncodingType:
    return "DISABLED"
# H264SaliencyAwareEncodingType definition

H264SaliencyAwareEncodingType = Literal[
    "DISABLED",
    "PREFERRED",
]

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",
]

H265EndOfStreamMarkersType#

# H265EndOfStreamMarkersType usage example

from mypy_boto3_mediaconvert.literals import H265EndOfStreamMarkersType

def get_value() -> H265EndOfStreamMarkersType:
    return "INCLUDE"
# H265EndOfStreamMarkersType definition

H265EndOfStreamMarkersType = Literal[
    "INCLUDE",
    "SUPPRESS",
]

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",
]

HlsProgressiveWriteHlsManifestType#

# HlsProgressiveWriteHlsManifestType usage example

from mypy_boto3_mediaconvert.literals import HlsProgressiveWriteHlsManifestType

def get_value() -> HlsProgressiveWriteHlsManifestType:
    return "DISABLED"
# HlsProgressiveWriteHlsManifestType definition

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

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",
]

ListVersionsPaginatorName#

# ListVersionsPaginatorName usage example

from mypy_boto3_mediaconvert.literals import ListVersionsPaginatorName

def get_value() -> ListVersionsPaginatorName:
    return "list_versions"
# ListVersionsPaginatorName definition

ListVersionsPaginatorName = Literal[
    "list_versions",
]

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",
]

M2tsPreventBufferUnderflowType#

# M2tsPreventBufferUnderflowType usage example

from mypy_boto3_mediaconvert.literals import M2tsPreventBufferUnderflowType

def get_value() -> M2tsPreventBufferUnderflowType:
    return "DISABLED"
# M2tsPreventBufferUnderflowType definition

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

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",
]

PresetSpeke20AudioType#

# PresetSpeke20AudioType usage example

from mypy_boto3_mediaconvert.literals import PresetSpeke20AudioType

def get_value() -> PresetSpeke20AudioType:
    return "PRESET_AUDIO_1"
# PresetSpeke20AudioType definition

PresetSpeke20AudioType = Literal[
    "PRESET_AUDIO_1",
    "PRESET_AUDIO_2",
    "PRESET_AUDIO_3",
    "SHARED",
    "UNENCRYPTED",
]

PresetSpeke20VideoType#

# PresetSpeke20VideoType usage example

from mypy_boto3_mediaconvert.literals import PresetSpeke20VideoType

def get_value() -> PresetSpeke20VideoType:
    return "PRESET_VIDEO_1"
# PresetSpeke20VideoType definition

PresetSpeke20VideoType = Literal[
    "PRESET_VIDEO_1",
    "PRESET_VIDEO_2",
    "PRESET_VIDEO_3",
    "PRESET_VIDEO_4",
    "PRESET_VIDEO_5",
    "PRESET_VIDEO_6",
    "PRESET_VIDEO_7",
    "PRESET_VIDEO_8",
    "SHARED",
    "UNENCRYPTED",
]

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 ProresChromaSamplingType

def get_value() -> ProresChromaSamplingType:
    return "PRESERVE_444_SAMPLING"
# ProresChromaSamplingType definition

ProresChromaSamplingType = Literal[
    "PRESERVE_444_SAMPLING",
    "SUBSAMPLE_TO_422",
]

ProresCodecProfileType#

# ProresCodecProfileType usage example

from mypy_boto3_mediaconvert.literals import ProresCodecProfileType

def get_value() -> ProresCodecProfileType:
    return "APPLE_PRORES_422"
# ProresCodecProfileType definition

ProresCodecProfileType = Literal[
    "APPLE_PRORES_422",
    "APPLE_PRORES_422_HQ",
    "APPLE_PRORES_422_LT",
    "APPLE_PRORES_422_PROXY",
    "APPLE_PRORES_4444",
    "APPLE_PRORES_4444_XQ",
]

ProresFramerateControlType#

# ProresFramerateControlType usage example

from mypy_boto3_mediaconvert.literals import ProresFramerateControlType

def get_value() -> ProresFramerateControlType:
    return "INITIALIZE_FROM_SOURCE"
# ProresFramerateControlType definition

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

ProresFramerateConversionAlgorithmType#

# ProresFramerateConversionAlgorithmType usage example

from mypy_boto3_mediaconvert.literals import ProresFramerateConversionAlgorithmType

def get_value() -> ProresFramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# ProresFramerateConversionAlgorithmType definition

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

ProresInterlaceModeType#

# ProresInterlaceModeType usage example

from mypy_boto3_mediaconvert.literals import ProresInterlaceModeType

def get_value() -> ProresInterlaceModeType:
    return "BOTTOM_FIELD"
# ProresInterlaceModeType definition

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

ProresParControlType#

# ProresParControlType usage example

from mypy_boto3_mediaconvert.literals import ProresParControlType

def get_value() -> ProresParControlType:
    return "INITIALIZE_FROM_SOURCE"
# ProresParControlType definition

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

ProresScanTypeConversionModeType#

# ProresScanTypeConversionModeType usage example

from mypy_boto3_mediaconvert.literals import ProresScanTypeConversionModeType

def get_value() -> ProresScanTypeConversionModeType:
    return "INTERLACED"
# ProresScanTypeConversionModeType definition

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

ProresSlowPalType#

# ProresSlowPalType usage example

from mypy_boto3_mediaconvert.literals import ProresSlowPalType

def get_value() -> ProresSlowPalType:
    return "DISABLED"
# ProresSlowPalType definition

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

ProresTelecineType#

# ProresTelecineType usage example

from mypy_boto3_mediaconvert.literals import ProresTelecineType

def get_value() -> ProresTelecineType:
    return "HARD"
# ProresTelecineType definition

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

QueueListByType#

# QueueListByType usage example

from mypy_boto3_mediaconvert.literals import QueueListByType

def get_value() -> QueueListByType:
    return "CREATION_DATE"
# QueueListByType definition

QueueListByType = Literal[
    "CREATION_DATE",
    "NAME",
]

QueueStatusType#

# QueueStatusType usage example

from mypy_boto3_mediaconvert.literals import QueueStatusType

def get_value() -> QueueStatusType:
    return "ACTIVE"
# QueueStatusType definition

QueueStatusType = Literal[
    "ACTIVE",
    "PAUSED",
]

RemoveRubyReserveAttributesType#

# RemoveRubyReserveAttributesType usage example

from mypy_boto3_mediaconvert.literals import RemoveRubyReserveAttributesType

def get_value() -> RemoveRubyReserveAttributesType:
    return "DISABLED"
# RemoveRubyReserveAttributesType definition

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

RenewalTypeType#

# RenewalTypeType usage example

from mypy_boto3_mediaconvert.literals import RenewalTypeType

def get_value() -> RenewalTypeType:
    return "AUTO_RENEW"
# RenewalTypeType definition

RenewalTypeType = Literal[
    "AUTO_RENEW",
    "EXPIRE",
]

RequiredFlagType#

# RequiredFlagType usage example

from mypy_boto3_mediaconvert.literals import RequiredFlagType

def get_value() -> RequiredFlagType:
    return "DISABLED"
# RequiredFlagType definition

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

ReservationPlanStatusType#

# ReservationPlanStatusType usage example

from mypy_boto3_mediaconvert.literals import ReservationPlanStatusType

def get_value() -> ReservationPlanStatusType:
    return "ACTIVE"
# ReservationPlanStatusType definition

ReservationPlanStatusType = Literal[
    "ACTIVE",
    "EXPIRED",
]

RespondToAfdType#

# RespondToAfdType usage example

from mypy_boto3_mediaconvert.literals import RespondToAfdType

def get_value() -> RespondToAfdType:
    return "NONE"
# RespondToAfdType definition

RespondToAfdType = Literal[
    "NONE",
    "PASSTHROUGH",
    "RESPOND",
]

RuleTypeType#

# RuleTypeType usage example

from mypy_boto3_mediaconvert.literals import RuleTypeType

def get_value() -> RuleTypeType:
    return "ALLOWED_RENDITIONS"
# RuleTypeType definition

RuleTypeType = Literal[
    "ALLOWED_RENDITIONS",
    "FORCE_INCLUDE_RENDITIONS",
    "MIN_BOTTOM_RENDITION_SIZE",
    "MIN_TOP_RENDITION_SIZE",
]

S3ObjectCannedAclType#

# S3ObjectCannedAclType usage example

from mypy_boto3_mediaconvert.literals import S3ObjectCannedAclType

def get_value() -> S3ObjectCannedAclType:
    return "AUTHENTICATED_READ"
# S3ObjectCannedAclType definition

S3ObjectCannedAclType = Literal[
    "AUTHENTICATED_READ",
    "BUCKET_OWNER_FULL_CONTROL",
    "BUCKET_OWNER_READ",
    "PUBLIC_READ",
]

S3ServerSideEncryptionTypeType#

# S3ServerSideEncryptionTypeType usage example

from mypy_boto3_mediaconvert.literals import S3ServerSideEncryptionTypeType

def get_value() -> S3ServerSideEncryptionTypeType:
    return "SERVER_SIDE_ENCRYPTION_KMS"
# S3ServerSideEncryptionTypeType definition

S3ServerSideEncryptionTypeType = Literal[
    "SERVER_SIDE_ENCRYPTION_KMS",
    "SERVER_SIDE_ENCRYPTION_S3",
]

S3StorageClassType#

# S3StorageClassType usage example

from mypy_boto3_mediaconvert.literals import S3StorageClassType

def get_value() -> S3StorageClassType:
    return "DEEP_ARCHIVE"
# S3StorageClassType definition

S3StorageClassType = Literal[
    "DEEP_ARCHIVE",
    "GLACIER",
    "INTELLIGENT_TIERING",
    "ONEZONE_IA",
    "REDUCED_REDUNDANCY",
    "STANDARD",
    "STANDARD_IA",
]

SampleRangeConversionType#

# SampleRangeConversionType usage example

from mypy_boto3_mediaconvert.literals import SampleRangeConversionType

def get_value() -> SampleRangeConversionType:
    return "LIMITED_RANGE_CLIP"
# SampleRangeConversionType definition

SampleRangeConversionType = Literal[
    "LIMITED_RANGE_CLIP",
    "LIMITED_RANGE_SQUEEZE",
    "NONE",
]

ScalingBehaviorType#

# ScalingBehaviorType usage example

from mypy_boto3_mediaconvert.literals import ScalingBehaviorType

def get_value() -> ScalingBehaviorType:
    return "DEFAULT"
# ScalingBehaviorType definition

ScalingBehaviorType = Literal[
    "DEFAULT",
    "FILL",
    "FIT",
    "FIT_NO_UPSCALE",
    "STRETCH_TO_OUTPUT",
]

SccDestinationFramerateType#

# SccDestinationFramerateType usage example

from mypy_boto3_mediaconvert.literals import SccDestinationFramerateType

def get_value() -> SccDestinationFramerateType:
    return "FRAMERATE_23_97"
# SccDestinationFramerateType definition

SccDestinationFramerateType = Literal[
    "FRAMERATE_23_97",
    "FRAMERATE_24",
    "FRAMERATE_25",
    "FRAMERATE_29_97_DROPFRAME",
    "FRAMERATE_29_97_NON_DROPFRAME",
]

SearchJobsPaginatorName#

# SearchJobsPaginatorName usage example

from mypy_boto3_mediaconvert.literals import SearchJobsPaginatorName

def get_value() -> SearchJobsPaginatorName:
    return "search_jobs"
# SearchJobsPaginatorName definition

SearchJobsPaginatorName = Literal[
    "search_jobs",
]

SimulateReservedQueueType#

# SimulateReservedQueueType usage example

from mypy_boto3_mediaconvert.literals import SimulateReservedQueueType

def get_value() -> SimulateReservedQueueType:
    return "DISABLED"
# SimulateReservedQueueType definition

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

SrtStylePassthroughType#

# SrtStylePassthroughType usage example

from mypy_boto3_mediaconvert.literals import SrtStylePassthroughType

def get_value() -> SrtStylePassthroughType:
    return "DISABLED"
# SrtStylePassthroughType definition

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

StatusUpdateIntervalType#

# StatusUpdateIntervalType usage example

from mypy_boto3_mediaconvert.literals import StatusUpdateIntervalType

def get_value() -> StatusUpdateIntervalType:
    return "SECONDS_10"
# StatusUpdateIntervalType definition

StatusUpdateIntervalType = Literal[
    "SECONDS_10",
    "SECONDS_12",
    "SECONDS_120",
    "SECONDS_15",
    "SECONDS_180",
    "SECONDS_20",
    "SECONDS_240",
    "SECONDS_30",
    "SECONDS_300",
    "SECONDS_360",
    "SECONDS_420",
    "SECONDS_480",
    "SECONDS_540",
    "SECONDS_60",
    "SECONDS_600",
]

TeletextPageTypeType#

# TeletextPageTypeType usage example

from mypy_boto3_mediaconvert.literals import TeletextPageTypeType

def get_value() -> TeletextPageTypeType:
    return "PAGE_TYPE_ADDL_INFO"
# TeletextPageTypeType definition

TeletextPageTypeType = Literal[
    "PAGE_TYPE_ADDL_INFO",
    "PAGE_TYPE_HEARING_IMPAIRED_SUBTITLE",
    "PAGE_TYPE_INITIAL",
    "PAGE_TYPE_PROGRAM_SCHEDULE",
    "PAGE_TYPE_SUBTITLE",
]

TimecodeBurninPositionType#

# TimecodeBurninPositionType usage example

from mypy_boto3_mediaconvert.literals import TimecodeBurninPositionType

def get_value() -> TimecodeBurninPositionType:
    return "BOTTOM_CENTER"
# TimecodeBurninPositionType definition

TimecodeBurninPositionType = Literal[
    "BOTTOM_CENTER",
    "BOTTOM_LEFT",
    "BOTTOM_RIGHT",
    "MIDDLE_CENTER",
    "MIDDLE_LEFT",
    "MIDDLE_RIGHT",
    "TOP_CENTER",
    "TOP_LEFT",
    "TOP_RIGHT",
]

TimecodeSourceType#

# TimecodeSourceType usage example

from mypy_boto3_mediaconvert.literals import TimecodeSourceType

def get_value() -> TimecodeSourceType:
    return "EMBEDDED"
# TimecodeSourceType definition

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

TimecodeTrackType#

# TimecodeTrackType usage example

from mypy_boto3_mediaconvert.literals import TimecodeTrackType

def get_value() -> TimecodeTrackType:
    return "DISABLED"
# TimecodeTrackType definition

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

TimedMetadataType#

# TimedMetadataType usage example

from mypy_boto3_mediaconvert.literals import TimedMetadataType

def get_value() -> TimedMetadataType:
    return "NONE"
# TimedMetadataType definition

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

TsPtsOffsetType#

# TsPtsOffsetType usage example

from mypy_boto3_mediaconvert.literals import TsPtsOffsetType

def get_value() -> TsPtsOffsetType:
    return "AUTO"
# TsPtsOffsetType definition

TsPtsOffsetType = Literal[
    "AUTO",
    "SECONDS",
]

TtmlStylePassthroughType#

# TtmlStylePassthroughType usage example

from mypy_boto3_mediaconvert.literals import TtmlStylePassthroughType

def get_value() -> TtmlStylePassthroughType:
    return "DISABLED"
# TtmlStylePassthroughType definition

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

TypeType#

# TypeType usage example

from mypy_boto3_mediaconvert.literals import TypeType

def get_value() -> TypeType:
    return "CUSTOM"
# TypeType definition

TypeType = Literal[
    "CUSTOM",
    "SYSTEM",
]

UncompressedFourccType#

# UncompressedFourccType usage example

from mypy_boto3_mediaconvert.literals import UncompressedFourccType

def get_value() -> UncompressedFourccType:
    return "I420"
# UncompressedFourccType definition

UncompressedFourccType = Literal[
    "I420",
    "I422",
    "I444",
]

UncompressedFramerateControlType#

# UncompressedFramerateControlType usage example

from mypy_boto3_mediaconvert.literals import UncompressedFramerateControlType

def get_value() -> UncompressedFramerateControlType:
    return "INITIALIZE_FROM_SOURCE"
# UncompressedFramerateControlType definition

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

UncompressedFramerateConversionAlgorithmType#

# UncompressedFramerateConversionAlgorithmType usage example

from mypy_boto3_mediaconvert.literals import UncompressedFramerateConversionAlgorithmType

def get_value() -> UncompressedFramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# UncompressedFramerateConversionAlgorithmType definition

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

UncompressedInterlaceModeType#

# UncompressedInterlaceModeType usage example

from mypy_boto3_mediaconvert.literals import UncompressedInterlaceModeType

def get_value() -> UncompressedInterlaceModeType:
    return "INTERLACED"
# UncompressedInterlaceModeType definition

UncompressedInterlaceModeType = Literal[
    "INTERLACED",
    "PROGRESSIVE",
]

UncompressedScanTypeConversionModeType#

# UncompressedScanTypeConversionModeType usage example

from mypy_boto3_mediaconvert.literals import UncompressedScanTypeConversionModeType

def get_value() -> UncompressedScanTypeConversionModeType:
    return "INTERLACED"
# UncompressedScanTypeConversionModeType definition

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

UncompressedSlowPalType#

# UncompressedSlowPalType usage example

from mypy_boto3_mediaconvert.literals import UncompressedSlowPalType

def get_value() -> UncompressedSlowPalType:
    return "DISABLED"
# UncompressedSlowPalType definition

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

UncompressedTelecineType#

# UncompressedTelecineType usage example

from mypy_boto3_mediaconvert.literals import UncompressedTelecineType

def get_value() -> UncompressedTelecineType:
    return "HARD"
# UncompressedTelecineType definition

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

Vc3ClassType#

# Vc3ClassType usage example

from mypy_boto3_mediaconvert.literals import Vc3ClassType

def get_value() -> Vc3ClassType:
    return "CLASS_145_8BIT"
# Vc3ClassType definition

Vc3ClassType = Literal[
    "CLASS_145_8BIT",
    "CLASS_220_10BIT",
    "CLASS_220_8BIT",
]

Vc3FramerateControlType#

# Vc3FramerateControlType usage example

from mypy_boto3_mediaconvert.literals import Vc3FramerateControlType

def get_value() -> Vc3FramerateControlType:
    return "INITIALIZE_FROM_SOURCE"
# Vc3FramerateControlType definition

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

Vc3FramerateConversionAlgorithmType#

# Vc3FramerateConversionAlgorithmType usage example

from mypy_boto3_mediaconvert.literals import Vc3FramerateConversionAlgorithmType

def get_value() -> Vc3FramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# Vc3FramerateConversionAlgorithmType definition

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

Vc3InterlaceModeType#

# Vc3InterlaceModeType usage example

from mypy_boto3_mediaconvert.literals import Vc3InterlaceModeType

def get_value() -> Vc3InterlaceModeType:
    return "INTERLACED"
# Vc3InterlaceModeType definition

Vc3InterlaceModeType = Literal[
    "INTERLACED",
    "PROGRESSIVE",
]

Vc3ScanTypeConversionModeType#

# Vc3ScanTypeConversionModeType usage example

from mypy_boto3_mediaconvert.literals import Vc3ScanTypeConversionModeType

def get_value() -> Vc3ScanTypeConversionModeType:
    return "INTERLACED"
# Vc3ScanTypeConversionModeType definition

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

Vc3SlowPalType#

# Vc3SlowPalType usage example

from mypy_boto3_mediaconvert.literals import Vc3SlowPalType

def get_value() -> Vc3SlowPalType:
    return "DISABLED"
# Vc3SlowPalType definition

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

Vc3TelecineType#

# Vc3TelecineType usage example

from mypy_boto3_mediaconvert.literals import Vc3TelecineType

def get_value() -> Vc3TelecineType:
    return "HARD"
# Vc3TelecineType definition

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

VchipActionType#

# VchipActionType usage example

from mypy_boto3_mediaconvert.literals import VchipActionType

def get_value() -> VchipActionType:
    return "PASSTHROUGH"
# VchipActionType definition

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

VideoCodecType#

# VideoCodecType usage example

from mypy_boto3_mediaconvert.literals import VideoCodecType

def get_value() -> VideoCodecType:
    return "AV1"
# VideoCodecType definition

VideoCodecType = Literal[
    "AV1",
    "AVC_INTRA",
    "FRAME_CAPTURE",
    "H_264",
    "H_265",
    "MPEG2",
    "PASSTHROUGH",
    "PRORES",
    "UNCOMPRESSED",
    "VC3",
    "VP8",
    "VP9",
    "XAVC",
]

VideoOverlayPlayBackModeType#

# VideoOverlayPlayBackModeType usage example

from mypy_boto3_mediaconvert.literals import VideoOverlayPlayBackModeType

def get_value() -> VideoOverlayPlayBackModeType:
    return "ONCE"
# VideoOverlayPlayBackModeType definition

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

VideoOverlayUnitType#

# VideoOverlayUnitType usage example

from mypy_boto3_mediaconvert.literals import VideoOverlayUnitType

def get_value() -> VideoOverlayUnitType:
    return "PERCENTAGE"
# VideoOverlayUnitType definition

VideoOverlayUnitType = Literal[
    "PERCENTAGE",
    "PIXELS",
]

VideoTimecodeInsertionType#

# VideoTimecodeInsertionType usage example

from mypy_boto3_mediaconvert.literals import VideoTimecodeInsertionType

def get_value() -> VideoTimecodeInsertionType:
    return "DISABLED"
# VideoTimecodeInsertionType definition

VideoTimecodeInsertionType = Literal[
    "DISABLED",
    "PIC_TIMING_SEI",
]

Vp8FramerateControlType#

# Vp8FramerateControlType usage example

from mypy_boto3_mediaconvert.literals import Vp8FramerateControlType

def get_value() -> Vp8FramerateControlType:
    return "INITIALIZE_FROM_SOURCE"
# Vp8FramerateControlType definition

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

Vp8FramerateConversionAlgorithmType#

# Vp8FramerateConversionAlgorithmType usage example

from mypy_boto3_mediaconvert.literals import Vp8FramerateConversionAlgorithmType

def get_value() -> Vp8FramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# Vp8FramerateConversionAlgorithmType definition

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

Vp8ParControlType#

# Vp8ParControlType usage example

from mypy_boto3_mediaconvert.literals import Vp8ParControlType

def get_value() -> Vp8ParControlType:
    return "INITIALIZE_FROM_SOURCE"
# Vp8ParControlType definition

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

Vp8QualityTuningLevelType#

# Vp8QualityTuningLevelType usage example

from mypy_boto3_mediaconvert.literals import Vp8QualityTuningLevelType

def get_value() -> Vp8QualityTuningLevelType:
    return "MULTI_PASS"
# Vp8QualityTuningLevelType definition

Vp8QualityTuningLevelType = Literal[
    "MULTI_PASS",
    "MULTI_PASS_HQ",
]

Vp8RateControlModeType#

# Vp8RateControlModeType usage example

from mypy_boto3_mediaconvert.literals import Vp8RateControlModeType

def get_value() -> Vp8RateControlModeType:
    return "VBR"
# Vp8RateControlModeType definition

Vp8RateControlModeType = Literal[
    "VBR",
]

Vp9FramerateControlType#

# Vp9FramerateControlType usage example

from mypy_boto3_mediaconvert.literals import Vp9FramerateControlType

def get_value() -> Vp9FramerateControlType:
    return "INITIALIZE_FROM_SOURCE"
# Vp9FramerateControlType definition

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

Vp9FramerateConversionAlgorithmType#

# Vp9FramerateConversionAlgorithmType usage example

from mypy_boto3_mediaconvert.literals import Vp9FramerateConversionAlgorithmType

def get_value() -> Vp9FramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# Vp9FramerateConversionAlgorithmType definition

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

Vp9ParControlType#

# Vp9ParControlType usage example

from mypy_boto3_mediaconvert.literals import Vp9ParControlType

def get_value() -> Vp9ParControlType:
    return "INITIALIZE_FROM_SOURCE"
# Vp9ParControlType definition

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

Vp9QualityTuningLevelType#

# Vp9QualityTuningLevelType usage example

from mypy_boto3_mediaconvert.literals import Vp9QualityTuningLevelType

def get_value() -> Vp9QualityTuningLevelType:
    return "MULTI_PASS"
# Vp9QualityTuningLevelType definition

Vp9QualityTuningLevelType = Literal[
    "MULTI_PASS",
    "MULTI_PASS_HQ",
]

Vp9RateControlModeType#

# Vp9RateControlModeType usage example

from mypy_boto3_mediaconvert.literals import Vp9RateControlModeType

def get_value() -> Vp9RateControlModeType:
    return "VBR"
# Vp9RateControlModeType definition

Vp9RateControlModeType = Literal[
    "VBR",
]

WatermarkingStrengthType#

# WatermarkingStrengthType usage example

from mypy_boto3_mediaconvert.literals import WatermarkingStrengthType

def get_value() -> WatermarkingStrengthType:
    return "DEFAULT"
# WatermarkingStrengthType definition

WatermarkingStrengthType = Literal[
    "DEFAULT",
    "LIGHTER",
    "LIGHTEST",
    "STRONGER",
    "STRONGEST",
]

WavFormatType#

# WavFormatType usage example

from mypy_boto3_mediaconvert.literals import WavFormatType

def get_value() -> WavFormatType:
    return "RF64"
# WavFormatType definition

WavFormatType = Literal[
    "RF64",
    "RIFF",
]

WebvttAccessibilitySubsType#

# WebvttAccessibilitySubsType usage example

from mypy_boto3_mediaconvert.literals import WebvttAccessibilitySubsType

def get_value() -> WebvttAccessibilitySubsType:
    return "DISABLED"
# WebvttAccessibilitySubsType definition

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

WebvttStylePassthroughType#

# WebvttStylePassthroughType usage example

from mypy_boto3_mediaconvert.literals import WebvttStylePassthroughType

def get_value() -> WebvttStylePassthroughType:
    return "DISABLED"
# WebvttStylePassthroughType definition

WebvttStylePassthroughType = Literal[
    "DISABLED",
    "ENABLED",
    "STRICT",
]

Xavc4kIntraCbgProfileClassType#

# Xavc4kIntraCbgProfileClassType usage example

from mypy_boto3_mediaconvert.literals import Xavc4kIntraCbgProfileClassType

def get_value() -> Xavc4kIntraCbgProfileClassType:
    return "CLASS_100"
# Xavc4kIntraCbgProfileClassType definition

Xavc4kIntraCbgProfileClassType = Literal[
    "CLASS_100",
    "CLASS_300",
    "CLASS_480",
]

Xavc4kIntraVbrProfileClassType#

# Xavc4kIntraVbrProfileClassType usage example

from mypy_boto3_mediaconvert.literals import Xavc4kIntraVbrProfileClassType

def get_value() -> Xavc4kIntraVbrProfileClassType:
    return "CLASS_100"
# Xavc4kIntraVbrProfileClassType definition

Xavc4kIntraVbrProfileClassType = Literal[
    "CLASS_100",
    "CLASS_300",
    "CLASS_480",
]

Xavc4kProfileBitrateClassType#

# Xavc4kProfileBitrateClassType usage example

from mypy_boto3_mediaconvert.literals import Xavc4kProfileBitrateClassType

def get_value() -> Xavc4kProfileBitrateClassType:
    return "BITRATE_CLASS_100"
# Xavc4kProfileBitrateClassType definition

Xavc4kProfileBitrateClassType = Literal[
    "BITRATE_CLASS_100",
    "BITRATE_CLASS_140",
    "BITRATE_CLASS_200",
]

Xavc4kProfileCodecProfileType#

# Xavc4kProfileCodecProfileType usage example

from mypy_boto3_mediaconvert.literals import Xavc4kProfileCodecProfileType

def get_value() -> Xavc4kProfileCodecProfileType:
    return "HIGH"
# Xavc4kProfileCodecProfileType definition

Xavc4kProfileCodecProfileType = Literal[
    "HIGH",
    "HIGH_422",
]

Xavc4kProfileQualityTuningLevelType#

# Xavc4kProfileQualityTuningLevelType usage example

from mypy_boto3_mediaconvert.literals import Xavc4kProfileQualityTuningLevelType

def get_value() -> Xavc4kProfileQualityTuningLevelType:
    return "MULTI_PASS_HQ"
# Xavc4kProfileQualityTuningLevelType definition

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

XavcAdaptiveQuantizationType#

# XavcAdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import XavcAdaptiveQuantizationType

def get_value() -> XavcAdaptiveQuantizationType:
    return "AUTO"
# XavcAdaptiveQuantizationType definition

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

XavcEntropyEncodingType#

# XavcEntropyEncodingType usage example

from mypy_boto3_mediaconvert.literals import XavcEntropyEncodingType

def get_value() -> XavcEntropyEncodingType:
    return "AUTO"
# XavcEntropyEncodingType definition

XavcEntropyEncodingType = Literal[
    "AUTO",
    "CABAC",
    "CAVLC",
]

XavcFlickerAdaptiveQuantizationType#

# XavcFlickerAdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import XavcFlickerAdaptiveQuantizationType

def get_value() -> XavcFlickerAdaptiveQuantizationType:
    return "DISABLED"
# XavcFlickerAdaptiveQuantizationType definition

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

XavcFramerateControlType#

# XavcFramerateControlType usage example

from mypy_boto3_mediaconvert.literals import XavcFramerateControlType

def get_value() -> XavcFramerateControlType:
    return "INITIALIZE_FROM_SOURCE"
# XavcFramerateControlType definition

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

XavcFramerateConversionAlgorithmType#

# XavcFramerateConversionAlgorithmType usage example

from mypy_boto3_mediaconvert.literals import XavcFramerateConversionAlgorithmType

def get_value() -> XavcFramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# XavcFramerateConversionAlgorithmType definition

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

XavcGopBReferenceType#

# XavcGopBReferenceType usage example

from mypy_boto3_mediaconvert.literals import XavcGopBReferenceType

def get_value() -> XavcGopBReferenceType:
    return "DISABLED"
# XavcGopBReferenceType definition

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

XavcHdIntraCbgProfileClassType#

# XavcHdIntraCbgProfileClassType usage example

from mypy_boto3_mediaconvert.literals import XavcHdIntraCbgProfileClassType

def get_value() -> XavcHdIntraCbgProfileClassType:
    return "CLASS_100"
# XavcHdIntraCbgProfileClassType definition

XavcHdIntraCbgProfileClassType = Literal[
    "CLASS_100",
    "CLASS_200",
    "CLASS_50",
]

XavcHdProfileBitrateClassType#

# XavcHdProfileBitrateClassType usage example

from mypy_boto3_mediaconvert.literals import XavcHdProfileBitrateClassType

def get_value() -> XavcHdProfileBitrateClassType:
    return "BITRATE_CLASS_25"
# XavcHdProfileBitrateClassType definition

XavcHdProfileBitrateClassType = Literal[
    "BITRATE_CLASS_25",
    "BITRATE_CLASS_35",
    "BITRATE_CLASS_50",
]

XavcHdProfileQualityTuningLevelType#

# XavcHdProfileQualityTuningLevelType usage example

from mypy_boto3_mediaconvert.literals import XavcHdProfileQualityTuningLevelType

def get_value() -> XavcHdProfileQualityTuningLevelType:
    return "MULTI_PASS_HQ"
# XavcHdProfileQualityTuningLevelType definition

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

XavcHdProfileTelecineType#

# XavcHdProfileTelecineType usage example

from mypy_boto3_mediaconvert.literals import XavcHdProfileTelecineType

def get_value() -> XavcHdProfileTelecineType:
    return "HARD"
# XavcHdProfileTelecineType definition

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

XavcInterlaceModeType#

# XavcInterlaceModeType usage example

from mypy_boto3_mediaconvert.literals import XavcInterlaceModeType

def get_value() -> XavcInterlaceModeType:
    return "BOTTOM_FIELD"
# XavcInterlaceModeType definition

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

XavcProfileType#

# XavcProfileType usage example

from mypy_boto3_mediaconvert.literals import XavcProfileType

def get_value() -> XavcProfileType:
    return "XAVC_4K"
# XavcProfileType definition

XavcProfileType = Literal[
    "XAVC_4K",
    "XAVC_4K_INTRA_CBG",
    "XAVC_4K_INTRA_VBR",
    "XAVC_HD",
    "XAVC_HD_INTRA_CBG",
]

XavcSlowPalType#

# XavcSlowPalType usage example

from mypy_boto3_mediaconvert.literals import XavcSlowPalType

def get_value() -> XavcSlowPalType:
    return "DISABLED"
# XavcSlowPalType definition

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

XavcSpatialAdaptiveQuantizationType#

# XavcSpatialAdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import XavcSpatialAdaptiveQuantizationType

def get_value() -> XavcSpatialAdaptiveQuantizationType:
    return "DISABLED"
# XavcSpatialAdaptiveQuantizationType definition

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

XavcTemporalAdaptiveQuantizationType#

# XavcTemporalAdaptiveQuantizationType usage example

from mypy_boto3_mediaconvert.literals import XavcTemporalAdaptiveQuantizationType

def get_value() -> XavcTemporalAdaptiveQuantizationType:
    return "DISABLED"
# XavcTemporalAdaptiveQuantizationType definition

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

MediaConvertServiceName#

# MediaConvertServiceName usage example

from mypy_boto3_mediaconvert.literals import MediaConvertServiceName

def get_value() -> MediaConvertServiceName:
    return "mediaconvert"
# MediaConvertServiceName definition

MediaConvertServiceName = Literal[
    "mediaconvert",
]

ServiceName#

# ServiceName usage example

from mypy_boto3_mediaconvert.literals import ServiceName

def get_value() -> ServiceName:
    return "accessanalyzer"
# ServiceName definition

ServiceName = Literal[
    "accessanalyzer",
    "account",
    "acm",
    "acm-pca",
    "amp",
    "amplify",
    "amplifybackend",
    "amplifyuibuilder",
    "apigateway",
    "apigatewaymanagementapi",
    "apigatewayv2",
    "appconfig",
    "appconfigdata",
    "appfabric",
    "appflow",
    "appintegrations",
    "application-autoscaling",
    "application-insights",
    "application-signals",
    "applicationcostprofiler",
    "appmesh",
    "apprunner",
    "appstream",
    "appsync",
    "apptest",
    "arc-zonal-shift",
    "artifact",
    "athena",
    "auditmanager",
    "autoscaling",
    "autoscaling-plans",
    "b2bi",
    "backup",
    "backup-gateway",
    "backupsearch",
    "batch",
    "bcm-data-exports",
    "bcm-pricing-calculator",
    "bedrock",
    "bedrock-agent",
    "bedrock-agent-runtime",
    "bedrock-data-automation",
    "bedrock-data-automation-runtime",
    "bedrock-runtime",
    "billing",
    "billingconductor",
    "braket",
    "budgets",
    "ce",
    "chatbot",
    "chime",
    "chime-sdk-identity",
    "chime-sdk-media-pipelines",
    "chime-sdk-meetings",
    "chime-sdk-messaging",
    "chime-sdk-voice",
    "cleanrooms",
    "cleanroomsml",
    "cloud9",
    "cloudcontrol",
    "clouddirectory",
    "cloudformation",
    "cloudfront",
    "cloudfront-keyvaluestore",
    "cloudhsm",
    "cloudhsmv2",
    "cloudsearch",
    "cloudsearchdomain",
    "cloudtrail",
    "cloudtrail-data",
    "cloudwatch",
    "codeartifact",
    "codebuild",
    "codecatalyst",
    "codecommit",
    "codeconnections",
    "codedeploy",
    "codeguru-reviewer",
    "codeguru-security",
    "codeguruprofiler",
    "codepipeline",
    "codestar-connections",
    "codestar-notifications",
    "cognito-identity",
    "cognito-idp",
    "cognito-sync",
    "comprehend",
    "comprehendmedical",
    "compute-optimizer",
    "config",
    "connect",
    "connect-contact-lens",
    "connectcampaigns",
    "connectcampaignsv2",
    "connectcases",
    "connectparticipant",
    "controlcatalog",
    "controltower",
    "cost-optimization-hub",
    "cur",
    "customer-profiles",
    "databrew",
    "dataexchange",
    "datapipeline",
    "datasync",
    "datazone",
    "dax",
    "deadline",
    "detective",
    "devicefarm",
    "devops-guru",
    "directconnect",
    "discovery",
    "dlm",
    "dms",
    "docdb",
    "docdb-elastic",
    "drs",
    "ds",
    "ds-data",
    "dsql",
    "dynamodb",
    "dynamodbstreams",
    "ebs",
    "ec2",
    "ec2-instance-connect",
    "ecr",
    "ecr-public",
    "ecs",
    "efs",
    "eks",
    "eks-auth",
    "elastic-inference",
    "elasticache",
    "elasticbeanstalk",
    "elastictranscoder",
    "elb",
    "elbv2",
    "emr",
    "emr-containers",
    "emr-serverless",
    "entityresolution",
    "es",
    "events",
    "evidently",
    "finspace",
    "finspace-data",
    "firehose",
    "fis",
    "fms",
    "forecast",
    "forecastquery",
    "frauddetector",
    "freetier",
    "fsx",
    "gamelift",
    "geo-maps",
    "geo-places",
    "geo-routes",
    "glacier",
    "globalaccelerator",
    "glue",
    "grafana",
    "greengrass",
    "greengrassv2",
    "groundstation",
    "guardduty",
    "health",
    "healthlake",
    "iam",
    "identitystore",
    "imagebuilder",
    "importexport",
    "inspector",
    "inspector-scan",
    "inspector2",
    "internetmonitor",
    "invoicing",
    "iot",
    "iot-data",
    "iot-jobs-data",
    "iot1click-devices",
    "iot1click-projects",
    "iotanalytics",
    "iotdeviceadvisor",
    "iotevents",
    "iotevents-data",
    "iotfleethub",
    "iotfleetwise",
    "iotsecuretunneling",
    "iotsitewise",
    "iotthingsgraph",
    "iottwinmaker",
    "iotwireless",
    "ivs",
    "ivs-realtime",
    "ivschat",
    "kafka",
    "kafkaconnect",
    "kendra",
    "kendra-ranking",
    "keyspaces",
    "kinesis",
    "kinesis-video-archived-media",
    "kinesis-video-media",
    "kinesis-video-signaling",
    "kinesis-video-webrtc-storage",
    "kinesisanalytics",
    "kinesisanalyticsv2",
    "kinesisvideo",
    "kms",
    "lakeformation",
    "lambda",
    "launch-wizard",
    "lex-models",
    "lex-runtime",
    "lexv2-models",
    "lexv2-runtime",
    "license-manager",
    "license-manager-linux-subscriptions",
    "license-manager-user-subscriptions",
    "lightsail",
    "location",
    "logs",
    "lookoutequipment",
    "lookoutmetrics",
    "lookoutvision",
    "m2",
    "machinelearning",
    "macie2",
    "mailmanager",
    "managedblockchain",
    "managedblockchain-query",
    "marketplace-agreement",
    "marketplace-catalog",
    "marketplace-deployment",
    "marketplace-entitlement",
    "marketplace-reporting",
    "marketplacecommerceanalytics",
    "mediaconnect",
    "mediaconvert",
    "medialive",
    "mediapackage",
    "mediapackage-vod",
    "mediapackagev2",
    "mediastore",
    "mediastore-data",
    "mediatailor",
    "medical-imaging",
    "memorydb",
    "meteringmarketplace",
    "mgh",
    "mgn",
    "migration-hub-refactor-spaces",
    "migrationhub-config",
    "migrationhuborchestrator",
    "migrationhubstrategy",
    "mq",
    "mturk",
    "mwaa",
    "neptune",
    "neptune-graph",
    "neptunedata",
    "network-firewall",
    "networkflowmonitor",
    "networkmanager",
    "networkmonitor",
    "notifications",
    "notificationscontacts",
    "oam",
    "observabilityadmin",
    "omics",
    "opensearch",
    "opensearchserverless",
    "opsworks",
    "opsworkscm",
    "organizations",
    "osis",
    "outposts",
    "panorama",
    "partnercentral-selling",
    "payment-cryptography",
    "payment-cryptography-data",
    "pca-connector-ad",
    "pca-connector-scep",
    "pcs",
    "personalize",
    "personalize-events",
    "personalize-runtime",
    "pi",
    "pinpoint",
    "pinpoint-email",
    "pinpoint-sms-voice",
    "pinpoint-sms-voice-v2",
    "pipes",
    "polly",
    "pricing",
    "privatenetworks",
    "proton",
    "qapps",
    "qbusiness",
    "qconnect",
    "qldb",
    "qldb-session",
    "quicksight",
    "ram",
    "rbin",
    "rds",
    "rds-data",
    "redshift",
    "redshift-data",
    "redshift-serverless",
    "rekognition",
    "repostspace",
    "resiliencehub",
    "resource-explorer-2",
    "resource-groups",
    "resourcegroupstaggingapi",
    "robomaker",
    "rolesanywhere",
    "route53",
    "route53-recovery-cluster",
    "route53-recovery-control-config",
    "route53-recovery-readiness",
    "route53domains",
    "route53profiles",
    "route53resolver",
    "rum",
    "s3",
    "s3control",
    "s3outposts",
    "s3tables",
    "sagemaker",
    "sagemaker-a2i-runtime",
    "sagemaker-edge",
    "sagemaker-featurestore-runtime",
    "sagemaker-geospatial",
    "sagemaker-metrics",
    "sagemaker-runtime",
    "savingsplans",
    "scheduler",
    "schemas",
    "sdb",
    "secretsmanager",
    "security-ir",
    "securityhub",
    "securitylake",
    "serverlessrepo",
    "service-quotas",
    "servicecatalog",
    "servicecatalog-appregistry",
    "servicediscovery",
    "ses",
    "sesv2",
    "shield",
    "signer",
    "simspaceweaver",
    "sms",
    "sms-voice",
    "snow-device-management",
    "snowball",
    "sns",
    "socialmessaging",
    "sqs",
    "ssm",
    "ssm-contacts",
    "ssm-incidents",
    "ssm-quicksetup",
    "ssm-sap",
    "sso",
    "sso-admin",
    "sso-oidc",
    "stepfunctions",
    "storagegateway",
    "sts",
    "supplychain",
    "support",
    "support-app",
    "swf",
    "synthetics",
    "taxsettings",
    "textract",
    "timestream-influxdb",
    "timestream-query",
    "timestream-write",
    "tnb",
    "transcribe",
    "transfer",
    "translate",
    "trustedadvisor",
    "verifiedpermissions",
    "voice-id",
    "vpc-lattice",
    "waf",
    "waf-regional",
    "wafv2",
    "wellarchitected",
    "wisdom",
    "workdocs",
    "workmail",
    "workmailmessageflow",
    "workspaces",
    "workspaces-thin-client",
    "workspaces-web",
    "xray",
]

ResourceServiceName#

# ResourceServiceName usage example

from mypy_boto3_mediaconvert.literals import ResourceServiceName

def get_value() -> ResourceServiceName:
    return "cloudformation"
# ResourceServiceName definition

ResourceServiceName = Literal[
    "cloudformation",
    "cloudwatch",
    "dynamodb",
    "ec2",
    "glacier",
    "iam",
    "opsworks",
    "s3",
    "sns",
    "sqs",
]

PaginatorName#

# PaginatorName usage example

from mypy_boto3_mediaconvert.literals import PaginatorName

def get_value() -> PaginatorName:
    return "describe_endpoints"
# PaginatorName definition

PaginatorName = Literal[
    "describe_endpoints",
    "list_job_templates",
    "list_jobs",
    "list_presets",
    "list_queues",
    "list_versions",
    "search_jobs",
]

RegionName#

# RegionName usage example

from mypy_boto3_mediaconvert.literals import RegionName

def get_value() -> RegionName:
    return "af-south-1"
# RegionName definition

RegionName = Literal[
    "af-south-1",
    "ap-northeast-1",
    "ap-northeast-2",
    "ap-northeast-3",
    "ap-south-1",
    "ap-southeast-1",
    "ap-southeast-2",
    "ap-southeast-4",
    "ca-central-1",
    "eu-central-1",
    "eu-north-1",
    "eu-west-1",
    "eu-west-2",
    "eu-west-3",
    "me-central-1",
    "sa-east-1",
    "us-east-1",
    "us-east-2",
    "us-west-1",
    "us-west-2",
]