Skip to content

Literals#

Index > MediaConvert > Literals

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

AacAudioDescriptionBroadcasterMixType#

# AacAudioDescriptionBroadcasterMixType usage example
from types_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 types_boto3_mediaconvert.literals import AacCodecProfileType

def get_value() -> AacCodecProfileType:
    return "HEV1"
# AacCodecProfileType definition
AacCodecProfileType = Literal[
    "HEV1",
    "HEV2",
    "LC",
    "XHE",
]

AacCodingModeType#

# AacCodingModeType usage example
from types_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",
]

AacLoudnessMeasurementModeType#

# AacLoudnessMeasurementModeType usage example
from types_boto3_mediaconvert.literals import AacLoudnessMeasurementModeType

def get_value() -> AacLoudnessMeasurementModeType:
    return "ANCHOR"
# AacLoudnessMeasurementModeType definition
AacLoudnessMeasurementModeType = Literal[
    "ANCHOR",
    "PROGRAM",
]

AacRateControlModeType#

# AacRateControlModeType usage example
from types_boto3_mediaconvert.literals import AacRateControlModeType

def get_value() -> AacRateControlModeType:
    return "CBR"
# AacRateControlModeType definition
AacRateControlModeType = Literal[
    "CBR",
    "VBR",
]

AacRawFormatType#

# AacRawFormatType usage example
from types_boto3_mediaconvert.literals import AacRawFormatType

def get_value() -> AacRawFormatType:
    return "LATM_LOAS"
# AacRawFormatType definition
AacRawFormatType = Literal[
    "LATM_LOAS",
    "NONE",
]

AacSpecificationType#

# AacSpecificationType usage example
from types_boto3_mediaconvert.literals import AacSpecificationType

def get_value() -> AacSpecificationType:
    return "MPEG2"
# AacSpecificationType definition
AacSpecificationType = Literal[
    "MPEG2",
    "MPEG4",
]

AacVbrQualityType#

# AacVbrQualityType usage example
from types_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 types_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 types_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 types_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 types_boto3_mediaconvert.literals import Ac3DynamicRangeCompressionProfileType

def get_value() -> Ac3DynamicRangeCompressionProfileType:
    return "FILM_STANDARD"
# Ac3DynamicRangeCompressionProfileType definition
Ac3DynamicRangeCompressionProfileType = Literal[
    "FILM_STANDARD",
    "NONE",
]

Ac3DynamicRangeCompressionRfType#

# Ac3DynamicRangeCompressionRfType usage example
from types_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 types_boto3_mediaconvert.literals import Ac3LfeFilterType

def get_value() -> Ac3LfeFilterType:
    return "DISABLED"
# Ac3LfeFilterType definition
Ac3LfeFilterType = Literal[
    "DISABLED",
    "ENABLED",
]

Ac3MetadataControlType#

# Ac3MetadataControlType usage example
from types_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 types_boto3_mediaconvert.literals import AccelerationModeType

def get_value() -> AccelerationModeType:
    return "DISABLED"
# AccelerationModeType definition
AccelerationModeType = Literal[
    "DISABLED",
    "ENABLED",
    "PREFERRED",
]

AccelerationStatusType#

# AccelerationStatusType usage example
from types_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 types_boto3_mediaconvert.literals import AdvancedInputFilterAddTextureType

def get_value() -> AdvancedInputFilterAddTextureType:
    return "DISABLED"
# AdvancedInputFilterAddTextureType definition
AdvancedInputFilterAddTextureType = Literal[
    "DISABLED",
    "ENABLED",
]

AdvancedInputFilterSharpenType#

# AdvancedInputFilterSharpenType usage example
from types_boto3_mediaconvert.literals import AdvancedInputFilterSharpenType

def get_value() -> AdvancedInputFilterSharpenType:
    return "HIGH"
# AdvancedInputFilterSharpenType definition
AdvancedInputFilterSharpenType = Literal[
    "HIGH",
    "LOW",
    "OFF",
]

AdvancedInputFilterType#

# AdvancedInputFilterType usage example
from types_boto3_mediaconvert.literals import AdvancedInputFilterType

def get_value() -> AdvancedInputFilterType:
    return "DISABLED"
# AdvancedInputFilterType definition
AdvancedInputFilterType = Literal[
    "DISABLED",
    "ENABLED",
]

AfdSignalingType#

# AfdSignalingType usage example
from types_boto3_mediaconvert.literals import AfdSignalingType

def get_value() -> AfdSignalingType:
    return "AUTO"
# AfdSignalingType definition
AfdSignalingType = Literal[
    "AUTO",
    "FIXED",
    "NONE",
]

AlphaBehaviorType#

# AlphaBehaviorType usage example
from types_boto3_mediaconvert.literals import AlphaBehaviorType

def get_value() -> AlphaBehaviorType:
    return "DISCARD"
# AlphaBehaviorType definition
AlphaBehaviorType = Literal[
    "DISCARD",
    "REMAP_TO_LUMA",
]

AncillaryConvert608To708Type#

# AncillaryConvert608To708Type usage example
from types_boto3_mediaconvert.literals import AncillaryConvert608To708Type

def get_value() -> AncillaryConvert608To708Type:
    return "DISABLED"
# AncillaryConvert608To708Type definition
AncillaryConvert608To708Type = Literal[
    "DISABLED",
    "UPCONVERT",
]

AncillaryTerminateCaptionsType#

# AncillaryTerminateCaptionsType usage example
from types_boto3_mediaconvert.literals import AncillaryTerminateCaptionsType

def get_value() -> AncillaryTerminateCaptionsType:
    return "DISABLED"
# AncillaryTerminateCaptionsType definition
AncillaryTerminateCaptionsType = Literal[
    "DISABLED",
    "END_OF_INPUT",
]

AntiAliasType#

# AntiAliasType usage example
from types_boto3_mediaconvert.literals import AntiAliasType

def get_value() -> AntiAliasType:
    return "DISABLED"
# AntiAliasType definition
AntiAliasType = Literal[
    "DISABLED",
    "ENABLED",
]

AudioChannelTagType#

# AudioChannelTagType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import AudioDefaultSelectionType

def get_value() -> AudioDefaultSelectionType:
    return "DEFAULT"
# AudioDefaultSelectionType definition
AudioDefaultSelectionType = Literal[
    "DEFAULT",
    "NOT_DEFAULT",
]

AudioDurationCorrectionType#

# AudioDurationCorrectionType usage example
from types_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 types_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 types_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 types_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 types_boto3_mediaconvert.literals import AudioNormalizationLoudnessLoggingType

def get_value() -> AudioNormalizationLoudnessLoggingType:
    return "DONT_LOG"
# AudioNormalizationLoudnessLoggingType definition
AudioNormalizationLoudnessLoggingType = Literal[
    "DONT_LOG",
    "LOG",
]

AudioNormalizationPeakCalculationType#

# AudioNormalizationPeakCalculationType usage example
from types_boto3_mediaconvert.literals import AudioNormalizationPeakCalculationType

def get_value() -> AudioNormalizationPeakCalculationType:
    return "NONE"
# AudioNormalizationPeakCalculationType definition
AudioNormalizationPeakCalculationType = Literal[
    "NONE",
    "TRUE_PEAK",
]

AudioSelectorTypeType#

# AudioSelectorTypeType usage example
from types_boto3_mediaconvert.literals import AudioSelectorTypeType

def get_value() -> AudioSelectorTypeType:
    return "ALL_PCM"
# AudioSelectorTypeType definition
AudioSelectorTypeType = Literal[
    "ALL_PCM",
    "HLS_RENDITION_GROUP",
    "LANGUAGE_CODE",
    "PID",
    "TRACK",
]

AudioTypeControlType#

# AudioTypeControlType usage example
from types_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 types_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 types_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 types_boto3_mediaconvert.literals import Av1FilmGrainSynthesisType

def get_value() -> Av1FilmGrainSynthesisType:
    return "DISABLED"
# Av1FilmGrainSynthesisType definition
Av1FilmGrainSynthesisType = Literal[
    "DISABLED",
    "ENABLED",
]

Av1FramerateControlType#

# Av1FramerateControlType usage example
from types_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 types_boto3_mediaconvert.literals import Av1FramerateConversionAlgorithmType

def get_value() -> Av1FramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# Av1FramerateConversionAlgorithmType definition
Av1FramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "FRAMEFORMER",
    "INTERPOLATE",
    "MAINTAIN_FRAME_COUNT",
]

Av1RateControlModeType#

# Av1RateControlModeType usage example
from types_boto3_mediaconvert.literals import Av1RateControlModeType

def get_value() -> Av1RateControlModeType:
    return "QVBR"
# Av1RateControlModeType definition
Av1RateControlModeType = Literal[
    "QVBR",
]

Av1SpatialAdaptiveQuantizationType#

# Av1SpatialAdaptiveQuantizationType usage example
from types_boto3_mediaconvert.literals import Av1SpatialAdaptiveQuantizationType

def get_value() -> Av1SpatialAdaptiveQuantizationType:
    return "DISABLED"
# Av1SpatialAdaptiveQuantizationType definition
Av1SpatialAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

AvcIntraClassType#

# AvcIntraClassType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import AvcIntraFramerateConversionAlgorithmType

def get_value() -> AvcIntraFramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# AvcIntraFramerateConversionAlgorithmType definition
AvcIntraFramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "FRAMEFORMER",
    "INTERPOLATE",
    "MAINTAIN_FRAME_COUNT",
]

AvcIntraInterlaceModeType#

# AvcIntraInterlaceModeType usage example
from types_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 types_boto3_mediaconvert.literals import AvcIntraScanTypeConversionModeType

def get_value() -> AvcIntraScanTypeConversionModeType:
    return "INTERLACED"
# AvcIntraScanTypeConversionModeType definition
AvcIntraScanTypeConversionModeType = Literal[
    "INTERLACED",
    "INTERLACED_OPTIMIZE",
]

AvcIntraSlowPalType#

# AvcIntraSlowPalType usage example
from types_boto3_mediaconvert.literals import AvcIntraSlowPalType

def get_value() -> AvcIntraSlowPalType:
    return "DISABLED"
# AvcIntraSlowPalType definition
AvcIntraSlowPalType = Literal[
    "DISABLED",
    "ENABLED",
]

AvcIntraTelecineType#

# AvcIntraTelecineType usage example
from types_boto3_mediaconvert.literals import AvcIntraTelecineType

def get_value() -> AvcIntraTelecineType:
    return "HARD"
# AvcIntraTelecineType definition
AvcIntraTelecineType = Literal[
    "HARD",
    "NONE",
]

AvcIntraUhdQualityTuningLevelType#

# AvcIntraUhdQualityTuningLevelType usage example
from types_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 types_boto3_mediaconvert.literals import BandwidthReductionFilterSharpeningType

def get_value() -> BandwidthReductionFilterSharpeningType:
    return "HIGH"
# BandwidthReductionFilterSharpeningType definition
BandwidthReductionFilterSharpeningType = Literal[
    "HIGH",
    "LOW",
    "MEDIUM",
    "OFF",
]

BandwidthReductionFilterStrengthType#

# BandwidthReductionFilterStrengthType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import BurnInSubtitleStylePassthroughType

def get_value() -> BurnInSubtitleStylePassthroughType:
    return "DISABLED"
# BurnInSubtitleStylePassthroughType definition
BurnInSubtitleStylePassthroughType = Literal[
    "DISABLED",
    "ENABLED",
]

BurninSubtitleAlignmentType#

# BurninSubtitleAlignmentType usage example
from types_boto3_mediaconvert.literals import BurninSubtitleAlignmentType

def get_value() -> BurninSubtitleAlignmentType:
    return "AUTO"
# BurninSubtitleAlignmentType definition
BurninSubtitleAlignmentType = Literal[
    "AUTO",
    "CENTERED",
    "LEFT",
]

BurninSubtitleApplyFontColorType#

# BurninSubtitleApplyFontColorType usage example
from types_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 types_boto3_mediaconvert.literals import BurninSubtitleBackgroundColorType

def get_value() -> BurninSubtitleBackgroundColorType:
    return "AUTO"
# BurninSubtitleBackgroundColorType definition
BurninSubtitleBackgroundColorType = Literal[
    "AUTO",
    "BLACK",
    "NONE",
    "WHITE",
]

BurninSubtitleFallbackFontType#

# BurninSubtitleFallbackFontType usage example
from types_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 types_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 types_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 types_boto3_mediaconvert.literals import BurninSubtitleShadowColorType

def get_value() -> BurninSubtitleShadowColorType:
    return "AUTO"
# BurninSubtitleShadowColorType definition
BurninSubtitleShadowColorType = Literal[
    "AUTO",
    "BLACK",
    "NONE",
    "WHITE",
]

BurninSubtitleTeletextSpacingType#

# BurninSubtitleTeletextSpacingType usage example
from types_boto3_mediaconvert.literals import BurninSubtitleTeletextSpacingType

def get_value() -> BurninSubtitleTeletextSpacingType:
    return "AUTO"
# BurninSubtitleTeletextSpacingType definition
BurninSubtitleTeletextSpacingType = Literal[
    "AUTO",
    "FIXED_GRID",
    "PROPORTIONAL",
]

CaptionDestinationTypeType#

# CaptionDestinationTypeType usage example
from types_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 types_boto3_mediaconvert.literals import CaptionSourceByteRateLimitType

def get_value() -> CaptionSourceByteRateLimitType:
    return "DISABLED"
# CaptionSourceByteRateLimitType definition
CaptionSourceByteRateLimitType = Literal[
    "DISABLED",
    "ENABLED",
]

CaptionSourceConvertPaintOnToPopOnType#

# CaptionSourceConvertPaintOnToPopOnType usage example
from types_boto3_mediaconvert.literals import CaptionSourceConvertPaintOnToPopOnType

def get_value() -> CaptionSourceConvertPaintOnToPopOnType:
    return "DISABLED"
# CaptionSourceConvertPaintOnToPopOnType definition
CaptionSourceConvertPaintOnToPopOnType = Literal[
    "DISABLED",
    "ENABLED",
]

CaptionSourceTypeType#

# CaptionSourceTypeType usage example
from types_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",
]

CaptionSourceUpconvertSTLToTeletextType#

# CaptionSourceUpconvertSTLToTeletextType usage example
from types_boto3_mediaconvert.literals import CaptionSourceUpconvertSTLToTeletextType

def get_value() -> CaptionSourceUpconvertSTLToTeletextType:
    return "DISABLED"
# CaptionSourceUpconvertSTLToTeletextType definition
CaptionSourceUpconvertSTLToTeletextType = Literal[
    "DISABLED",
    "UPCONVERT",
]

ChromaPositionModeType#

# ChromaPositionModeType usage example
from types_boto3_mediaconvert.literals import ChromaPositionModeType

def get_value() -> ChromaPositionModeType:
    return "AUTO"
# ChromaPositionModeType definition
ChromaPositionModeType = Literal[
    "AUTO",
    "FORCE_CENTER",
    "FORCE_TOP_LEFT",
]

CmafClientCacheType#

# CmafClientCacheType usage example
from types_boto3_mediaconvert.literals import CmafClientCacheType

def get_value() -> CmafClientCacheType:
    return "DISABLED"
# CmafClientCacheType definition
CmafClientCacheType = Literal[
    "DISABLED",
    "ENABLED",
]

CmafCodecSpecificationType#

# CmafCodecSpecificationType usage example
from types_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 types_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 types_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 types_boto3_mediaconvert.literals import CmafInitializationVectorInManifestType

def get_value() -> CmafInitializationVectorInManifestType:
    return "EXCLUDE"
# CmafInitializationVectorInManifestType definition
CmafInitializationVectorInManifestType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

CmafIntervalCadenceType#

# CmafIntervalCadenceType usage example
from types_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 types_boto3_mediaconvert.literals import CmafKeyProviderTypeType

def get_value() -> CmafKeyProviderTypeType:
    return "SPEKE"
# CmafKeyProviderTypeType definition
CmafKeyProviderTypeType = Literal[
    "SPEKE",
    "STATIC_KEY",
]

CmafManifestCompressionType#

# CmafManifestCompressionType usage example
from types_boto3_mediaconvert.literals import CmafManifestCompressionType

def get_value() -> CmafManifestCompressionType:
    return "GZIP"
# CmafManifestCompressionType definition
CmafManifestCompressionType = Literal[
    "GZIP",
    "NONE",
]

CmafManifestDurationFormatType#

# CmafManifestDurationFormatType usage example
from types_boto3_mediaconvert.literals import CmafManifestDurationFormatType

def get_value() -> CmafManifestDurationFormatType:
    return "FLOATING_POINT"
# CmafManifestDurationFormatType definition
CmafManifestDurationFormatType = Literal[
    "FLOATING_POINT",
    "INTEGER",
]

CmafMpdManifestBandwidthTypeType#

# CmafMpdManifestBandwidthTypeType usage example
from types_boto3_mediaconvert.literals import CmafMpdManifestBandwidthTypeType

def get_value() -> CmafMpdManifestBandwidthTypeType:
    return "AVERAGE"
# CmafMpdManifestBandwidthTypeType definition
CmafMpdManifestBandwidthTypeType = Literal[
    "AVERAGE",
    "MAX",
]

CmafMpdProfileType#

# CmafMpdProfileType usage example
from types_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 types_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 types_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 types_boto3_mediaconvert.literals import CmafSegmentLengthControlType

def get_value() -> CmafSegmentLengthControlType:
    return "EXACT"
# CmafSegmentLengthControlType definition
CmafSegmentLengthControlType = Literal[
    "EXACT",
    "GOP_MULTIPLE",
    "MATCH",
]

CmafStreamInfResolutionType#

# CmafStreamInfResolutionType usage example
from types_boto3_mediaconvert.literals import CmafStreamInfResolutionType

def get_value() -> CmafStreamInfResolutionType:
    return "EXCLUDE"
# CmafStreamInfResolutionType definition
CmafStreamInfResolutionType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

CmafTargetDurationCompatibilityModeType#

# CmafTargetDurationCompatibilityModeType usage example
from types_boto3_mediaconvert.literals import CmafTargetDurationCompatibilityModeType

def get_value() -> CmafTargetDurationCompatibilityModeType:
    return "LEGACY"
# CmafTargetDurationCompatibilityModeType definition
CmafTargetDurationCompatibilityModeType = Literal[
    "LEGACY",
    "SPEC_COMPLIANT",
]

CmafVideoCompositionOffsetsType#

# CmafVideoCompositionOffsetsType usage example
from types_boto3_mediaconvert.literals import CmafVideoCompositionOffsetsType

def get_value() -> CmafVideoCompositionOffsetsType:
    return "SIGNED"
# CmafVideoCompositionOffsetsType definition
CmafVideoCompositionOffsetsType = Literal[
    "SIGNED",
    "UNSIGNED",
]

CmafWriteDASHManifestType#

# CmafWriteDASHManifestType usage example
from types_boto3_mediaconvert.literals import CmafWriteDASHManifestType

def get_value() -> CmafWriteDASHManifestType:
    return "DISABLED"
# CmafWriteDASHManifestType definition
CmafWriteDASHManifestType = Literal[
    "DISABLED",
    "ENABLED",
]

CmafWriteHLSManifestType#

# CmafWriteHLSManifestType usage example
from types_boto3_mediaconvert.literals import CmafWriteHLSManifestType

def get_value() -> CmafWriteHLSManifestType:
    return "DISABLED"
# CmafWriteHLSManifestType definition
CmafWriteHLSManifestType = Literal[
    "DISABLED",
    "ENABLED",
]

CmafWriteSegmentTimelineInRepresentationType#

# CmafWriteSegmentTimelineInRepresentationType usage example
from types_boto3_mediaconvert.literals import CmafWriteSegmentTimelineInRepresentationType

def get_value() -> CmafWriteSegmentTimelineInRepresentationType:
    return "DISABLED"
# CmafWriteSegmentTimelineInRepresentationType definition
CmafWriteSegmentTimelineInRepresentationType = Literal[
    "DISABLED",
    "ENABLED",
]

CmfcAudioDurationType#

# CmfcAudioDurationType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import CmfcDescriptiveVideoServiceFlagType

def get_value() -> CmfcDescriptiveVideoServiceFlagType:
    return "DONT_FLAG"
# CmfcDescriptiveVideoServiceFlagType definition
CmfcDescriptiveVideoServiceFlagType = Literal[
    "DONT_FLAG",
    "FLAG",
]

CmfcIFrameOnlyManifestType#

# CmfcIFrameOnlyManifestType usage example
from types_boto3_mediaconvert.literals import CmfcIFrameOnlyManifestType

def get_value() -> CmfcIFrameOnlyManifestType:
    return "EXCLUDE"
# CmfcIFrameOnlyManifestType definition
CmfcIFrameOnlyManifestType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

CmfcKlvMetadataType#

# CmfcKlvMetadataType usage example
from types_boto3_mediaconvert.literals import CmfcKlvMetadataType

def get_value() -> CmfcKlvMetadataType:
    return "NONE"
# CmfcKlvMetadataType definition
CmfcKlvMetadataType = Literal[
    "NONE",
    "PASSTHROUGH",
]

CmfcManifestMetadataSignalingType#

# CmfcManifestMetadataSignalingType usage example
from types_boto3_mediaconvert.literals import CmfcManifestMetadataSignalingType

def get_value() -> CmfcManifestMetadataSignalingType:
    return "DISABLED"
# CmfcManifestMetadataSignalingType definition
CmfcManifestMetadataSignalingType = Literal[
    "DISABLED",
    "ENABLED",
]

CmfcScte35EsamType#

# CmfcScte35EsamType usage example
from types_boto3_mediaconvert.literals import CmfcScte35EsamType

def get_value() -> CmfcScte35EsamType:
    return "INSERT"
# CmfcScte35EsamType definition
CmfcScte35EsamType = Literal[
    "INSERT",
    "NONE",
]

CmfcScte35SourceType#

# CmfcScte35SourceType usage example
from types_boto3_mediaconvert.literals import CmfcScte35SourceType

def get_value() -> CmfcScte35SourceType:
    return "NONE"
# CmfcScte35SourceType definition
CmfcScte35SourceType = Literal[
    "NONE",
    "PASSTHROUGH",
]

CmfcTimedMetadataBoxVersionType#

# CmfcTimedMetadataBoxVersionType usage example
from types_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 types_boto3_mediaconvert.literals import CmfcTimedMetadataType

def get_value() -> CmfcTimedMetadataType:
    return "NONE"
# CmfcTimedMetadataType definition
CmfcTimedMetadataType = Literal[
    "NONE",
    "PASSTHROUGH",
]

CodecType#

# CodecType usage example
from types_boto3_mediaconvert.literals import CodecType

def get_value() -> CodecType:
    return "AAC"
# CodecType definition
CodecType = Literal[
    "AAC",
    "AC3",
    "AV1",
    "AVC",
    "C608",
    "C708",
    "EAC3",
    "FLAC",
    "HEVC",
    "JPEG2000",
    "MJPEG",
    "MP3",
    "MP4V",
    "MPEG1",
    "MPEG2",
    "OPUS",
    "PCM",
    "PRORES",
    "QTRLE",
    "THEORA",
    "UNKNOWN",
    "VFW",
    "VORBIS",
    "VP8",
    "VP9",
    "WEBVTT",
]

ColorMetadataType#

# ColorMetadataType usage example
from types_boto3_mediaconvert.literals import ColorMetadataType

def get_value() -> ColorMetadataType:
    return "IGNORE"
# ColorMetadataType definition
ColorMetadataType = Literal[
    "IGNORE",
    "INSERT",
]

ColorPrimariesType#

# ColorPrimariesType usage example
from types_boto3_mediaconvert.literals import ColorPrimariesType

def get_value() -> ColorPrimariesType:
    return "EBU_3213_E"
# ColorPrimariesType definition
ColorPrimariesType = Literal[
    "EBU_3213_E",
    "GENERIC_FILM",
    "IPT",
    "ITU_2020",
    "ITU_470BG",
    "ITU_470M",
    "ITU_709",
    "LAST",
    "RESERVED",
    "SMPTE_170M",
    "SMPTE_2067XYZ",
    "SMPTE_240M",
    "SMPTE_428_1",
    "SMPTE_431_2",
    "SMPTE_EG_432_1",
    "UNSPECIFIED",
]

ColorSpaceConversionType#

# ColorSpaceConversionType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import ColorSpaceUsageType

def get_value() -> ColorSpaceUsageType:
    return "FALLBACK"
# ColorSpaceUsageType definition
ColorSpaceUsageType = Literal[
    "FALLBACK",
    "FORCE",
]

CommitmentType#

# CommitmentType usage example
from types_boto3_mediaconvert.literals import CommitmentType

def get_value() -> CommitmentType:
    return "ONE_YEAR"
# CommitmentType definition
CommitmentType = Literal[
    "ONE_YEAR",
]

ContainerTypeType#

# ContainerTypeType usage example
from types_boto3_mediaconvert.literals import ContainerTypeType

def get_value() -> ContainerTypeType:
    return "CMFC"
# ContainerTypeType definition
ContainerTypeType = Literal[
    "CMFC",
    "F4V",
    "GIF",
    "ISMV",
    "M2TS",
    "M3U8",
    "MOV",
    "MP4",
    "MPD",
    "MXF",
    "OGG",
    "RAW",
    "WEBM",
    "Y4M",
]

CopyProtectionActionType#

# CopyProtectionActionType usage example
from types_boto3_mediaconvert.literals import CopyProtectionActionType

def get_value() -> CopyProtectionActionType:
    return "PASSTHROUGH"
# CopyProtectionActionType definition
CopyProtectionActionType = Literal[
    "PASSTHROUGH",
    "STRIP",
]

DashIsoGroupAudioChannelConfigSchemeIdUriType#

# DashIsoGroupAudioChannelConfigSchemeIdUriType usage example
from types_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 types_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 types_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 types_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 types_boto3_mediaconvert.literals import DashIsoMpdManifestBandwidthTypeType

def get_value() -> DashIsoMpdManifestBandwidthTypeType:
    return "AVERAGE"
# DashIsoMpdManifestBandwidthTypeType definition
DashIsoMpdManifestBandwidthTypeType = Literal[
    "AVERAGE",
    "MAX",
]

DashIsoMpdProfileType#

# DashIsoMpdProfileType usage example
from types_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 types_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 types_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 types_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 types_boto3_mediaconvert.literals import DashIsoSegmentLengthControlType

def get_value() -> DashIsoSegmentLengthControlType:
    return "EXACT"
# DashIsoSegmentLengthControlType definition
DashIsoSegmentLengthControlType = Literal[
    "EXACT",
    "GOP_MULTIPLE",
    "MATCH",
]

DashIsoVideoCompositionOffsetsType#

# DashIsoVideoCompositionOffsetsType usage example
from types_boto3_mediaconvert.literals import DashIsoVideoCompositionOffsetsType

def get_value() -> DashIsoVideoCompositionOffsetsType:
    return "SIGNED"
# DashIsoVideoCompositionOffsetsType definition
DashIsoVideoCompositionOffsetsType = Literal[
    "SIGNED",
    "UNSIGNED",
]

DashIsoWriteSegmentTimelineInRepresentationType#

# DashIsoWriteSegmentTimelineInRepresentationType usage example
from types_boto3_mediaconvert.literals import DashIsoWriteSegmentTimelineInRepresentationType

def get_value() -> DashIsoWriteSegmentTimelineInRepresentationType:
    return "DISABLED"
# DashIsoWriteSegmentTimelineInRepresentationType definition
DashIsoWriteSegmentTimelineInRepresentationType = Literal[
    "DISABLED",
    "ENABLED",
]

DashManifestStyleType#

# DashManifestStyleType usage example
from types_boto3_mediaconvert.literals import DashManifestStyleType

def get_value() -> DashManifestStyleType:
    return "BASIC"
# DashManifestStyleType definition
DashManifestStyleType = Literal[
    "BASIC",
    "COMPACT",
    "DISTINCT",
]

DecryptionModeType#

# DecryptionModeType usage example
from types_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 types_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 types_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 types_boto3_mediaconvert.literals import DeinterlacerModeType

def get_value() -> DeinterlacerModeType:
    return "ADAPTIVE"
# DeinterlacerModeType definition
DeinterlacerModeType = Literal[
    "ADAPTIVE",
    "DEINTERLACE",
    "INVERSE_TELECINE",
]

DescribeEndpointsModeType#

# DescribeEndpointsModeType usage example
from types_boto3_mediaconvert.literals import DescribeEndpointsModeType

def get_value() -> DescribeEndpointsModeType:
    return "DEFAULT"
# DescribeEndpointsModeType definition
DescribeEndpointsModeType = Literal[
    "DEFAULT",
    "GET_ONLY",
]

DescribeEndpointsPaginatorName#

# DescribeEndpointsPaginatorName usage example
from types_boto3_mediaconvert.literals import DescribeEndpointsPaginatorName

def get_value() -> DescribeEndpointsPaginatorName:
    return "describe_endpoints"
# DescribeEndpointsPaginatorName definition
DescribeEndpointsPaginatorName = Literal[
    "describe_endpoints",
]

DolbyVisionLevel6ModeType#

# DolbyVisionLevel6ModeType usage example
from types_boto3_mediaconvert.literals import DolbyVisionLevel6ModeType

def get_value() -> DolbyVisionLevel6ModeType:
    return "PASSTHROUGH"
# DolbyVisionLevel6ModeType definition
DolbyVisionLevel6ModeType = Literal[
    "PASSTHROUGH",
    "RECALCULATE",
    "SPECIFY",
]

DolbyVisionMappingType#

# DolbyVisionMappingType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import DropFrameTimecodeType

def get_value() -> DropFrameTimecodeType:
    return "DISABLED"
# DropFrameTimecodeType definition
DropFrameTimecodeType = Literal[
    "DISABLED",
    "ENABLED",
]

DvbSubSubtitleFallbackFontType#

# DvbSubSubtitleFallbackFontType usage example
from types_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 types_boto3_mediaconvert.literals import DvbSubtitleAlignmentType

def get_value() -> DvbSubtitleAlignmentType:
    return "AUTO"
# DvbSubtitleAlignmentType definition
DvbSubtitleAlignmentType = Literal[
    "AUTO",
    "CENTERED",
    "LEFT",
]

DvbSubtitleApplyFontColorType#

# DvbSubtitleApplyFontColorType usage example
from types_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 types_boto3_mediaconvert.literals import DvbSubtitleBackgroundColorType

def get_value() -> DvbSubtitleBackgroundColorType:
    return "AUTO"
# DvbSubtitleBackgroundColorType definition
DvbSubtitleBackgroundColorType = Literal[
    "AUTO",
    "BLACK",
    "NONE",
    "WHITE",
]

DvbSubtitleFontColorType#

# DvbSubtitleFontColorType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import DvbSubtitleShadowColorType

def get_value() -> DvbSubtitleShadowColorType:
    return "AUTO"
# DvbSubtitleShadowColorType definition
DvbSubtitleShadowColorType = Literal[
    "AUTO",
    "BLACK",
    "NONE",
    "WHITE",
]

DvbSubtitleStylePassthroughType#

# DvbSubtitleStylePassthroughType usage example
from types_boto3_mediaconvert.literals import DvbSubtitleStylePassthroughType

def get_value() -> DvbSubtitleStylePassthroughType:
    return "DISABLED"
# DvbSubtitleStylePassthroughType definition
DvbSubtitleStylePassthroughType = Literal[
    "DISABLED",
    "ENABLED",
]

DvbSubtitleTeletextSpacingType#

# DvbSubtitleTeletextSpacingType usage example
from types_boto3_mediaconvert.literals import DvbSubtitleTeletextSpacingType

def get_value() -> DvbSubtitleTeletextSpacingType:
    return "AUTO"
# DvbSubtitleTeletextSpacingType definition
DvbSubtitleTeletextSpacingType = Literal[
    "AUTO",
    "FIXED_GRID",
    "PROPORTIONAL",
]

DvbSubtitlingTypeType#

# DvbSubtitlingTypeType usage example
from types_boto3_mediaconvert.literals import DvbSubtitlingTypeType

def get_value() -> DvbSubtitlingTypeType:
    return "HEARING_IMPAIRED"
# DvbSubtitlingTypeType definition
DvbSubtitlingTypeType = Literal[
    "HEARING_IMPAIRED",
    "STANDARD",
]

DvbddsHandlingType#

# DvbddsHandlingType usage example
from types_boto3_mediaconvert.literals import DvbddsHandlingType

def get_value() -> DvbddsHandlingType:
    return "NONE"
# DvbddsHandlingType definition
DvbddsHandlingType = Literal[
    "NO_DISPLAY_WINDOW",
    "NONE",
    "SPECIFIED",
    "SPECIFIED_OPTIMAL",
]

DynamicAudioSelectorTypeType#

# DynamicAudioSelectorTypeType usage example
from types_boto3_mediaconvert.literals import DynamicAudioSelectorTypeType

def get_value() -> DynamicAudioSelectorTypeType:
    return "ALL_TRACKS"
# DynamicAudioSelectorTypeType definition
DynamicAudioSelectorTypeType = Literal[
    "ALL_TRACKS",
    "LANGUAGE_CODE",
]

Eac3AtmosBitstreamModeType#

# Eac3AtmosBitstreamModeType usage example
from types_boto3_mediaconvert.literals import Eac3AtmosBitstreamModeType

def get_value() -> Eac3AtmosBitstreamModeType:
    return "COMPLETE_MAIN"
# Eac3AtmosBitstreamModeType definition
Eac3AtmosBitstreamModeType = Literal[
    "COMPLETE_MAIN",
]

Eac3AtmosCodingModeType#

# Eac3AtmosCodingModeType usage example
from types_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 types_boto3_mediaconvert.literals import Eac3AtmosDialogueIntelligenceType

def get_value() -> Eac3AtmosDialogueIntelligenceType:
    return "DISABLED"
# Eac3AtmosDialogueIntelligenceType definition
Eac3AtmosDialogueIntelligenceType = Literal[
    "DISABLED",
    "ENABLED",
]

Eac3AtmosDownmixControlType#

# Eac3AtmosDownmixControlType usage example
from types_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 types_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 types_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 types_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 types_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 types_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 types_boto3_mediaconvert.literals import Eac3AtmosSurroundExModeType

def get_value() -> Eac3AtmosSurroundExModeType:
    return "DISABLED"
# Eac3AtmosSurroundExModeType definition
Eac3AtmosSurroundExModeType = Literal[
    "DISABLED",
    "ENABLED",
    "NOT_INDICATED",
]

Eac3AttenuationControlType#

# Eac3AttenuationControlType usage example
from types_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 types_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 types_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 types_boto3_mediaconvert.literals import Eac3DcFilterType

def get_value() -> Eac3DcFilterType:
    return "DISABLED"
# Eac3DcFilterType definition
Eac3DcFilterType = Literal[
    "DISABLED",
    "ENABLED",
]

Eac3DynamicRangeCompressionLineType#

# Eac3DynamicRangeCompressionLineType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import Eac3LfeControlType

def get_value() -> Eac3LfeControlType:
    return "LFE"
# Eac3LfeControlType definition
Eac3LfeControlType = Literal[
    "LFE",
    "NO_LFE",
]

Eac3LfeFilterType#

# Eac3LfeFilterType usage example
from types_boto3_mediaconvert.literals import Eac3LfeFilterType

def get_value() -> Eac3LfeFilterType:
    return "DISABLED"
# Eac3LfeFilterType definition
Eac3LfeFilterType = Literal[
    "DISABLED",
    "ENABLED",
]

Eac3MetadataControlType#

# Eac3MetadataControlType usage example
from types_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 types_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 types_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 types_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 types_boto3_mediaconvert.literals import Eac3SurroundExModeType

def get_value() -> Eac3SurroundExModeType:
    return "DISABLED"
# Eac3SurroundExModeType definition
Eac3SurroundExModeType = Literal[
    "DISABLED",
    "ENABLED",
    "NOT_INDICATED",
]

Eac3SurroundModeType#

# Eac3SurroundModeType usage example
from types_boto3_mediaconvert.literals import Eac3SurroundModeType

def get_value() -> Eac3SurroundModeType:
    return "DISABLED"
# Eac3SurroundModeType definition
Eac3SurroundModeType = Literal[
    "DISABLED",
    "ENABLED",
    "NOT_INDICATED",
]

EmbeddedConvert608To708Type#

# EmbeddedConvert608To708Type usage example
from types_boto3_mediaconvert.literals import EmbeddedConvert608To708Type

def get_value() -> EmbeddedConvert608To708Type:
    return "DISABLED"
# EmbeddedConvert608To708Type definition
EmbeddedConvert608To708Type = Literal[
    "DISABLED",
    "UPCONVERT",
]

EmbeddedTerminateCaptionsType#

# EmbeddedTerminateCaptionsType usage example
from types_boto3_mediaconvert.literals import EmbeddedTerminateCaptionsType

def get_value() -> EmbeddedTerminateCaptionsType:
    return "DISABLED"
# EmbeddedTerminateCaptionsType definition
EmbeddedTerminateCaptionsType = Literal[
    "DISABLED",
    "END_OF_INPUT",
]

EmbeddedTimecodeOverrideType#

# EmbeddedTimecodeOverrideType usage example
from types_boto3_mediaconvert.literals import EmbeddedTimecodeOverrideType

def get_value() -> EmbeddedTimecodeOverrideType:
    return "NONE"
# EmbeddedTimecodeOverrideType definition
EmbeddedTimecodeOverrideType = Literal[
    "NONE",
    "USE_MDPM",
]

F4vMoovPlacementType#

# F4vMoovPlacementType usage example
from types_boto3_mediaconvert.literals import F4vMoovPlacementType

def get_value() -> F4vMoovPlacementType:
    return "NORMAL"
# F4vMoovPlacementType definition
F4vMoovPlacementType = Literal[
    "NORMAL",
    "PROGRESSIVE_DOWNLOAD",
]

FileSourceConvert608To708Type#

# FileSourceConvert608To708Type usage example
from types_boto3_mediaconvert.literals import FileSourceConvert608To708Type

def get_value() -> FileSourceConvert608To708Type:
    return "DISABLED"
# FileSourceConvert608To708Type definition
FileSourceConvert608To708Type = Literal[
    "DISABLED",
    "UPCONVERT",
]

FileSourceTimeDeltaUnitsType#

# FileSourceTimeDeltaUnitsType usage example
from types_boto3_mediaconvert.literals import FileSourceTimeDeltaUnitsType

def get_value() -> FileSourceTimeDeltaUnitsType:
    return "MILLISECONDS"
# FileSourceTimeDeltaUnitsType definition
FileSourceTimeDeltaUnitsType = Literal[
    "MILLISECONDS",
    "SECONDS",
]

FontScriptType#

# FontScriptType usage example
from types_boto3_mediaconvert.literals import FontScriptType

def get_value() -> FontScriptType:
    return "AUTOMATIC"
# FontScriptType definition
FontScriptType = Literal[
    "AUTOMATIC",
    "HANS",
    "HANT",
]

FormatType#

# FormatType usage example
from types_boto3_mediaconvert.literals import FormatType

def get_value() -> FormatType:
    return "matroska"
# FormatType definition
FormatType = Literal[
    "matroska",
    "mp4",
    "mxf",
    "quicktime",
    "webm",
]

FrameMetricTypeType#

# FrameMetricTypeType usage example
from types_boto3_mediaconvert.literals import FrameMetricTypeType

def get_value() -> FrameMetricTypeType:
    return "MS_SSIM"
# FrameMetricTypeType definition
FrameMetricTypeType = Literal[
    "MS_SSIM",
    "PSNR",
    "PSNR_HVS",
    "QVBR",
    "SHOT_CHANGE",
    "SSIM",
    "VMAF",
]

GifFramerateControlType#

# GifFramerateControlType usage example
from types_boto3_mediaconvert.literals import GifFramerateControlType

def get_value() -> GifFramerateControlType:
    return "INITIALIZE_FROM_SOURCE"
# GifFramerateControlType definition
GifFramerateControlType = Literal[
    "INITIALIZE_FROM_SOURCE",
    "SPECIFIED",
]

GifFramerateConversionAlgorithmType#

# GifFramerateConversionAlgorithmType usage example
from types_boto3_mediaconvert.literals import GifFramerateConversionAlgorithmType

def get_value() -> GifFramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# GifFramerateConversionAlgorithmType definition
GifFramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "INTERPOLATE",
]

H264AdaptiveQuantizationType#

# H264AdaptiveQuantizationType usage example
from types_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 types_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 types_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 types_boto3_mediaconvert.literals import H264DynamicSubGopType

def get_value() -> H264DynamicSubGopType:
    return "ADAPTIVE"
# H264DynamicSubGopType definition
H264DynamicSubGopType = Literal[
    "ADAPTIVE",
    "STATIC",
]

H264EndOfStreamMarkersType#

# H264EndOfStreamMarkersType usage example
from types_boto3_mediaconvert.literals import H264EndOfStreamMarkersType

def get_value() -> H264EndOfStreamMarkersType:
    return "INCLUDE"
# H264EndOfStreamMarkersType definition
H264EndOfStreamMarkersType = Literal[
    "INCLUDE",
    "SUPPRESS",
]

H264EntropyEncodingType#

# H264EntropyEncodingType usage example
from types_boto3_mediaconvert.literals import H264EntropyEncodingType

def get_value() -> H264EntropyEncodingType:
    return "CABAC"
# H264EntropyEncodingType definition
H264EntropyEncodingType = Literal[
    "CABAC",
    "CAVLC",
]

H264FieldEncodingType#

# H264FieldEncodingType usage example
from types_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 types_boto3_mediaconvert.literals import H264FlickerAdaptiveQuantizationType

def get_value() -> H264FlickerAdaptiveQuantizationType:
    return "DISABLED"
# H264FlickerAdaptiveQuantizationType definition
H264FlickerAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

H264FramerateControlType#

# H264FramerateControlType usage example
from types_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 types_boto3_mediaconvert.literals import H264FramerateConversionAlgorithmType

def get_value() -> H264FramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# H264FramerateConversionAlgorithmType definition
H264FramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "FRAMEFORMER",
    "INTERPOLATE",
    "MAINTAIN_FRAME_COUNT",
]

H264GopBReferenceType#

# H264GopBReferenceType usage example
from types_boto3_mediaconvert.literals import H264GopBReferenceType

def get_value() -> H264GopBReferenceType:
    return "DISABLED"
# H264GopBReferenceType definition
H264GopBReferenceType = Literal[
    "DISABLED",
    "ENABLED",
]

H264GopSizeUnitsType#

# H264GopSizeUnitsType usage example
from types_boto3_mediaconvert.literals import H264GopSizeUnitsType

def get_value() -> H264GopSizeUnitsType:
    return "AUTO"
# H264GopSizeUnitsType definition
H264GopSizeUnitsType = Literal[
    "AUTO",
    "FRAMES",
    "SECONDS",
]

H264InterlaceModeType#

# H264InterlaceModeType usage example
from types_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 types_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 types_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 types_boto3_mediaconvert.literals import H264RateControlModeType

def get_value() -> H264RateControlModeType:
    return "CBR"
# H264RateControlModeType definition
H264RateControlModeType = Literal[
    "CBR",
    "QVBR",
    "VBR",
]

H264RepeatPpsType#

# H264RepeatPpsType usage example
from types_boto3_mediaconvert.literals import H264RepeatPpsType

def get_value() -> H264RepeatPpsType:
    return "DISABLED"
# H264RepeatPpsType definition
H264RepeatPpsType = Literal[
    "DISABLED",
    "ENABLED",
]

H264SaliencyAwareEncodingType#

# H264SaliencyAwareEncodingType usage example
from types_boto3_mediaconvert.literals import H264SaliencyAwareEncodingType

def get_value() -> H264SaliencyAwareEncodingType:
    return "DISABLED"
# H264SaliencyAwareEncodingType definition
H264SaliencyAwareEncodingType = Literal[
    "DISABLED",
    "PREFERRED",
]

H264ScanTypeConversionModeType#

# H264ScanTypeConversionModeType usage example
from types_boto3_mediaconvert.literals import H264ScanTypeConversionModeType

def get_value() -> H264ScanTypeConversionModeType:
    return "INTERLACED"
# H264ScanTypeConversionModeType definition
H264ScanTypeConversionModeType = Literal[
    "INTERLACED",
    "INTERLACED_OPTIMIZE",
]

H264SceneChangeDetectType#

# H264SceneChangeDetectType usage example
from types_boto3_mediaconvert.literals import H264SceneChangeDetectType

def get_value() -> H264SceneChangeDetectType:
    return "DISABLED"
# H264SceneChangeDetectType definition
H264SceneChangeDetectType = Literal[
    "DISABLED",
    "ENABLED",
    "TRANSITION_DETECTION",
]

H264SlowPalType#

# H264SlowPalType usage example
from types_boto3_mediaconvert.literals import H264SlowPalType

def get_value() -> H264SlowPalType:
    return "DISABLED"
# H264SlowPalType definition
H264SlowPalType = Literal[
    "DISABLED",
    "ENABLED",
]

H264SpatialAdaptiveQuantizationType#

# H264SpatialAdaptiveQuantizationType usage example
from types_boto3_mediaconvert.literals import H264SpatialAdaptiveQuantizationType

def get_value() -> H264SpatialAdaptiveQuantizationType:
    return "DISABLED"
# H264SpatialAdaptiveQuantizationType definition
H264SpatialAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

H264SyntaxType#

# H264SyntaxType usage example
from types_boto3_mediaconvert.literals import H264SyntaxType

def get_value() -> H264SyntaxType:
    return "DEFAULT"
# H264SyntaxType definition
H264SyntaxType = Literal[
    "DEFAULT",
    "RP2027",
]

H264TelecineType#

# H264TelecineType usage example
from types_boto3_mediaconvert.literals import H264TelecineType

def get_value() -> H264TelecineType:
    return "HARD"
# H264TelecineType definition
H264TelecineType = Literal[
    "HARD",
    "NONE",
    "SOFT",
]

H264TemporalAdaptiveQuantizationType#

# H264TemporalAdaptiveQuantizationType usage example
from types_boto3_mediaconvert.literals import H264TemporalAdaptiveQuantizationType

def get_value() -> H264TemporalAdaptiveQuantizationType:
    return "DISABLED"
# H264TemporalAdaptiveQuantizationType definition
H264TemporalAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

H264UnregisteredSeiTimecodeType#

# H264UnregisteredSeiTimecodeType usage example
from types_boto3_mediaconvert.literals import H264UnregisteredSeiTimecodeType

def get_value() -> H264UnregisteredSeiTimecodeType:
    return "DISABLED"
# H264UnregisteredSeiTimecodeType definition
H264UnregisteredSeiTimecodeType = Literal[
    "DISABLED",
    "ENABLED",
]

H264WriteMp4PackagingTypeType#

# H264WriteMp4PackagingTypeType usage example
from types_boto3_mediaconvert.literals import H264WriteMp4PackagingTypeType

def get_value() -> H264WriteMp4PackagingTypeType:
    return "AVC1"
# H264WriteMp4PackagingTypeType definition
H264WriteMp4PackagingTypeType = Literal[
    "AVC1",
    "AVC3",
]

H265AdaptiveQuantizationType#

# H265AdaptiveQuantizationType usage example
from types_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 types_boto3_mediaconvert.literals import H265AlternateTransferFunctionSeiType

def get_value() -> H265AlternateTransferFunctionSeiType:
    return "DISABLED"
# H265AlternateTransferFunctionSeiType definition
H265AlternateTransferFunctionSeiType = Literal[
    "DISABLED",
    "ENABLED",
]

H265CodecLevelType#

# H265CodecLevelType usage example
from types_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 types_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",
]

H265DeblockingType#

# H265DeblockingType usage example
from types_boto3_mediaconvert.literals import H265DeblockingType

def get_value() -> H265DeblockingType:
    return "DISABLED"
# H265DeblockingType definition
H265DeblockingType = Literal[
    "DISABLED",
    "ENABLED",
]

H265DynamicSubGopType#

# H265DynamicSubGopType usage example
from types_boto3_mediaconvert.literals import H265DynamicSubGopType

def get_value() -> H265DynamicSubGopType:
    return "ADAPTIVE"
# H265DynamicSubGopType definition
H265DynamicSubGopType = Literal[
    "ADAPTIVE",
    "STATIC",
]

H265EndOfStreamMarkersType#

# H265EndOfStreamMarkersType usage example
from types_boto3_mediaconvert.literals import H265EndOfStreamMarkersType

def get_value() -> H265EndOfStreamMarkersType:
    return "INCLUDE"
# H265EndOfStreamMarkersType definition
H265EndOfStreamMarkersType = Literal[
    "INCLUDE",
    "SUPPRESS",
]

H265FlickerAdaptiveQuantizationType#

# H265FlickerAdaptiveQuantizationType usage example
from types_boto3_mediaconvert.literals import H265FlickerAdaptiveQuantizationType

def get_value() -> H265FlickerAdaptiveQuantizationType:
    return "DISABLED"
# H265FlickerAdaptiveQuantizationType definition
H265FlickerAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

H265FramerateControlType#

# H265FramerateControlType usage example
from types_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 types_boto3_mediaconvert.literals import H265FramerateConversionAlgorithmType

def get_value() -> H265FramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# H265FramerateConversionAlgorithmType definition
H265FramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "FRAMEFORMER",
    "INTERPOLATE",
    "MAINTAIN_FRAME_COUNT",
]

H265GopBReferenceType#

# H265GopBReferenceType usage example
from types_boto3_mediaconvert.literals import H265GopBReferenceType

def get_value() -> H265GopBReferenceType:
    return "DISABLED"
# H265GopBReferenceType definition
H265GopBReferenceType = Literal[
    "DISABLED",
    "ENABLED",
]

H265GopSizeUnitsType#

# H265GopSizeUnitsType usage example
from types_boto3_mediaconvert.literals import H265GopSizeUnitsType

def get_value() -> H265GopSizeUnitsType:
    return "AUTO"
# H265GopSizeUnitsType definition
H265GopSizeUnitsType = Literal[
    "AUTO",
    "FRAMES",
    "SECONDS",
]

H265InterlaceModeType#

# H265InterlaceModeType usage example
from types_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 types_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 types_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 types_boto3_mediaconvert.literals import H265RateControlModeType

def get_value() -> H265RateControlModeType:
    return "CBR"
# H265RateControlModeType definition
H265RateControlModeType = Literal[
    "CBR",
    "QVBR",
    "VBR",
]

H265SampleAdaptiveOffsetFilterModeType#

# H265SampleAdaptiveOffsetFilterModeType usage example
from types_boto3_mediaconvert.literals import H265SampleAdaptiveOffsetFilterModeType

def get_value() -> H265SampleAdaptiveOffsetFilterModeType:
    return "ADAPTIVE"
# H265SampleAdaptiveOffsetFilterModeType definition
H265SampleAdaptiveOffsetFilterModeType = Literal[
    "ADAPTIVE",
    "DEFAULT",
    "OFF",
]

H265ScanTypeConversionModeType#

# H265ScanTypeConversionModeType usage example
from types_boto3_mediaconvert.literals import H265ScanTypeConversionModeType

def get_value() -> H265ScanTypeConversionModeType:
    return "INTERLACED"
# H265ScanTypeConversionModeType definition
H265ScanTypeConversionModeType = Literal[
    "INTERLACED",
    "INTERLACED_OPTIMIZE",
]

H265SceneChangeDetectType#

# H265SceneChangeDetectType usage example
from types_boto3_mediaconvert.literals import H265SceneChangeDetectType

def get_value() -> H265SceneChangeDetectType:
    return "DISABLED"
# H265SceneChangeDetectType definition
H265SceneChangeDetectType = Literal[
    "DISABLED",
    "ENABLED",
    "TRANSITION_DETECTION",
]

H265SlowPalType#

# H265SlowPalType usage example
from types_boto3_mediaconvert.literals import H265SlowPalType

def get_value() -> H265SlowPalType:
    return "DISABLED"
# H265SlowPalType definition
H265SlowPalType = Literal[
    "DISABLED",
    "ENABLED",
]

H265SpatialAdaptiveQuantizationType#

# H265SpatialAdaptiveQuantizationType usage example
from types_boto3_mediaconvert.literals import H265SpatialAdaptiveQuantizationType

def get_value() -> H265SpatialAdaptiveQuantizationType:
    return "DISABLED"
# H265SpatialAdaptiveQuantizationType definition
H265SpatialAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

H265TelecineType#

# H265TelecineType usage example
from types_boto3_mediaconvert.literals import H265TelecineType

def get_value() -> H265TelecineType:
    return "HARD"
# H265TelecineType definition
H265TelecineType = Literal[
    "HARD",
    "NONE",
    "SOFT",
]

H265TemporalAdaptiveQuantizationType#

# H265TemporalAdaptiveQuantizationType usage example
from types_boto3_mediaconvert.literals import H265TemporalAdaptiveQuantizationType

def get_value() -> H265TemporalAdaptiveQuantizationType:
    return "DISABLED"
# H265TemporalAdaptiveQuantizationType definition
H265TemporalAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

H265TemporalIdsType#

# H265TemporalIdsType usage example
from types_boto3_mediaconvert.literals import H265TemporalIdsType

def get_value() -> H265TemporalIdsType:
    return "DISABLED"
# H265TemporalIdsType definition
H265TemporalIdsType = Literal[
    "DISABLED",
    "ENABLED",
]

H265TilesType#

# H265TilesType usage example
from types_boto3_mediaconvert.literals import H265TilesType

def get_value() -> H265TilesType:
    return "DISABLED"
# H265TilesType definition
H265TilesType = Literal[
    "DISABLED",
    "ENABLED",
]

H265UnregisteredSeiTimecodeType#

# H265UnregisteredSeiTimecodeType usage example
from types_boto3_mediaconvert.literals import H265UnregisteredSeiTimecodeType

def get_value() -> H265UnregisteredSeiTimecodeType:
    return "DISABLED"
# H265UnregisteredSeiTimecodeType definition
H265UnregisteredSeiTimecodeType = Literal[
    "DISABLED",
    "ENABLED",
]

H265WriteMp4PackagingTypeType#

# H265WriteMp4PackagingTypeType usage example
from types_boto3_mediaconvert.literals import H265WriteMp4PackagingTypeType

def get_value() -> H265WriteMp4PackagingTypeType:
    return "HEV1"
# H265WriteMp4PackagingTypeType definition
H265WriteMp4PackagingTypeType = Literal[
    "HEV1",
    "HVC1",
]

HDRToSDRToneMapperType#

# HDRToSDRToneMapperType usage example
from types_boto3_mediaconvert.literals import HDRToSDRToneMapperType

def get_value() -> HDRToSDRToneMapperType:
    return "PRESERVE_DETAILS"
# HDRToSDRToneMapperType definition
HDRToSDRToneMapperType = Literal[
    "PRESERVE_DETAILS",
    "VIBRANT",
]

HlsAdMarkersType#

# HlsAdMarkersType usage example
from types_boto3_mediaconvert.literals import HlsAdMarkersType

def get_value() -> HlsAdMarkersType:
    return "ELEMENTAL"
# HlsAdMarkersType definition
HlsAdMarkersType = Literal[
    "ELEMENTAL",
    "ELEMENTAL_SCTE35",
]

HlsAudioOnlyContainerType#

# HlsAudioOnlyContainerType usage example
from types_boto3_mediaconvert.literals import HlsAudioOnlyContainerType

def get_value() -> HlsAudioOnlyContainerType:
    return "AUTOMATIC"
# HlsAudioOnlyContainerType definition
HlsAudioOnlyContainerType = Literal[
    "AUTOMATIC",
    "M2TS",
]

HlsAudioOnlyHeaderType#

# HlsAudioOnlyHeaderType usage example
from types_boto3_mediaconvert.literals import HlsAudioOnlyHeaderType

def get_value() -> HlsAudioOnlyHeaderType:
    return "EXCLUDE"
# HlsAudioOnlyHeaderType definition
HlsAudioOnlyHeaderType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

HlsAudioTrackTypeType#

# HlsAudioTrackTypeType usage example
from types_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 types_boto3_mediaconvert.literals import HlsCaptionLanguageSettingType

def get_value() -> HlsCaptionLanguageSettingType:
    return "INSERT"
# HlsCaptionLanguageSettingType definition
HlsCaptionLanguageSettingType = Literal[
    "INSERT",
    "NONE",
    "OMIT",
]

HlsCaptionSegmentLengthControlType#

# HlsCaptionSegmentLengthControlType usage example
from types_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 types_boto3_mediaconvert.literals import HlsClientCacheType

def get_value() -> HlsClientCacheType:
    return "DISABLED"
# HlsClientCacheType definition
HlsClientCacheType = Literal[
    "DISABLED",
    "ENABLED",
]

HlsCodecSpecificationType#

# HlsCodecSpecificationType usage example
from types_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 types_boto3_mediaconvert.literals import HlsDescriptiveVideoServiceFlagType

def get_value() -> HlsDescriptiveVideoServiceFlagType:
    return "DONT_FLAG"
# HlsDescriptiveVideoServiceFlagType definition
HlsDescriptiveVideoServiceFlagType = Literal[
    "DONT_FLAG",
    "FLAG",
]

HlsDirectoryStructureType#

# HlsDirectoryStructureType usage example
from types_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 types_boto3_mediaconvert.literals import HlsEncryptionTypeType

def get_value() -> HlsEncryptionTypeType:
    return "AES128"
# HlsEncryptionTypeType definition
HlsEncryptionTypeType = Literal[
    "AES128",
    "SAMPLE_AES",
]

HlsIFrameOnlyManifestType#

# HlsIFrameOnlyManifestType usage example
from types_boto3_mediaconvert.literals import HlsIFrameOnlyManifestType

def get_value() -> HlsIFrameOnlyManifestType:
    return "EXCLUDE"
# HlsIFrameOnlyManifestType definition
HlsIFrameOnlyManifestType = Literal[
    "EXCLUDE",
    "INCLUDE",
    "INCLUDE_AS_TS",
]

HlsImageBasedTrickPlayType#

# HlsImageBasedTrickPlayType usage example
from types_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 types_boto3_mediaconvert.literals import HlsInitializationVectorInManifestType

def get_value() -> HlsInitializationVectorInManifestType:
    return "EXCLUDE"
# HlsInitializationVectorInManifestType definition
HlsInitializationVectorInManifestType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

HlsIntervalCadenceType#

# HlsIntervalCadenceType usage example
from types_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 types_boto3_mediaconvert.literals import HlsKeyProviderTypeType

def get_value() -> HlsKeyProviderTypeType:
    return "SPEKE"
# HlsKeyProviderTypeType definition
HlsKeyProviderTypeType = Literal[
    "SPEKE",
    "STATIC_KEY",
]

HlsManifestCompressionType#

# HlsManifestCompressionType usage example
from types_boto3_mediaconvert.literals import HlsManifestCompressionType

def get_value() -> HlsManifestCompressionType:
    return "GZIP"
# HlsManifestCompressionType definition
HlsManifestCompressionType = Literal[
    "GZIP",
    "NONE",
]

HlsManifestDurationFormatType#

# HlsManifestDurationFormatType usage example
from types_boto3_mediaconvert.literals import HlsManifestDurationFormatType

def get_value() -> HlsManifestDurationFormatType:
    return "FLOATING_POINT"
# HlsManifestDurationFormatType definition
HlsManifestDurationFormatType = Literal[
    "FLOATING_POINT",
    "INTEGER",
]

HlsOfflineEncryptedType#

# HlsOfflineEncryptedType usage example
from types_boto3_mediaconvert.literals import HlsOfflineEncryptedType

def get_value() -> HlsOfflineEncryptedType:
    return "DISABLED"
# HlsOfflineEncryptedType definition
HlsOfflineEncryptedType = Literal[
    "DISABLED",
    "ENABLED",
]

HlsOutputSelectionType#

# HlsOutputSelectionType usage example
from types_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 types_boto3_mediaconvert.literals import HlsProgramDateTimeType

def get_value() -> HlsProgramDateTimeType:
    return "EXCLUDE"
# HlsProgramDateTimeType definition
HlsProgramDateTimeType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

HlsProgressiveWriteHlsManifestType#

# HlsProgressiveWriteHlsManifestType usage example
from types_boto3_mediaconvert.literals import HlsProgressiveWriteHlsManifestType

def get_value() -> HlsProgressiveWriteHlsManifestType:
    return "DISABLED"
# HlsProgressiveWriteHlsManifestType definition
HlsProgressiveWriteHlsManifestType = Literal[
    "DISABLED",
    "ENABLED",
]

HlsSegmentControlType#

# HlsSegmentControlType usage example
from types_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 types_boto3_mediaconvert.literals import HlsSegmentLengthControlType

def get_value() -> HlsSegmentLengthControlType:
    return "EXACT"
# HlsSegmentLengthControlType definition
HlsSegmentLengthControlType = Literal[
    "EXACT",
    "GOP_MULTIPLE",
    "MATCH",
]

HlsStreamInfResolutionType#

# HlsStreamInfResolutionType usage example
from types_boto3_mediaconvert.literals import HlsStreamInfResolutionType

def get_value() -> HlsStreamInfResolutionType:
    return "EXCLUDE"
# HlsStreamInfResolutionType definition
HlsStreamInfResolutionType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

HlsTargetDurationCompatibilityModeType#

# HlsTargetDurationCompatibilityModeType usage example
from types_boto3_mediaconvert.literals import HlsTargetDurationCompatibilityModeType

def get_value() -> HlsTargetDurationCompatibilityModeType:
    return "LEGACY"
# HlsTargetDurationCompatibilityModeType definition
HlsTargetDurationCompatibilityModeType = Literal[
    "LEGACY",
    "SPEC_COMPLIANT",
]

HlsTimedMetadataId3FrameType#

# HlsTimedMetadataId3FrameType usage example
from types_boto3_mediaconvert.literals import HlsTimedMetadataId3FrameType

def get_value() -> HlsTimedMetadataId3FrameType:
    return "NONE"
# HlsTimedMetadataId3FrameType definition
HlsTimedMetadataId3FrameType = Literal[
    "NONE",
    "PRIV",
    "TDRL",
]

ImscAccessibilitySubsType#

# ImscAccessibilitySubsType usage example
from types_boto3_mediaconvert.literals import ImscAccessibilitySubsType

def get_value() -> ImscAccessibilitySubsType:
    return "DISABLED"
# ImscAccessibilitySubsType definition
ImscAccessibilitySubsType = Literal[
    "DISABLED",
    "ENABLED",
]

ImscStylePassthroughType#

# ImscStylePassthroughType usage example
from types_boto3_mediaconvert.literals import ImscStylePassthroughType

def get_value() -> ImscStylePassthroughType:
    return "DISABLED"
# ImscStylePassthroughType definition
ImscStylePassthroughType = Literal[
    "DISABLED",
    "ENABLED",
]

InputDeblockFilterType#

# InputDeblockFilterType usage example
from types_boto3_mediaconvert.literals import InputDeblockFilterType

def get_value() -> InputDeblockFilterType:
    return "DISABLED"
# InputDeblockFilterType definition
InputDeblockFilterType = Literal[
    "DISABLED",
    "ENABLED",
]

InputDenoiseFilterType#

# InputDenoiseFilterType usage example
from types_boto3_mediaconvert.literals import InputDenoiseFilterType

def get_value() -> InputDenoiseFilterType:
    return "DISABLED"
# InputDenoiseFilterType definition
InputDenoiseFilterType = Literal[
    "DISABLED",
    "ENABLED",
]

InputFilterEnableType#

# InputFilterEnableType usage example
from types_boto3_mediaconvert.literals import InputFilterEnableType

def get_value() -> InputFilterEnableType:
    return "AUTO"
# InputFilterEnableType definition
InputFilterEnableType = Literal[
    "AUTO",
    "DISABLE",
    "FORCE",
]

InputPolicyType#

# InputPolicyType usage example
from types_boto3_mediaconvert.literals import InputPolicyType

def get_value() -> InputPolicyType:
    return "ALLOWED"
# InputPolicyType definition
InputPolicyType = Literal[
    "ALLOWED",
    "DISALLOWED",
]

InputPsiControlType#

# InputPsiControlType usage example
from types_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 types_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 types_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 types_boto3_mediaconvert.literals import InputScanTypeType

def get_value() -> InputScanTypeType:
    return "AUTO"
# InputScanTypeType definition
InputScanTypeType = Literal[
    "AUTO",
    "PSF",
]

InputTimecodeSourceType#

# InputTimecodeSourceType usage example
from types_boto3_mediaconvert.literals import InputTimecodeSourceType

def get_value() -> InputTimecodeSourceType:
    return "EMBEDDED"
# InputTimecodeSourceType definition
InputTimecodeSourceType = Literal[
    "EMBEDDED",
    "SPECIFIEDSTART",
    "ZEROBASED",
]

JobPhaseType#

# JobPhaseType usage example
from types_boto3_mediaconvert.literals import JobPhaseType

def get_value() -> JobPhaseType:
    return "PROBING"
# JobPhaseType definition
JobPhaseType = Literal[
    "PROBING",
    "TRANSCODING",
    "UPLOADING",
]

JobStatusType#

# JobStatusType usage example
from types_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 types_boto3_mediaconvert.literals import JobTemplateListByType

def get_value() -> JobTemplateListByType:
    return "CREATION_DATE"
# JobTemplateListByType definition
JobTemplateListByType = Literal[
    "CREATION_DATE",
    "NAME",
    "SYSTEM",
]

JobsQueryFilterKeyType#

# JobsQueryFilterKeyType usage example
from types_boto3_mediaconvert.literals import JobsQueryFilterKeyType

def get_value() -> JobsQueryFilterKeyType:
    return "audioCodec"
# JobsQueryFilterKeyType definition
JobsQueryFilterKeyType = Literal[
    "audioCodec",
    "fileInput",
    "jobEngineVersionRequested",
    "jobEngineVersionUsed",
    "queue",
    "status",
    "videoCodec",
]

JobsQueryStatusType#

# JobsQueryStatusType usage example
from types_boto3_mediaconvert.literals import JobsQueryStatusType

def get_value() -> JobsQueryStatusType:
    return "COMPLETE"
# JobsQueryStatusType definition
JobsQueryStatusType = Literal[
    "COMPLETE",
    "ERROR",
    "PROGRESSING",
    "SUBMITTED",
]

LanguageCodeType#

# LanguageCodeType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import ListJobsPaginatorName

def get_value() -> ListJobsPaginatorName:
    return "list_jobs"
# ListJobsPaginatorName definition
ListJobsPaginatorName = Literal[
    "list_jobs",
]

ListPresetsPaginatorName#

# ListPresetsPaginatorName usage example
from types_boto3_mediaconvert.literals import ListPresetsPaginatorName

def get_value() -> ListPresetsPaginatorName:
    return "list_presets"
# ListPresetsPaginatorName definition
ListPresetsPaginatorName = Literal[
    "list_presets",
]

ListQueuesPaginatorName#

# ListQueuesPaginatorName usage example
from types_boto3_mediaconvert.literals import ListQueuesPaginatorName

def get_value() -> ListQueuesPaginatorName:
    return "list_queues"
# ListQueuesPaginatorName definition
ListQueuesPaginatorName = Literal[
    "list_queues",
]

ListVersionsPaginatorName#

# ListVersionsPaginatorName usage example
from types_boto3_mediaconvert.literals import ListVersionsPaginatorName

def get_value() -> ListVersionsPaginatorName:
    return "list_versions"
# ListVersionsPaginatorName definition
ListVersionsPaginatorName = Literal[
    "list_versions",
]

M2tsAudioBufferModelType#

# M2tsAudioBufferModelType usage example
from types_boto3_mediaconvert.literals import M2tsAudioBufferModelType

def get_value() -> M2tsAudioBufferModelType:
    return "ATSC"
# M2tsAudioBufferModelType definition
M2tsAudioBufferModelType = Literal[
    "ATSC",
    "DVB",
]

M2tsAudioDurationType#

# M2tsAudioDurationType usage example
from types_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 types_boto3_mediaconvert.literals import M2tsBufferModelType

def get_value() -> M2tsBufferModelType:
    return "MULTIPLEX"
# M2tsBufferModelType definition
M2tsBufferModelType = Literal[
    "MULTIPLEX",
    "NONE",
]

M2tsDataPtsControlType#

# M2tsDataPtsControlType usage example
from types_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 types_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 types_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 types_boto3_mediaconvert.literals import M2tsEsRateInPesType

def get_value() -> M2tsEsRateInPesType:
    return "EXCLUDE"
# M2tsEsRateInPesType definition
M2tsEsRateInPesType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

M2tsForceTsVideoEbpOrderType#

# M2tsForceTsVideoEbpOrderType usage example
from types_boto3_mediaconvert.literals import M2tsForceTsVideoEbpOrderType

def get_value() -> M2tsForceTsVideoEbpOrderType:
    return "DEFAULT"
# M2tsForceTsVideoEbpOrderType definition
M2tsForceTsVideoEbpOrderType = Literal[
    "DEFAULT",
    "FORCE",
]

M2tsKlvMetadataType#

# M2tsKlvMetadataType usage example
from types_boto3_mediaconvert.literals import M2tsKlvMetadataType

def get_value() -> M2tsKlvMetadataType:
    return "NONE"
# M2tsKlvMetadataType definition
M2tsKlvMetadataType = Literal[
    "NONE",
    "PASSTHROUGH",
]

M2tsNielsenId3Type#

# M2tsNielsenId3Type usage example
from types_boto3_mediaconvert.literals import M2tsNielsenId3Type

def get_value() -> M2tsNielsenId3Type:
    return "INSERT"
# M2tsNielsenId3Type definition
M2tsNielsenId3Type = Literal[
    "INSERT",
    "NONE",
]

M2tsPcrControlType#

# M2tsPcrControlType usage example
from types_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 types_boto3_mediaconvert.literals import M2tsPreventBufferUnderflowType

def get_value() -> M2tsPreventBufferUnderflowType:
    return "DISABLED"
# M2tsPreventBufferUnderflowType definition
M2tsPreventBufferUnderflowType = Literal[
    "DISABLED",
    "ENABLED",
]

M2tsRateModeType#

# M2tsRateModeType usage example
from types_boto3_mediaconvert.literals import M2tsRateModeType

def get_value() -> M2tsRateModeType:
    return "CBR"
# M2tsRateModeType definition
M2tsRateModeType = Literal[
    "CBR",
    "VBR",
]

M2tsScte35SourceType#

# M2tsScte35SourceType usage example
from types_boto3_mediaconvert.literals import M2tsScte35SourceType

def get_value() -> M2tsScte35SourceType:
    return "NONE"
# M2tsScte35SourceType definition
M2tsScte35SourceType = Literal[
    "NONE",
    "PASSTHROUGH",
]

M2tsSegmentationMarkersType#

# M2tsSegmentationMarkersType usage example
from types_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 types_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 types_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 types_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 types_boto3_mediaconvert.literals import M3u8NielsenId3Type

def get_value() -> M3u8NielsenId3Type:
    return "INSERT"
# M3u8NielsenId3Type definition
M3u8NielsenId3Type = Literal[
    "INSERT",
    "NONE",
]

M3u8PcrControlType#

# M3u8PcrControlType usage example
from types_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 types_boto3_mediaconvert.literals import M3u8Scte35SourceType

def get_value() -> M3u8Scte35SourceType:
    return "NONE"
# M3u8Scte35SourceType definition
M3u8Scte35SourceType = Literal[
    "NONE",
    "PASSTHROUGH",
]

MatrixCoefficientsType#

# MatrixCoefficientsType usage example
from types_boto3_mediaconvert.literals import MatrixCoefficientsType

def get_value() -> MatrixCoefficientsType:
    return "CD_CL"
# MatrixCoefficientsType definition
MatrixCoefficientsType = Literal[
    "CD_CL",
    "CD_NCL",
    "EBU3213",
    "FCC",
    "IPT",
    "ITU_2020_CL",
    "ITU_2020_NCL",
    "ITU_2100ICtCp",
    "ITU_470BG",
    "ITU_709",
    "LAST",
    "RESERVED",
    "RGB",
    "SMPTE_170M",
    "SMPTE_2085",
    "SMPTE_240M",
    "UNSPECIFIED",
    "YCgCo",
]

MotionImageInsertionModeType#

# MotionImageInsertionModeType usage example
from types_boto3_mediaconvert.literals import MotionImageInsertionModeType

def get_value() -> MotionImageInsertionModeType:
    return "MOV"
# MotionImageInsertionModeType definition
MotionImageInsertionModeType = Literal[
    "MOV",
    "PNG",
]

MotionImagePlaybackType#

# MotionImagePlaybackType usage example
from types_boto3_mediaconvert.literals import MotionImagePlaybackType

def get_value() -> MotionImagePlaybackType:
    return "ONCE"
# MotionImagePlaybackType definition
MotionImagePlaybackType = Literal[
    "ONCE",
    "REPEAT",
]

MovClapAtomType#

# MovClapAtomType usage example
from types_boto3_mediaconvert.literals import MovClapAtomType

def get_value() -> MovClapAtomType:
    return "EXCLUDE"
# MovClapAtomType definition
MovClapAtomType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

MovCslgAtomType#

# MovCslgAtomType usage example
from types_boto3_mediaconvert.literals import MovCslgAtomType

def get_value() -> MovCslgAtomType:
    return "EXCLUDE"
# MovCslgAtomType definition
MovCslgAtomType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

MovMpeg2FourCCControlType#

# MovMpeg2FourCCControlType usage example
from types_boto3_mediaconvert.literals import MovMpeg2FourCCControlType

def get_value() -> MovMpeg2FourCCControlType:
    return "MPEG"
# MovMpeg2FourCCControlType definition
MovMpeg2FourCCControlType = Literal[
    "MPEG",
    "XDCAM",
]

MovPaddingControlType#

# MovPaddingControlType usage example
from types_boto3_mediaconvert.literals import MovPaddingControlType

def get_value() -> MovPaddingControlType:
    return "NONE"
# MovPaddingControlType definition
MovPaddingControlType = Literal[
    "NONE",
    "OMNEON",
]

MovReferenceType#

# MovReferenceType usage example
from types_boto3_mediaconvert.literals import MovReferenceType

def get_value() -> MovReferenceType:
    return "EXTERNAL"
# MovReferenceType definition
MovReferenceType = Literal[
    "EXTERNAL",
    "SELF_CONTAINED",
]

Mp2AudioDescriptionMixType#

# Mp2AudioDescriptionMixType usage example
from types_boto3_mediaconvert.literals import Mp2AudioDescriptionMixType

def get_value() -> Mp2AudioDescriptionMixType:
    return "BROADCASTER_MIXED_AD"
# Mp2AudioDescriptionMixType definition
Mp2AudioDescriptionMixType = Literal[
    "BROADCASTER_MIXED_AD",
    "NONE",
]

Mp3RateControlModeType#

# Mp3RateControlModeType usage example
from types_boto3_mediaconvert.literals import Mp3RateControlModeType

def get_value() -> Mp3RateControlModeType:
    return "CBR"
# Mp3RateControlModeType definition
Mp3RateControlModeType = Literal[
    "CBR",
    "VBR",
]

Mp4C2paManifestType#

# Mp4C2paManifestType usage example
from types_boto3_mediaconvert.literals import Mp4C2paManifestType

def get_value() -> Mp4C2paManifestType:
    return "EXCLUDE"
# Mp4C2paManifestType definition
Mp4C2paManifestType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

Mp4CslgAtomType#

# Mp4CslgAtomType usage example
from types_boto3_mediaconvert.literals import Mp4CslgAtomType

def get_value() -> Mp4CslgAtomType:
    return "EXCLUDE"
# Mp4CslgAtomType definition
Mp4CslgAtomType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

Mp4FreeSpaceBoxType#

# Mp4FreeSpaceBoxType usage example
from types_boto3_mediaconvert.literals import Mp4FreeSpaceBoxType

def get_value() -> Mp4FreeSpaceBoxType:
    return "EXCLUDE"
# Mp4FreeSpaceBoxType definition
Mp4FreeSpaceBoxType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

Mp4MoovPlacementType#

# Mp4MoovPlacementType usage example
from types_boto3_mediaconvert.literals import Mp4MoovPlacementType

def get_value() -> Mp4MoovPlacementType:
    return "NORMAL"
# Mp4MoovPlacementType definition
Mp4MoovPlacementType = Literal[
    "NORMAL",
    "PROGRESSIVE_DOWNLOAD",
]

MpdAccessibilityCaptionHintsType#

# MpdAccessibilityCaptionHintsType usage example
from types_boto3_mediaconvert.literals import MpdAccessibilityCaptionHintsType

def get_value() -> MpdAccessibilityCaptionHintsType:
    return "EXCLUDE"
# MpdAccessibilityCaptionHintsType definition
MpdAccessibilityCaptionHintsType = Literal[
    "EXCLUDE",
    "INCLUDE",
]

MpdAudioDurationType#

# MpdAudioDurationType usage example
from types_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 types_boto3_mediaconvert.literals import MpdCaptionContainerTypeType

def get_value() -> MpdCaptionContainerTypeType:
    return "FRAGMENTED_MP4"
# MpdCaptionContainerTypeType definition
MpdCaptionContainerTypeType = Literal[
    "FRAGMENTED_MP4",
    "RAW",
]

MpdKlvMetadataType#

# MpdKlvMetadataType usage example
from types_boto3_mediaconvert.literals import MpdKlvMetadataType

def get_value() -> MpdKlvMetadataType:
    return "NONE"
# MpdKlvMetadataType definition
MpdKlvMetadataType = Literal[
    "NONE",
    "PASSTHROUGH",
]

MpdManifestMetadataSignalingType#

# MpdManifestMetadataSignalingType usage example
from types_boto3_mediaconvert.literals import MpdManifestMetadataSignalingType

def get_value() -> MpdManifestMetadataSignalingType:
    return "DISABLED"
# MpdManifestMetadataSignalingType definition
MpdManifestMetadataSignalingType = Literal[
    "DISABLED",
    "ENABLED",
]

MpdScte35EsamType#

# MpdScte35EsamType usage example
from types_boto3_mediaconvert.literals import MpdScte35EsamType

def get_value() -> MpdScte35EsamType:
    return "INSERT"
# MpdScte35EsamType definition
MpdScte35EsamType = Literal[
    "INSERT",
    "NONE",
]

MpdScte35SourceType#

# MpdScte35SourceType usage example
from types_boto3_mediaconvert.literals import MpdScte35SourceType

def get_value() -> MpdScte35SourceType:
    return "NONE"
# MpdScte35SourceType definition
MpdScte35SourceType = Literal[
    "NONE",
    "PASSTHROUGH",
]

MpdTimedMetadataBoxVersionType#

# MpdTimedMetadataBoxVersionType usage example
from types_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 types_boto3_mediaconvert.literals import MpdTimedMetadataType

def get_value() -> MpdTimedMetadataType:
    return "NONE"
# MpdTimedMetadataType definition
MpdTimedMetadataType = Literal[
    "NONE",
    "PASSTHROUGH",
]

Mpeg2AdaptiveQuantizationType#

# Mpeg2AdaptiveQuantizationType usage example
from types_boto3_mediaconvert.literals import Mpeg2AdaptiveQuantizationType

def get_value() -> Mpeg2AdaptiveQuantizationType:
    return "HIGH"
# Mpeg2AdaptiveQuantizationType definition
Mpeg2AdaptiveQuantizationType = Literal[
    "HIGH",
    "LOW",
    "MEDIUM",
    "OFF",
]

Mpeg2CodecLevelType#

# Mpeg2CodecLevelType usage example
from types_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 types_boto3_mediaconvert.literals import Mpeg2CodecProfileType

def get_value() -> Mpeg2CodecProfileType:
    return "MAIN"
# Mpeg2CodecProfileType definition
Mpeg2CodecProfileType = Literal[
    "MAIN",
    "PROFILE_422",
]

Mpeg2DynamicSubGopType#

# Mpeg2DynamicSubGopType usage example
from types_boto3_mediaconvert.literals import Mpeg2DynamicSubGopType

def get_value() -> Mpeg2DynamicSubGopType:
    return "ADAPTIVE"
# Mpeg2DynamicSubGopType definition
Mpeg2DynamicSubGopType = Literal[
    "ADAPTIVE",
    "STATIC",
]

Mpeg2FramerateControlType#

# Mpeg2FramerateControlType usage example
from types_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 types_boto3_mediaconvert.literals import Mpeg2FramerateConversionAlgorithmType

def get_value() -> Mpeg2FramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# Mpeg2FramerateConversionAlgorithmType definition
Mpeg2FramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "FRAMEFORMER",
    "INTERPOLATE",
    "MAINTAIN_FRAME_COUNT",
]

Mpeg2GopSizeUnitsType#

# Mpeg2GopSizeUnitsType usage example
from types_boto3_mediaconvert.literals import Mpeg2GopSizeUnitsType

def get_value() -> Mpeg2GopSizeUnitsType:
    return "FRAMES"
# Mpeg2GopSizeUnitsType definition
Mpeg2GopSizeUnitsType = Literal[
    "FRAMES",
    "SECONDS",
]

Mpeg2InterlaceModeType#

# Mpeg2InterlaceModeType usage example
from types_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 types_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 types_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 types_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 types_boto3_mediaconvert.literals import Mpeg2RateControlModeType

def get_value() -> Mpeg2RateControlModeType:
    return "CBR"
# Mpeg2RateControlModeType definition
Mpeg2RateControlModeType = Literal[
    "CBR",
    "VBR",
]

Mpeg2ScanTypeConversionModeType#

# Mpeg2ScanTypeConversionModeType usage example
from types_boto3_mediaconvert.literals import Mpeg2ScanTypeConversionModeType

def get_value() -> Mpeg2ScanTypeConversionModeType:
    return "INTERLACED"
# Mpeg2ScanTypeConversionModeType definition
Mpeg2ScanTypeConversionModeType = Literal[
    "INTERLACED",
    "INTERLACED_OPTIMIZE",
]

Mpeg2SceneChangeDetectType#

# Mpeg2SceneChangeDetectType usage example
from types_boto3_mediaconvert.literals import Mpeg2SceneChangeDetectType

def get_value() -> Mpeg2SceneChangeDetectType:
    return "DISABLED"
# Mpeg2SceneChangeDetectType definition
Mpeg2SceneChangeDetectType = Literal[
    "DISABLED",
    "ENABLED",
]

Mpeg2SlowPalType#

# Mpeg2SlowPalType usage example
from types_boto3_mediaconvert.literals import Mpeg2SlowPalType

def get_value() -> Mpeg2SlowPalType:
    return "DISABLED"
# Mpeg2SlowPalType definition
Mpeg2SlowPalType = Literal[
    "DISABLED",
    "ENABLED",
]

Mpeg2SpatialAdaptiveQuantizationType#

# Mpeg2SpatialAdaptiveQuantizationType usage example
from types_boto3_mediaconvert.literals import Mpeg2SpatialAdaptiveQuantizationType

def get_value() -> Mpeg2SpatialAdaptiveQuantizationType:
    return "DISABLED"
# Mpeg2SpatialAdaptiveQuantizationType definition
Mpeg2SpatialAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

Mpeg2SyntaxType#

# Mpeg2SyntaxType usage example
from types_boto3_mediaconvert.literals import Mpeg2SyntaxType

def get_value() -> Mpeg2SyntaxType:
    return "DEFAULT"
# Mpeg2SyntaxType definition
Mpeg2SyntaxType = Literal[
    "D_10",
    "DEFAULT",
]

Mpeg2TelecineType#

# Mpeg2TelecineType usage example
from types_boto3_mediaconvert.literals import Mpeg2TelecineType

def get_value() -> Mpeg2TelecineType:
    return "HARD"
# Mpeg2TelecineType definition
Mpeg2TelecineType = Literal[
    "HARD",
    "NONE",
    "SOFT",
]

Mpeg2TemporalAdaptiveQuantizationType#

# Mpeg2TemporalAdaptiveQuantizationType usage example
from types_boto3_mediaconvert.literals import Mpeg2TemporalAdaptiveQuantizationType

def get_value() -> Mpeg2TemporalAdaptiveQuantizationType:
    return "DISABLED"
# Mpeg2TemporalAdaptiveQuantizationType definition
Mpeg2TemporalAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

MsSmoothAudioDeduplicationType#

# MsSmoothAudioDeduplicationType usage example
from types_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 types_boto3_mediaconvert.literals import MsSmoothFragmentLengthControlType

def get_value() -> MsSmoothFragmentLengthControlType:
    return "EXACT"
# MsSmoothFragmentLengthControlType definition
MsSmoothFragmentLengthControlType = Literal[
    "EXACT",
    "GOP_MULTIPLE",
]

MsSmoothManifestEncodingType#

# MsSmoothManifestEncodingType usage example
from types_boto3_mediaconvert.literals import MsSmoothManifestEncodingType

def get_value() -> MsSmoothManifestEncodingType:
    return "UTF16"
# MsSmoothManifestEncodingType definition
MsSmoothManifestEncodingType = Literal[
    "UTF16",
    "UTF8",
]

MxfAfdSignalingType#

# MxfAfdSignalingType usage example
from types_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 types_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 types_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 types_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 types_boto3_mediaconvert.literals import NielsenSourceWatermarkStatusTypeType

def get_value() -> NielsenSourceWatermarkStatusTypeType:
    return "CLEAN"
# NielsenSourceWatermarkStatusTypeType definition
NielsenSourceWatermarkStatusTypeType = Literal[
    "CLEAN",
    "WATERMARKED",
]

NielsenUniqueTicPerAudioTrackTypeType#

# NielsenUniqueTicPerAudioTrackTypeType usage example
from types_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 types_boto3_mediaconvert.literals import NoiseFilterPostTemporalSharpeningStrengthType

def get_value() -> NoiseFilterPostTemporalSharpeningStrengthType:
    return "HIGH"
# NoiseFilterPostTemporalSharpeningStrengthType definition
NoiseFilterPostTemporalSharpeningStrengthType = Literal[
    "HIGH",
    "LOW",
    "MEDIUM",
]

NoiseFilterPostTemporalSharpeningType#

# NoiseFilterPostTemporalSharpeningType usage example
from types_boto3_mediaconvert.literals import NoiseFilterPostTemporalSharpeningType

def get_value() -> NoiseFilterPostTemporalSharpeningType:
    return "AUTO"
# NoiseFilterPostTemporalSharpeningType definition
NoiseFilterPostTemporalSharpeningType = Literal[
    "AUTO",
    "DISABLED",
    "ENABLED",
]

NoiseReducerFilterType#

# NoiseReducerFilterType usage example
from types_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 types_boto3_mediaconvert.literals import OrderType

def get_value() -> OrderType:
    return "ASCENDING"
# OrderType definition
OrderType = Literal[
    "ASCENDING",
    "DESCENDING",
]

OutputGroupTypeType#

# OutputGroupTypeType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import PadVideoType

def get_value() -> PadVideoType:
    return "BLACK"
# PadVideoType definition
PadVideoType = Literal[
    "BLACK",
    "DISABLED",
]

PresetListByType#

# PresetListByType usage example
from types_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 types_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 types_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 types_boto3_mediaconvert.literals import PricingPlanType

def get_value() -> PricingPlanType:
    return "ON_DEMAND"
# PricingPlanType definition
PricingPlanType = Literal[
    "ON_DEMAND",
    "RESERVED",
]

ProresChromaSamplingType#

# ProresChromaSamplingType usage example
from types_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 types_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 types_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 types_boto3_mediaconvert.literals import ProresFramerateConversionAlgorithmType

def get_value() -> ProresFramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# ProresFramerateConversionAlgorithmType definition
ProresFramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "FRAMEFORMER",
    "INTERPOLATE",
    "MAINTAIN_FRAME_COUNT",
]

ProresInterlaceModeType#

# ProresInterlaceModeType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import ProresScanTypeConversionModeType

def get_value() -> ProresScanTypeConversionModeType:
    return "INTERLACED"
# ProresScanTypeConversionModeType definition
ProresScanTypeConversionModeType = Literal[
    "INTERLACED",
    "INTERLACED_OPTIMIZE",
]

ProresSlowPalType#

# ProresSlowPalType usage example
from types_boto3_mediaconvert.literals import ProresSlowPalType

def get_value() -> ProresSlowPalType:
    return "DISABLED"
# ProresSlowPalType definition
ProresSlowPalType = Literal[
    "DISABLED",
    "ENABLED",
]

ProresTelecineType#

# ProresTelecineType usage example
from types_boto3_mediaconvert.literals import ProresTelecineType

def get_value() -> ProresTelecineType:
    return "HARD"
# ProresTelecineType definition
ProresTelecineType = Literal[
    "HARD",
    "NONE",
]

QueueListByType#

# QueueListByType usage example
from types_boto3_mediaconvert.literals import QueueListByType

def get_value() -> QueueListByType:
    return "CREATION_DATE"
# QueueListByType definition
QueueListByType = Literal[
    "CREATION_DATE",
    "NAME",
]

QueueStatusType#

# QueueStatusType usage example
from types_boto3_mediaconvert.literals import QueueStatusType

def get_value() -> QueueStatusType:
    return "ACTIVE"
# QueueStatusType definition
QueueStatusType = Literal[
    "ACTIVE",
    "PAUSED",
]

RemoveRubyReserveAttributesType#

# RemoveRubyReserveAttributesType usage example
from types_boto3_mediaconvert.literals import RemoveRubyReserveAttributesType

def get_value() -> RemoveRubyReserveAttributesType:
    return "DISABLED"
# RemoveRubyReserveAttributesType definition
RemoveRubyReserveAttributesType = Literal[
    "DISABLED",
    "ENABLED",
]

RenewalTypeType#

# RenewalTypeType usage example
from types_boto3_mediaconvert.literals import RenewalTypeType

def get_value() -> RenewalTypeType:
    return "AUTO_RENEW"
# RenewalTypeType definition
RenewalTypeType = Literal[
    "AUTO_RENEW",
    "EXPIRE",
]

RequiredFlagType#

# RequiredFlagType usage example
from types_boto3_mediaconvert.literals import RequiredFlagType

def get_value() -> RequiredFlagType:
    return "DISABLED"
# RequiredFlagType definition
RequiredFlagType = Literal[
    "DISABLED",
    "ENABLED",
]

ReservationPlanStatusType#

# ReservationPlanStatusType usage example
from types_boto3_mediaconvert.literals import ReservationPlanStatusType

def get_value() -> ReservationPlanStatusType:
    return "ACTIVE"
# ReservationPlanStatusType definition
ReservationPlanStatusType = Literal[
    "ACTIVE",
    "EXPIRED",
]

RespondToAfdType#

# RespondToAfdType usage example
from types_boto3_mediaconvert.literals import RespondToAfdType

def get_value() -> RespondToAfdType:
    return "NONE"
# RespondToAfdType definition
RespondToAfdType = Literal[
    "NONE",
    "PASSTHROUGH",
    "RESPOND",
]

RuleTypeType#

# RuleTypeType usage example
from types_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 types_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 types_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 types_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 types_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 types_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 types_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 types_boto3_mediaconvert.literals import SearchJobsPaginatorName

def get_value() -> SearchJobsPaginatorName:
    return "search_jobs"
# SearchJobsPaginatorName definition
SearchJobsPaginatorName = Literal[
    "search_jobs",
]

ShareStatusType#

# ShareStatusType usage example
from types_boto3_mediaconvert.literals import ShareStatusType

def get_value() -> ShareStatusType:
    return "INITIATED"
# ShareStatusType definition
ShareStatusType = Literal[
    "INITIATED",
    "NOT_SHARED",
    "SHARED",
]

SimulateReservedQueueType#

# SimulateReservedQueueType usage example
from types_boto3_mediaconvert.literals import SimulateReservedQueueType

def get_value() -> SimulateReservedQueueType:
    return "DISABLED"
# SimulateReservedQueueType definition
SimulateReservedQueueType = Literal[
    "DISABLED",
    "ENABLED",
]

SrtStylePassthroughType#

# SrtStylePassthroughType usage example
from types_boto3_mediaconvert.literals import SrtStylePassthroughType

def get_value() -> SrtStylePassthroughType:
    return "DISABLED"
# SrtStylePassthroughType definition
SrtStylePassthroughType = Literal[
    "DISABLED",
    "ENABLED",
]

StatusUpdateIntervalType#

# StatusUpdateIntervalType usage example
from types_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",
]

TamsGapHandlingType#

# TamsGapHandlingType usage example
from types_boto3_mediaconvert.literals import TamsGapHandlingType

def get_value() -> TamsGapHandlingType:
    return "FILL_WITH_BLACK"
# TamsGapHandlingType definition
TamsGapHandlingType = Literal[
    "FILL_WITH_BLACK",
    "HOLD_LAST_FRAME",
    "SKIP_GAPS",
]

TeletextPageTypeType#

# TeletextPageTypeType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import TimecodeSourceType

def get_value() -> TimecodeSourceType:
    return "EMBEDDED"
# TimecodeSourceType definition
TimecodeSourceType = Literal[
    "EMBEDDED",
    "SPECIFIEDSTART",
    "ZEROBASED",
]

TimecodeTrackType#

# TimecodeTrackType usage example
from types_boto3_mediaconvert.literals import TimecodeTrackType

def get_value() -> TimecodeTrackType:
    return "DISABLED"
# TimecodeTrackType definition
TimecodeTrackType = Literal[
    "DISABLED",
    "ENABLED",
]

TimedMetadataType#

# TimedMetadataType usage example
from types_boto3_mediaconvert.literals import TimedMetadataType

def get_value() -> TimedMetadataType:
    return "NONE"
# TimedMetadataType definition
TimedMetadataType = Literal[
    "NONE",
    "PASSTHROUGH",
]

TrackTypeType#

# TrackTypeType usage example
from types_boto3_mediaconvert.literals import TrackTypeType

def get_value() -> TrackTypeType:
    return "audio"
# TrackTypeType definition
TrackTypeType = Literal[
    "audio",
    "data",
    "video",
]

TransferCharacteristicsType#

# TransferCharacteristicsType usage example
from types_boto3_mediaconvert.literals import TransferCharacteristicsType

def get_value() -> TransferCharacteristicsType:
    return "ARIB_B67"
# TransferCharacteristicsType definition
TransferCharacteristicsType = Literal[
    "ARIB_B67",
    "IEC_61966_2_1",
    "IEC_61966_2_4",
    "ITU_1361",
    "ITU_2020_10bit",
    "ITU_2020_12bit",
    "ITU_470BG",
    "ITU_470M",
    "ITU_709",
    "LAST",
    "LINEAR",
    "LOC10_2_5",
    "LOG10_2",
    "RESERVED",
    "SMPTE_170M",
    "SMPTE_2084",
    "SMPTE_240M",
    "SMPTE_428_1",
    "UNSPECIFIED",
]

TsPtsOffsetType#

# TsPtsOffsetType usage example
from types_boto3_mediaconvert.literals import TsPtsOffsetType

def get_value() -> TsPtsOffsetType:
    return "AUTO"
# TsPtsOffsetType definition
TsPtsOffsetType = Literal[
    "AUTO",
    "MILLISECONDS",
    "SECONDS",
]

TtmlStylePassthroughType#

# TtmlStylePassthroughType usage example
from types_boto3_mediaconvert.literals import TtmlStylePassthroughType

def get_value() -> TtmlStylePassthroughType:
    return "DISABLED"
# TtmlStylePassthroughType definition
TtmlStylePassthroughType = Literal[
    "DISABLED",
    "ENABLED",
]

TypeType#

# TypeType usage example
from types_boto3_mediaconvert.literals import TypeType

def get_value() -> TypeType:
    return "CUSTOM"
# TypeType definition
TypeType = Literal[
    "CUSTOM",
    "SYSTEM",
]

UncompressedFourccType#

# UncompressedFourccType usage example
from types_boto3_mediaconvert.literals import UncompressedFourccType

def get_value() -> UncompressedFourccType:
    return "I420"
# UncompressedFourccType definition
UncompressedFourccType = Literal[
    "I420",
    "I422",
    "I444",
]

UncompressedFramerateControlType#

# UncompressedFramerateControlType usage example
from types_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 types_boto3_mediaconvert.literals import UncompressedFramerateConversionAlgorithmType

def get_value() -> UncompressedFramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# UncompressedFramerateConversionAlgorithmType definition
UncompressedFramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "FRAMEFORMER",
    "INTERPOLATE",
    "MAINTAIN_FRAME_COUNT",
]

UncompressedInterlaceModeType#

# UncompressedInterlaceModeType usage example
from types_boto3_mediaconvert.literals import UncompressedInterlaceModeType

def get_value() -> UncompressedInterlaceModeType:
    return "INTERLACED"
# UncompressedInterlaceModeType definition
UncompressedInterlaceModeType = Literal[
    "INTERLACED",
    "PROGRESSIVE",
]

UncompressedScanTypeConversionModeType#

# UncompressedScanTypeConversionModeType usage example
from types_boto3_mediaconvert.literals import UncompressedScanTypeConversionModeType

def get_value() -> UncompressedScanTypeConversionModeType:
    return "INTERLACED"
# UncompressedScanTypeConversionModeType definition
UncompressedScanTypeConversionModeType = Literal[
    "INTERLACED",
    "INTERLACED_OPTIMIZE",
]

UncompressedSlowPalType#

# UncompressedSlowPalType usage example
from types_boto3_mediaconvert.literals import UncompressedSlowPalType

def get_value() -> UncompressedSlowPalType:
    return "DISABLED"
# UncompressedSlowPalType definition
UncompressedSlowPalType = Literal[
    "DISABLED",
    "ENABLED",
]

UncompressedTelecineType#

# UncompressedTelecineType usage example
from types_boto3_mediaconvert.literals import UncompressedTelecineType

def get_value() -> UncompressedTelecineType:
    return "HARD"
# UncompressedTelecineType definition
UncompressedTelecineType = Literal[
    "HARD",
    "NONE",
]

Vc3ClassType#

# Vc3ClassType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import Vc3FramerateConversionAlgorithmType

def get_value() -> Vc3FramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# Vc3FramerateConversionAlgorithmType definition
Vc3FramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "FRAMEFORMER",
    "INTERPOLATE",
    "MAINTAIN_FRAME_COUNT",
]

Vc3InterlaceModeType#

# Vc3InterlaceModeType usage example
from types_boto3_mediaconvert.literals import Vc3InterlaceModeType

def get_value() -> Vc3InterlaceModeType:
    return "INTERLACED"
# Vc3InterlaceModeType definition
Vc3InterlaceModeType = Literal[
    "INTERLACED",
    "PROGRESSIVE",
]

Vc3ScanTypeConversionModeType#

# Vc3ScanTypeConversionModeType usage example
from types_boto3_mediaconvert.literals import Vc3ScanTypeConversionModeType

def get_value() -> Vc3ScanTypeConversionModeType:
    return "INTERLACED"
# Vc3ScanTypeConversionModeType definition
Vc3ScanTypeConversionModeType = Literal[
    "INTERLACED",
    "INTERLACED_OPTIMIZE",
]

Vc3SlowPalType#

# Vc3SlowPalType usage example
from types_boto3_mediaconvert.literals import Vc3SlowPalType

def get_value() -> Vc3SlowPalType:
    return "DISABLED"
# Vc3SlowPalType definition
Vc3SlowPalType = Literal[
    "DISABLED",
    "ENABLED",
]

Vc3TelecineType#

# Vc3TelecineType usage example
from types_boto3_mediaconvert.literals import Vc3TelecineType

def get_value() -> Vc3TelecineType:
    return "HARD"
# Vc3TelecineType definition
Vc3TelecineType = Literal[
    "HARD",
    "NONE",
]

VchipActionType#

# VchipActionType usage example
from types_boto3_mediaconvert.literals import VchipActionType

def get_value() -> VchipActionType:
    return "PASSTHROUGH"
# VchipActionType definition
VchipActionType = Literal[
    "PASSTHROUGH",
    "STRIP",
]

VideoCodecType#

# VideoCodecType usage example
from types_boto3_mediaconvert.literals import VideoCodecType

def get_value() -> VideoCodecType:
    return "AV1"
# VideoCodecType definition
VideoCodecType = Literal[
    "AV1",
    "AVC_INTRA",
    "FRAME_CAPTURE",
    "GIF",
    "H_264",
    "H_265",
    "MPEG2",
    "PASSTHROUGH",
    "PRORES",
    "UNCOMPRESSED",
    "VC3",
    "VP8",
    "VP9",
    "XAVC",
]

VideoOverlayPlayBackModeType#

# VideoOverlayPlayBackModeType usage example
from types_boto3_mediaconvert.literals import VideoOverlayPlayBackModeType

def get_value() -> VideoOverlayPlayBackModeType:
    return "ONCE"
# VideoOverlayPlayBackModeType definition
VideoOverlayPlayBackModeType = Literal[
    "ONCE",
    "REPEAT",
]

VideoOverlayUnitType#

# VideoOverlayUnitType usage example
from types_boto3_mediaconvert.literals import VideoOverlayUnitType

def get_value() -> VideoOverlayUnitType:
    return "PERCENTAGE"
# VideoOverlayUnitType definition
VideoOverlayUnitType = Literal[
    "PERCENTAGE",
    "PIXELS",
]

VideoSelectorTypeType#

# VideoSelectorTypeType usage example
from types_boto3_mediaconvert.literals import VideoSelectorTypeType

def get_value() -> VideoSelectorTypeType:
    return "AUTO"
# VideoSelectorTypeType definition
VideoSelectorTypeType = Literal[
    "AUTO",
    "STREAM",
]

VideoTimecodeInsertionType#

# VideoTimecodeInsertionType usage example
from types_boto3_mediaconvert.literals import VideoTimecodeInsertionType

def get_value() -> VideoTimecodeInsertionType:
    return "DISABLED"
# VideoTimecodeInsertionType definition
VideoTimecodeInsertionType = Literal[
    "DISABLED",
    "PIC_TIMING_SEI",
]

Vp8FramerateControlType#

# Vp8FramerateControlType usage example
from types_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 types_boto3_mediaconvert.literals import Vp8FramerateConversionAlgorithmType

def get_value() -> Vp8FramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# Vp8FramerateConversionAlgorithmType definition
Vp8FramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "FRAMEFORMER",
    "INTERPOLATE",
    "MAINTAIN_FRAME_COUNT",
]

Vp8ParControlType#

# Vp8ParControlType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import Vp8RateControlModeType

def get_value() -> Vp8RateControlModeType:
    return "VBR"
# Vp8RateControlModeType definition
Vp8RateControlModeType = Literal[
    "VBR",
]

Vp9FramerateControlType#

# Vp9FramerateControlType usage example
from types_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 types_boto3_mediaconvert.literals import Vp9FramerateConversionAlgorithmType

def get_value() -> Vp9FramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# Vp9FramerateConversionAlgorithmType definition
Vp9FramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "FRAMEFORMER",
    "INTERPOLATE",
    "MAINTAIN_FRAME_COUNT",
]

Vp9ParControlType#

# Vp9ParControlType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import Vp9RateControlModeType

def get_value() -> Vp9RateControlModeType:
    return "VBR"
# Vp9RateControlModeType definition
Vp9RateControlModeType = Literal[
    "VBR",
]

WatermarkingStrengthType#

# WatermarkingStrengthType usage example
from types_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 types_boto3_mediaconvert.literals import WavFormatType

def get_value() -> WavFormatType:
    return "EXTENSIBLE"
# WavFormatType definition
WavFormatType = Literal[
    "EXTENSIBLE",
    "RF64",
    "RIFF",
]

WebvttAccessibilitySubsType#

# WebvttAccessibilitySubsType usage example
from types_boto3_mediaconvert.literals import WebvttAccessibilitySubsType

def get_value() -> WebvttAccessibilitySubsType:
    return "DISABLED"
# WebvttAccessibilitySubsType definition
WebvttAccessibilitySubsType = Literal[
    "DISABLED",
    "ENABLED",
]

WebvttStylePassthroughType#

# WebvttStylePassthroughType usage example
from types_boto3_mediaconvert.literals import WebvttStylePassthroughType

def get_value() -> WebvttStylePassthroughType:
    return "DISABLED"
# WebvttStylePassthroughType definition
WebvttStylePassthroughType = Literal[
    "DISABLED",
    "ENABLED",
    "MERGE",
    "STRICT",
]

Xavc4kIntraCbgProfileClassType#

# Xavc4kIntraCbgProfileClassType usage example
from types_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 types_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 types_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 types_boto3_mediaconvert.literals import Xavc4kProfileCodecProfileType

def get_value() -> Xavc4kProfileCodecProfileType:
    return "HIGH"
# Xavc4kProfileCodecProfileType definition
Xavc4kProfileCodecProfileType = Literal[
    "HIGH",
    "HIGH_422",
]

Xavc4kProfileQualityTuningLevelType#

# Xavc4kProfileQualityTuningLevelType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import XavcEntropyEncodingType

def get_value() -> XavcEntropyEncodingType:
    return "AUTO"
# XavcEntropyEncodingType definition
XavcEntropyEncodingType = Literal[
    "AUTO",
    "CABAC",
    "CAVLC",
]

XavcFlickerAdaptiveQuantizationType#

# XavcFlickerAdaptiveQuantizationType usage example
from types_boto3_mediaconvert.literals import XavcFlickerAdaptiveQuantizationType

def get_value() -> XavcFlickerAdaptiveQuantizationType:
    return "DISABLED"
# XavcFlickerAdaptiveQuantizationType definition
XavcFlickerAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

XavcFramerateControlType#

# XavcFramerateControlType usage example
from types_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 types_boto3_mediaconvert.literals import XavcFramerateConversionAlgorithmType

def get_value() -> XavcFramerateConversionAlgorithmType:
    return "DUPLICATE_DROP"
# XavcFramerateConversionAlgorithmType definition
XavcFramerateConversionAlgorithmType = Literal[
    "DUPLICATE_DROP",
    "FRAMEFORMER",
    "INTERPOLATE",
    "MAINTAIN_FRAME_COUNT",
]

XavcGopBReferenceType#

# XavcGopBReferenceType usage example
from types_boto3_mediaconvert.literals import XavcGopBReferenceType

def get_value() -> XavcGopBReferenceType:
    return "DISABLED"
# XavcGopBReferenceType definition
XavcGopBReferenceType = Literal[
    "DISABLED",
    "ENABLED",
]

XavcHdIntraCbgProfileClassType#

# XavcHdIntraCbgProfileClassType usage example
from types_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 types_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 types_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 types_boto3_mediaconvert.literals import XavcHdProfileTelecineType

def get_value() -> XavcHdProfileTelecineType:
    return "HARD"
# XavcHdProfileTelecineType definition
XavcHdProfileTelecineType = Literal[
    "HARD",
    "NONE",
]

XavcInterlaceModeType#

# XavcInterlaceModeType usage example
from types_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 types_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 types_boto3_mediaconvert.literals import XavcSlowPalType

def get_value() -> XavcSlowPalType:
    return "DISABLED"
# XavcSlowPalType definition
XavcSlowPalType = Literal[
    "DISABLED",
    "ENABLED",
]

XavcSpatialAdaptiveQuantizationType#

# XavcSpatialAdaptiveQuantizationType usage example
from types_boto3_mediaconvert.literals import XavcSpatialAdaptiveQuantizationType

def get_value() -> XavcSpatialAdaptiveQuantizationType:
    return "DISABLED"
# XavcSpatialAdaptiveQuantizationType definition
XavcSpatialAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

XavcTemporalAdaptiveQuantizationType#

# XavcTemporalAdaptiveQuantizationType usage example
from types_boto3_mediaconvert.literals import XavcTemporalAdaptiveQuantizationType

def get_value() -> XavcTemporalAdaptiveQuantizationType:
    return "DISABLED"
# XavcTemporalAdaptiveQuantizationType definition
XavcTemporalAdaptiveQuantizationType = Literal[
    "DISABLED",
    "ENABLED",
]

MediaConvertServiceName#

# MediaConvertServiceName usage example
from types_boto3_mediaconvert.literals import MediaConvertServiceName

def get_value() -> MediaConvertServiceName:
    return "mediaconvert"
# MediaConvertServiceName definition
MediaConvertServiceName = Literal[
    "mediaconvert",
]

ServiceName#

# ServiceName usage example
from types_boto3_mediaconvert.literals import ServiceName

def get_value() -> ServiceName:
    return "accessanalyzer"
# ServiceName definition
ServiceName = Literal[
    "accessanalyzer",
    "account",
    "acm",
    "acm-pca",
    "aiops",
    "amp",
    "amplify",
    "amplifybackend",
    "amplifyuibuilder",
    "apigateway",
    "apigatewaymanagementapi",
    "apigatewayv2",
    "appconfig",
    "appconfigdata",
    "appfabric",
    "appflow",
    "appintegrations",
    "application-autoscaling",
    "application-insights",
    "application-signals",
    "applicationcostprofiler",
    "appmesh",
    "apprunner",
    "appstream",
    "appsync",
    "arc-region-switch",
    "arc-zonal-shift",
    "artifact",
    "athena",
    "auditmanager",
    "autoscaling",
    "autoscaling-plans",
    "b2bi",
    "backup",
    "backup-gateway",
    "backupsearch",
    "batch",
    "bcm-dashboards",
    "bcm-data-exports",
    "bcm-pricing-calculator",
    "bcm-recommended-actions",
    "bedrock",
    "bedrock-agent",
    "bedrock-agent-runtime",
    "bedrock-agentcore",
    "bedrock-agentcore-control",
    "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",
    "elasticache",
    "elasticbeanstalk",
    "elastictranscoder",
    "elb",
    "elbv2",
    "emr",
    "emr-containers",
    "emr-serverless",
    "entityresolution",
    "es",
    "events",
    "evidently",
    "evs",
    "finspace",
    "finspace-data",
    "firehose",
    "fis",
    "fms",
    "forecast",
    "forecastquery",
    "frauddetector",
    "freetier",
    "fsx",
    "gamelift",
    "gameliftstreams",
    "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",
    "iot-managed-integrations",
    "iotanalytics",
    "iotdeviceadvisor",
    "iotevents",
    "iotevents-data",
    "iotfleetwise",
    "iotsecuretunneling",
    "iotsitewise",
    "iotthingsgraph",
    "iottwinmaker",
    "iotwireless",
    "ivs",
    "ivs-realtime",
    "ivschat",
    "kafka",
    "kafkaconnect",
    "kendra",
    "kendra-ranking",
    "keyspaces",
    "keyspacesstreams",
    "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",
    "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",
    "mpa",
    "mq",
    "mturk",
    "mwaa",
    "neptune",
    "neptune-graph",
    "neptunedata",
    "network-firewall",
    "networkflowmonitor",
    "networkmanager",
    "networkmonitor",
    "notifications",
    "notificationscontacts",
    "oam",
    "observabilityadmin",
    "odb",
    "omics",
    "opensearch",
    "opensearchserverless",
    "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",
    "proton",
    "qapps",
    "qbusiness",
    "qconnect",
    "quicksight",
    "ram",
    "rbin",
    "rds",
    "rds-data",
    "redshift",
    "redshift-data",
    "redshift-serverless",
    "rekognition",
    "repostspace",
    "resiliencehub",
    "resource-explorer-2",
    "resource-groups",
    "resourcegroupstaggingapi",
    "rolesanywhere",
    "route53",
    "route53-recovery-cluster",
    "route53-recovery-control-config",
    "route53-recovery-readiness",
    "route53domains",
    "route53profiles",
    "route53resolver",
    "rtbfabric",
    "rum",
    "s3",
    "s3control",
    "s3outposts",
    "s3tables",
    "s3vectors",
    "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",
    "snow-device-management",
    "snowball",
    "sns",
    "socialmessaging",
    "sqs",
    "ssm",
    "ssm-contacts",
    "ssm-guiconnect",
    "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-instances",
    "workspaces-thin-client",
    "workspaces-web",
    "xray",
]

ResourceServiceName#

# ResourceServiceName usage example
from types_boto3_mediaconvert.literals import ResourceServiceName

def get_value() -> ResourceServiceName:
    return "cloudformation"
# ResourceServiceName definition
ResourceServiceName = Literal[
    "cloudformation",
    "cloudwatch",
    "dynamodb",
    "ec2",
    "glacier",
    "iam",
    "s3",
    "sns",
    "sqs",
]

PaginatorName#

# PaginatorName usage example
from types_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 types_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",
]