Type definitions#

Index > MediaConvert > Type definitions

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

PresetSettingsUnionTypeDef#

# PresetSettingsUnionTypeDef Union usage example

from mypy_boto3_mediaconvert.type_defs import PresetSettingsUnionTypeDef


def get_value() -> PresetSettingsUnionTypeDef:
    return ...


# PresetSettingsUnionTypeDef definition

PresetSettingsUnionTypeDef = Union[
    PresetSettingsTypeDef,  # (1)
    PresetSettingsOutputTypeDef,  # (2)
]

See PresetSettingsTypeDef
See PresetSettingsOutputTypeDef

JobSettingsUnionTypeDef#

# JobSettingsUnionTypeDef Union usage example

from mypy_boto3_mediaconvert.type_defs import JobSettingsUnionTypeDef


def get_value() -> JobSettingsUnionTypeDef:
    return ...


# JobSettingsUnionTypeDef definition

JobSettingsUnionTypeDef = Union[
    JobSettingsTypeDef,  # (1)
    JobSettingsOutputTypeDef,  # (2)
]

See JobSettingsTypeDef
See JobSettingsOutputTypeDef

JobTemplateSettingsUnionTypeDef#

# JobTemplateSettingsUnionTypeDef Union usage example

from mypy_boto3_mediaconvert.type_defs import JobTemplateSettingsUnionTypeDef


def get_value() -> JobTemplateSettingsUnionTypeDef:
    return ...


# JobTemplateSettingsUnionTypeDef definition

JobTemplateSettingsUnionTypeDef = Union[
    JobTemplateSettingsTypeDef,  # (1)
    JobTemplateSettingsOutputTypeDef,  # (2)
]

AacSettingsTypeDef#

# AacSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AacSettingsTypeDef


def get_value() -> AacSettingsTypeDef:
    return {
        "AudioDescriptionBroadcasterMix": ...,
    }


# AacSettingsTypeDef definition

class AacSettingsTypeDef(TypedDict):
    AudioDescriptionBroadcasterMix: NotRequired[AacAudioDescriptionBroadcasterMixType],  # (1)
    Bitrate: NotRequired[int],
    CodecProfile: NotRequired[AacCodecProfileType],  # (2)
    CodingMode: NotRequired[AacCodingModeType],  # (3)
    RateControlMode: NotRequired[AacRateControlModeType],  # (4)
    RawFormat: NotRequired[AacRawFormatType],  # (5)
    SampleRate: NotRequired[int],
    Specification: NotRequired[AacSpecificationType],  # (6)
    VbrQuality: NotRequired[AacVbrQualityType],  # (7)

See AacAudioDescriptionBroadcasterMixType
See AacCodecProfileType
See AacCodingModeType
See AacRateControlModeType
See AacRawFormatType
See AacSpecificationType
See AacVbrQualityType

Ac3SettingsTypeDef#

# Ac3SettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Ac3SettingsTypeDef


def get_value() -> Ac3SettingsTypeDef:
    return {
        "Bitrate": ...,
    }


# Ac3SettingsTypeDef definition

class Ac3SettingsTypeDef(TypedDict):
    Bitrate: NotRequired[int],
    BitstreamMode: NotRequired[Ac3BitstreamModeType],  # (1)
    CodingMode: NotRequired[Ac3CodingModeType],  # (2)
    Dialnorm: NotRequired[int],
    DynamicRangeCompressionLine: NotRequired[Ac3DynamicRangeCompressionLineType],  # (3)
    DynamicRangeCompressionProfile: NotRequired[Ac3DynamicRangeCompressionProfileType],  # (4)
    DynamicRangeCompressionRf: NotRequired[Ac3DynamicRangeCompressionRfType],  # (5)
    LfeFilter: NotRequired[Ac3LfeFilterType],  # (6)
    MetadataControl: NotRequired[Ac3MetadataControlType],  # (7)
    SampleRate: NotRequired[int],

See Ac3BitstreamModeType
See Ac3CodingModeType
See Ac3DynamicRangeCompressionLineType
See Ac3DynamicRangeCompressionProfileType
See Ac3DynamicRangeCompressionRfType
See Ac3LfeFilterType
See Ac3MetadataControlType

AccelerationSettingsTypeDef#

# AccelerationSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AccelerationSettingsTypeDef


def get_value() -> AccelerationSettingsTypeDef:
    return {
        "Mode": ...,
    }


# AccelerationSettingsTypeDef definition

class AccelerationSettingsTypeDef(TypedDict):
    Mode: AccelerationModeType,  # (1)

See AccelerationModeType

AdvancedInputFilterSettingsTypeDef#

# AdvancedInputFilterSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AdvancedInputFilterSettingsTypeDef


def get_value() -> AdvancedInputFilterSettingsTypeDef:
    return {
        "AddTexture": ...,
    }


# AdvancedInputFilterSettingsTypeDef definition

class AdvancedInputFilterSettingsTypeDef(TypedDict):
    AddTexture: NotRequired[AdvancedInputFilterAddTextureType],  # (1)
    Sharpening: NotRequired[AdvancedInputFilterSharpenType],  # (2)

AiffSettingsTypeDef#

# AiffSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AiffSettingsTypeDef


def get_value() -> AiffSettingsTypeDef:
    return {
        "BitDepth": ...,
    }


# AiffSettingsTypeDef definition

class AiffSettingsTypeDef(TypedDict):
    BitDepth: NotRequired[int],
    Channels: NotRequired[int],
    SampleRate: NotRequired[int],

AllowedRenditionSizeTypeDef#

# AllowedRenditionSizeTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AllowedRenditionSizeTypeDef


def get_value() -> AllowedRenditionSizeTypeDef:
    return {
        "Height": ...,
    }


# AllowedRenditionSizeTypeDef definition

class AllowedRenditionSizeTypeDef(TypedDict):
    Height: NotRequired[int],
    Required: NotRequired[RequiredFlagType],  # (1)
    Width: NotRequired[int],

See RequiredFlagType

AncillarySourceSettingsTypeDef#

# AncillarySourceSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AncillarySourceSettingsTypeDef


def get_value() -> AncillarySourceSettingsTypeDef:
    return {
        "Convert608To708": ...,
    }


# AncillarySourceSettingsTypeDef definition

class AncillarySourceSettingsTypeDef(TypedDict):
    Convert608To708: NotRequired[AncillaryConvert608To708Type],  # (1)
    SourceAncillaryChannelNumber: NotRequired[int],
    TerminateCaptions: NotRequired[AncillaryTerminateCaptionsType],  # (2)

AssociateCertificateRequestTypeDef#

# AssociateCertificateRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AssociateCertificateRequestTypeDef


def get_value() -> AssociateCertificateRequestTypeDef:
    return {
        "Arn": ...,
    }


# AssociateCertificateRequestTypeDef definition

class AssociateCertificateRequestTypeDef(TypedDict):
    Arn: str,

AudioChannelTaggingSettingsOutputTypeDef#

# AudioChannelTaggingSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AudioChannelTaggingSettingsOutputTypeDef


def get_value() -> AudioChannelTaggingSettingsOutputTypeDef:
    return {
        "ChannelTag": ...,
    }


# AudioChannelTaggingSettingsOutputTypeDef definition

class AudioChannelTaggingSettingsOutputTypeDef(TypedDict):
    ChannelTag: NotRequired[AudioChannelTagType],  # (1)
    ChannelTags: NotRequired[List[AudioChannelTagType]],  # (2)

See AudioChannelTagType
See List[AudioChannelTagType]

AudioChannelTaggingSettingsTypeDef#

# AudioChannelTaggingSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AudioChannelTaggingSettingsTypeDef


def get_value() -> AudioChannelTaggingSettingsTypeDef:
    return {
        "ChannelTag": ...,
    }


# AudioChannelTaggingSettingsTypeDef definition

class AudioChannelTaggingSettingsTypeDef(TypedDict):
    ChannelTag: NotRequired[AudioChannelTagType],  # (1)
    ChannelTags: NotRequired[Sequence[AudioChannelTagType]],  # (2)

See AudioChannelTagType
See Sequence[AudioChannelTagType]

Eac3AtmosSettingsTypeDef#

# Eac3AtmosSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Eac3AtmosSettingsTypeDef


def get_value() -> Eac3AtmosSettingsTypeDef:
    return {
        "Bitrate": ...,
    }


# Eac3AtmosSettingsTypeDef definition

class Eac3AtmosSettingsTypeDef(TypedDict):
    Bitrate: NotRequired[int],
    BitstreamMode: NotRequired[Eac3AtmosBitstreamModeType],  # (1)
    CodingMode: NotRequired[Eac3AtmosCodingModeType],  # (2)
    DialogueIntelligence: NotRequired[Eac3AtmosDialogueIntelligenceType],  # (3)
    DownmixControl: NotRequired[Eac3AtmosDownmixControlType],  # (4)
    DynamicRangeCompressionLine: NotRequired[Eac3AtmosDynamicRangeCompressionLineType],  # (5)
    DynamicRangeCompressionRf: NotRequired[Eac3AtmosDynamicRangeCompressionRfType],  # (6)
    DynamicRangeControl: NotRequired[Eac3AtmosDynamicRangeControlType],  # (7)
    LoRoCenterMixLevel: NotRequired[float],
    LoRoSurroundMixLevel: NotRequired[float],
    LtRtCenterMixLevel: NotRequired[float],
    LtRtSurroundMixLevel: NotRequired[float],
    MeteringMode: NotRequired[Eac3AtmosMeteringModeType],  # (8)
    SampleRate: NotRequired[int],
    SpeechThreshold: NotRequired[int],
    StereoDownmix: NotRequired[Eac3AtmosStereoDownmixType],  # (9)
    SurroundExMode: NotRequired[Eac3AtmosSurroundExModeType],  # (10)

See Eac3AtmosBitstreamModeType
See Eac3AtmosCodingModeType
See Eac3AtmosDialogueIntelligenceType
See Eac3AtmosDownmixControlType
See Eac3AtmosDynamicRangeCompressionLineType
See Eac3AtmosDynamicRangeCompressionRfType
See Eac3AtmosDynamicRangeControlType
See Eac3AtmosMeteringModeType
See Eac3AtmosStereoDownmixType
See Eac3AtmosSurroundExModeType

Eac3SettingsTypeDef#

# Eac3SettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Eac3SettingsTypeDef


def get_value() -> Eac3SettingsTypeDef:
    return {
        "AttenuationControl": ...,
    }


# Eac3SettingsTypeDef definition

class Eac3SettingsTypeDef(TypedDict):
    AttenuationControl: NotRequired[Eac3AttenuationControlType],  # (1)
    Bitrate: NotRequired[int],
    BitstreamMode: NotRequired[Eac3BitstreamModeType],  # (2)
    CodingMode: NotRequired[Eac3CodingModeType],  # (3)
    DcFilter: NotRequired[Eac3DcFilterType],  # (4)
    Dialnorm: NotRequired[int],
    DynamicRangeCompressionLine: NotRequired[Eac3DynamicRangeCompressionLineType],  # (5)
    DynamicRangeCompressionRf: NotRequired[Eac3DynamicRangeCompressionRfType],  # (6)
    LfeControl: NotRequired[Eac3LfeControlType],  # (7)
    LfeFilter: NotRequired[Eac3LfeFilterType],  # (8)
    LoRoCenterMixLevel: NotRequired[float],
    LoRoSurroundMixLevel: NotRequired[float],
    LtRtCenterMixLevel: NotRequired[float],
    LtRtSurroundMixLevel: NotRequired[float],
    MetadataControl: NotRequired[Eac3MetadataControlType],  # (9)
    PassthroughControl: NotRequired[Eac3PassthroughControlType],  # (10)
    PhaseControl: NotRequired[Eac3PhaseControlType],  # (11)
    SampleRate: NotRequired[int],
    StereoDownmix: NotRequired[Eac3StereoDownmixType],  # (12)
    SurroundExMode: NotRequired[Eac3SurroundExModeType],  # (13)
    SurroundMode: NotRequired[Eac3SurroundModeType],  # (14)

FlacSettingsTypeDef#

# FlacSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import FlacSettingsTypeDef


def get_value() -> FlacSettingsTypeDef:
    return {
        "BitDepth": ...,
    }


# FlacSettingsTypeDef definition

class FlacSettingsTypeDef(TypedDict):
    BitDepth: NotRequired[int],
    Channels: NotRequired[int],
    SampleRate: NotRequired[int],

Mp2SettingsTypeDef#

# Mp2SettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Mp2SettingsTypeDef


def get_value() -> Mp2SettingsTypeDef:
    return {
        "Bitrate": ...,
    }


# Mp2SettingsTypeDef definition

class Mp2SettingsTypeDef(TypedDict):
    Bitrate: NotRequired[int],
    Channels: NotRequired[int],
    SampleRate: NotRequired[int],

Mp3SettingsTypeDef#

# Mp3SettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Mp3SettingsTypeDef


def get_value() -> Mp3SettingsTypeDef:
    return {
        "Bitrate": ...,
    }


# Mp3SettingsTypeDef definition

class Mp3SettingsTypeDef(TypedDict):
    Bitrate: NotRequired[int],
    Channels: NotRequired[int],
    RateControlMode: NotRequired[Mp3RateControlModeType],  # (1)
    SampleRate: NotRequired[int],
    VbrQuality: NotRequired[int],

See Mp3RateControlModeType

OpusSettingsTypeDef#

# OpusSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import OpusSettingsTypeDef


def get_value() -> OpusSettingsTypeDef:
    return {
        "Bitrate": ...,
    }


# OpusSettingsTypeDef definition

class OpusSettingsTypeDef(TypedDict):
    Bitrate: NotRequired[int],
    Channels: NotRequired[int],
    SampleRate: NotRequired[int],

VorbisSettingsTypeDef#

# VorbisSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import VorbisSettingsTypeDef


def get_value() -> VorbisSettingsTypeDef:
    return {
        "Channels": ...,
    }


# VorbisSettingsTypeDef definition

class VorbisSettingsTypeDef(TypedDict):
    Channels: NotRequired[int],
    SampleRate: NotRequired[int],
    VbrQuality: NotRequired[int],

WavSettingsTypeDef#

# WavSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import WavSettingsTypeDef


def get_value() -> WavSettingsTypeDef:
    return {
        "BitDepth": ...,
    }


# WavSettingsTypeDef definition

class WavSettingsTypeDef(TypedDict):
    BitDepth: NotRequired[int],
    Channels: NotRequired[int],
    Format: NotRequired[WavFormatType],  # (1)
    SampleRate: NotRequired[int],

See WavFormatType

AudioNormalizationSettingsTypeDef#

# AudioNormalizationSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AudioNormalizationSettingsTypeDef


def get_value() -> AudioNormalizationSettingsTypeDef:
    return {
        "Algorithm": ...,
    }


# AudioNormalizationSettingsTypeDef definition

class AudioNormalizationSettingsTypeDef(TypedDict):
    Algorithm: NotRequired[AudioNormalizationAlgorithmType],  # (1)
    AlgorithmControl: NotRequired[AudioNormalizationAlgorithmControlType],  # (2)
    CorrectionGateLevel: NotRequired[int],
    LoudnessLogging: NotRequired[AudioNormalizationLoudnessLoggingType],  # (3)
    PeakCalculation: NotRequired[AudioNormalizationPeakCalculationType],  # (4)
    TargetLkfs: NotRequired[float],
    TruePeakLimiterThreshold: NotRequired[float],

FrameRateTypeDef#

# FrameRateTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import FrameRateTypeDef


def get_value() -> FrameRateTypeDef:
    return {
        "Denominator": ...,
    }


# FrameRateTypeDef definition

class FrameRateTypeDef(TypedDict):
    Denominator: NotRequired[int],
    Numerator: NotRequired[int],

AudioSelectorGroupOutputTypeDef#

# AudioSelectorGroupOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AudioSelectorGroupOutputTypeDef


def get_value() -> AudioSelectorGroupOutputTypeDef:
    return {
        "AudioSelectorNames": ...,
    }


# AudioSelectorGroupOutputTypeDef definition

class AudioSelectorGroupOutputTypeDef(TypedDict):
    AudioSelectorNames: NotRequired[List[str]],

AudioSelectorGroupTypeDef#

# AudioSelectorGroupTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AudioSelectorGroupTypeDef


def get_value() -> AudioSelectorGroupTypeDef:
    return {
        "AudioSelectorNames": ...,
    }


# AudioSelectorGroupTypeDef definition

class AudioSelectorGroupTypeDef(TypedDict):
    AudioSelectorNames: NotRequired[Sequence[str]],

HlsRenditionGroupSettingsTypeDef#

# HlsRenditionGroupSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import HlsRenditionGroupSettingsTypeDef


def get_value() -> HlsRenditionGroupSettingsTypeDef:
    return {
        "RenditionGroupId": ...,
    }


# HlsRenditionGroupSettingsTypeDef definition

class HlsRenditionGroupSettingsTypeDef(TypedDict):
    RenditionGroupId: NotRequired[str],
    RenditionLanguageCode: NotRequired[LanguageCodeType],  # (1)
    RenditionName: NotRequired[str],

See LanguageCodeType

ForceIncludeRenditionSizeTypeDef#

# ForceIncludeRenditionSizeTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ForceIncludeRenditionSizeTypeDef


def get_value() -> ForceIncludeRenditionSizeTypeDef:
    return {
        "Height": ...,
    }


# ForceIncludeRenditionSizeTypeDef definition

class ForceIncludeRenditionSizeTypeDef(TypedDict):
    Height: NotRequired[int],
    Width: NotRequired[int],

MinBottomRenditionSizeTypeDef#

# MinBottomRenditionSizeTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import MinBottomRenditionSizeTypeDef


def get_value() -> MinBottomRenditionSizeTypeDef:
    return {
        "Height": ...,
    }


# MinBottomRenditionSizeTypeDef definition

class MinBottomRenditionSizeTypeDef(TypedDict):
    Height: NotRequired[int],
    Width: NotRequired[int],

MinTopRenditionSizeTypeDef#

# MinTopRenditionSizeTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import MinTopRenditionSizeTypeDef


def get_value() -> MinTopRenditionSizeTypeDef:
    return {
        "Height": ...,
    }


# MinTopRenditionSizeTypeDef definition

class MinTopRenditionSizeTypeDef(TypedDict):
    Height: NotRequired[int],
    Width: NotRequired[int],

Av1QvbrSettingsTypeDef#

# Av1QvbrSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Av1QvbrSettingsTypeDef


def get_value() -> Av1QvbrSettingsTypeDef:
    return {
        "QvbrQualityLevel": ...,
    }


# Av1QvbrSettingsTypeDef definition

class Av1QvbrSettingsTypeDef(TypedDict):
    QvbrQualityLevel: NotRequired[int],
    QvbrQualityLevelFineTune: NotRequired[float],

AvailBlankingTypeDef#

# AvailBlankingTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AvailBlankingTypeDef


def get_value() -> AvailBlankingTypeDef:
    return {
        "AvailBlankingImage": ...,
    }


# AvailBlankingTypeDef definition

class AvailBlankingTypeDef(TypedDict):
    AvailBlankingImage: NotRequired[str],

AvcIntraUhdSettingsTypeDef#

# AvcIntraUhdSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AvcIntraUhdSettingsTypeDef


def get_value() -> AvcIntraUhdSettingsTypeDef:
    return {
        "QualityTuningLevel": ...,
    }


# AvcIntraUhdSettingsTypeDef definition

class AvcIntraUhdSettingsTypeDef(TypedDict):
    QualityTuningLevel: NotRequired[AvcIntraUhdQualityTuningLevelType],  # (1)

See AvcIntraUhdQualityTuningLevelType

BandwidthReductionFilterTypeDef#

# BandwidthReductionFilterTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import BandwidthReductionFilterTypeDef


def get_value() -> BandwidthReductionFilterTypeDef:
    return {
        "Sharpening": ...,
    }


# BandwidthReductionFilterTypeDef definition

class BandwidthReductionFilterTypeDef(TypedDict):
    Sharpening: NotRequired[BandwidthReductionFilterSharpeningType],  # (1)
    Strength: NotRequired[BandwidthReductionFilterStrengthType],  # (2)

BurninDestinationSettingsTypeDef#

# BurninDestinationSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import BurninDestinationSettingsTypeDef


def get_value() -> BurninDestinationSettingsTypeDef:
    return {
        "Alignment": ...,
    }


# BurninDestinationSettingsTypeDef definition

class BurninDestinationSettingsTypeDef(TypedDict):
    Alignment: NotRequired[BurninSubtitleAlignmentType],  # (1)
    ApplyFontColor: NotRequired[BurninSubtitleApplyFontColorType],  # (2)
    BackgroundColor: NotRequired[BurninSubtitleBackgroundColorType],  # (3)
    BackgroundOpacity: NotRequired[int],
    FallbackFont: NotRequired[BurninSubtitleFallbackFontType],  # (4)
    FontColor: NotRequired[BurninSubtitleFontColorType],  # (5)
    FontFileBold: NotRequired[str],
    FontFileBoldItalic: NotRequired[str],
    FontFileItalic: NotRequired[str],
    FontFileRegular: NotRequired[str],
    FontOpacity: NotRequired[int],
    FontResolution: NotRequired[int],
    FontScript: NotRequired[FontScriptType],  # (6)
    FontSize: NotRequired[int],
    HexFontColor: NotRequired[str],
    OutlineColor: NotRequired[BurninSubtitleOutlineColorType],  # (7)
    OutlineSize: NotRequired[int],
    RemoveRubyReserveAttributes: NotRequired[RemoveRubyReserveAttributesType],  # (8)
    ShadowColor: NotRequired[BurninSubtitleShadowColorType],  # (9)
    ShadowOpacity: NotRequired[int],
    ShadowXOffset: NotRequired[int],
    ShadowYOffset: NotRequired[int],
    StylePassthrough: NotRequired[BurnInSubtitleStylePassthroughType],  # (10)
    TeletextSpacing: NotRequired[BurninSubtitleTeletextSpacingType],  # (11)
    XPosition: NotRequired[int],
    YPosition: NotRequired[int],

CancelJobRequestTypeDef#

# CancelJobRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CancelJobRequestTypeDef


def get_value() -> CancelJobRequestTypeDef:
    return {
        "Id": ...,
    }


# CancelJobRequestTypeDef definition

class CancelJobRequestTypeDef(TypedDict):
    Id: str,

DvbSubDestinationSettingsTypeDef#

# DvbSubDestinationSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DvbSubDestinationSettingsTypeDef


def get_value() -> DvbSubDestinationSettingsTypeDef:
    return {
        "Alignment": ...,
    }


# DvbSubDestinationSettingsTypeDef definition

class DvbSubDestinationSettingsTypeDef(TypedDict):
    Alignment: NotRequired[DvbSubtitleAlignmentType],  # (1)
    ApplyFontColor: NotRequired[DvbSubtitleApplyFontColorType],  # (2)
    BackgroundColor: NotRequired[DvbSubtitleBackgroundColorType],  # (3)
    BackgroundOpacity: NotRequired[int],
    DdsHandling: NotRequired[DvbddsHandlingType],  # (4)
    DdsXCoordinate: NotRequired[int],
    DdsYCoordinate: NotRequired[int],
    FallbackFont: NotRequired[DvbSubSubtitleFallbackFontType],  # (5)
    FontColor: NotRequired[DvbSubtitleFontColorType],  # (6)
    FontFileBold: NotRequired[str],
    FontFileBoldItalic: NotRequired[str],
    FontFileItalic: NotRequired[str],
    FontFileRegular: NotRequired[str],
    FontOpacity: NotRequired[int],
    FontResolution: NotRequired[int],
    FontScript: NotRequired[FontScriptType],  # (7)
    FontSize: NotRequired[int],
    Height: NotRequired[int],
    HexFontColor: NotRequired[str],
    OutlineColor: NotRequired[DvbSubtitleOutlineColorType],  # (8)
    OutlineSize: NotRequired[int],
    ShadowColor: NotRequired[DvbSubtitleShadowColorType],  # (9)
    ShadowOpacity: NotRequired[int],
    ShadowXOffset: NotRequired[int],
    ShadowYOffset: NotRequired[int],
    StylePassthrough: NotRequired[DvbSubtitleStylePassthroughType],  # (10)
    SubtitlingType: NotRequired[DvbSubtitlingTypeType],  # (11)
    TeletextSpacing: NotRequired[DvbSubtitleTeletextSpacingType],  # (12)
    Width: NotRequired[int],
    XPosition: NotRequired[int],
    YPosition: NotRequired[int],

EmbeddedDestinationSettingsTypeDef#

# EmbeddedDestinationSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import EmbeddedDestinationSettingsTypeDef


def get_value() -> EmbeddedDestinationSettingsTypeDef:
    return {
        "Destination608ChannelNumber": ...,
    }


# EmbeddedDestinationSettingsTypeDef definition

class EmbeddedDestinationSettingsTypeDef(TypedDict):
    Destination608ChannelNumber: NotRequired[int],
    Destination708ServiceNumber: NotRequired[int],

ImscDestinationSettingsTypeDef#

# ImscDestinationSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ImscDestinationSettingsTypeDef


def get_value() -> ImscDestinationSettingsTypeDef:
    return {
        "Accessibility": ...,
    }


# ImscDestinationSettingsTypeDef definition

class ImscDestinationSettingsTypeDef(TypedDict):
    Accessibility: NotRequired[ImscAccessibilitySubsType],  # (1)
    StylePassthrough: NotRequired[ImscStylePassthroughType],  # (2)

See ImscAccessibilitySubsType
See ImscStylePassthroughType

SccDestinationSettingsTypeDef#

# SccDestinationSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import SccDestinationSettingsTypeDef


def get_value() -> SccDestinationSettingsTypeDef:
    return {
        "Framerate": ...,
    }


# SccDestinationSettingsTypeDef definition

class SccDestinationSettingsTypeDef(TypedDict):
    Framerate: NotRequired[SccDestinationFramerateType],  # (1)

See SccDestinationFramerateType

SrtDestinationSettingsTypeDef#

# SrtDestinationSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import SrtDestinationSettingsTypeDef


def get_value() -> SrtDestinationSettingsTypeDef:
    return {
        "StylePassthrough": ...,
    }


# SrtDestinationSettingsTypeDef definition

class SrtDestinationSettingsTypeDef(TypedDict):
    StylePassthrough: NotRequired[SrtStylePassthroughType],  # (1)

See SrtStylePassthroughType

TeletextDestinationSettingsOutputTypeDef#

# TeletextDestinationSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import TeletextDestinationSettingsOutputTypeDef


def get_value() -> TeletextDestinationSettingsOutputTypeDef:
    return {
        "PageNumber": ...,
    }


# TeletextDestinationSettingsOutputTypeDef definition

class TeletextDestinationSettingsOutputTypeDef(TypedDict):
    PageNumber: NotRequired[str],
    PageTypes: NotRequired[List[TeletextPageTypeType]],  # (1)

See List[TeletextPageTypeType]

TtmlDestinationSettingsTypeDef#

# TtmlDestinationSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import TtmlDestinationSettingsTypeDef


def get_value() -> TtmlDestinationSettingsTypeDef:
    return {
        "StylePassthrough": ...,
    }


# TtmlDestinationSettingsTypeDef definition

class TtmlDestinationSettingsTypeDef(TypedDict):
    StylePassthrough: NotRequired[TtmlStylePassthroughType],  # (1)

See TtmlStylePassthroughType

WebvttDestinationSettingsTypeDef#

# WebvttDestinationSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import WebvttDestinationSettingsTypeDef


def get_value() -> WebvttDestinationSettingsTypeDef:
    return {
        "Accessibility": ...,
    }


# WebvttDestinationSettingsTypeDef definition

class WebvttDestinationSettingsTypeDef(TypedDict):
    Accessibility: NotRequired[WebvttAccessibilitySubsType],  # (1)
    StylePassthrough: NotRequired[WebvttStylePassthroughType],  # (2)

See WebvttAccessibilitySubsType
See WebvttStylePassthroughType

TeletextDestinationSettingsTypeDef#

# TeletextDestinationSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import TeletextDestinationSettingsTypeDef


def get_value() -> TeletextDestinationSettingsTypeDef:
    return {
        "PageNumber": ...,
    }


# TeletextDestinationSettingsTypeDef definition

class TeletextDestinationSettingsTypeDef(TypedDict):
    PageNumber: NotRequired[str],
    PageTypes: NotRequired[Sequence[TeletextPageTypeType]],  # (1)

See Sequence[TeletextPageTypeType]

CaptionSourceFramerateTypeDef#

# CaptionSourceFramerateTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CaptionSourceFramerateTypeDef


def get_value() -> CaptionSourceFramerateTypeDef:
    return {
        "FramerateDenominator": ...,
    }


# CaptionSourceFramerateTypeDef definition

class CaptionSourceFramerateTypeDef(TypedDict):
    FramerateDenominator: NotRequired[int],
    FramerateNumerator: NotRequired[int],

DvbSubSourceSettingsTypeDef#

# DvbSubSourceSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DvbSubSourceSettingsTypeDef


def get_value() -> DvbSubSourceSettingsTypeDef:
    return {
        "Pid": ...,
    }


# DvbSubSourceSettingsTypeDef definition

class DvbSubSourceSettingsTypeDef(TypedDict):
    Pid: NotRequired[int],

EmbeddedSourceSettingsTypeDef#

# EmbeddedSourceSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import EmbeddedSourceSettingsTypeDef


def get_value() -> EmbeddedSourceSettingsTypeDef:
    return {
        "Convert608To708": ...,
    }


# EmbeddedSourceSettingsTypeDef definition

class EmbeddedSourceSettingsTypeDef(TypedDict):
    Convert608To708: NotRequired[EmbeddedConvert608To708Type],  # (1)
    Source608ChannelNumber: NotRequired[int],
    Source608TrackNumber: NotRequired[int],
    TerminateCaptions: NotRequired[EmbeddedTerminateCaptionsType],  # (2)

See EmbeddedConvert608To708Type
See EmbeddedTerminateCaptionsType

TeletextSourceSettingsTypeDef#

# TeletextSourceSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import TeletextSourceSettingsTypeDef


def get_value() -> TeletextSourceSettingsTypeDef:
    return {
        "PageNumber": ...,
    }


# TeletextSourceSettingsTypeDef definition

class TeletextSourceSettingsTypeDef(TypedDict):
    PageNumber: NotRequired[str],

TrackSourceSettingsTypeDef#

# TrackSourceSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import TrackSourceSettingsTypeDef


def get_value() -> TrackSourceSettingsTypeDef:
    return {
        "TrackNumber": ...,
    }


# TrackSourceSettingsTypeDef definition

class TrackSourceSettingsTypeDef(TypedDict):
    TrackNumber: NotRequired[int],

WebvttHlsSourceSettingsTypeDef#

# WebvttHlsSourceSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import WebvttHlsSourceSettingsTypeDef


def get_value() -> WebvttHlsSourceSettingsTypeDef:
    return {
        "RenditionGroupId": ...,
    }


# WebvttHlsSourceSettingsTypeDef definition

class WebvttHlsSourceSettingsTypeDef(TypedDict):
    RenditionGroupId: NotRequired[str],
    RenditionLanguageCode: NotRequired[LanguageCodeType],  # (1)
    RenditionName: NotRequired[str],

See LanguageCodeType

OutputChannelMappingOutputTypeDef#

# OutputChannelMappingOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import OutputChannelMappingOutputTypeDef


def get_value() -> OutputChannelMappingOutputTypeDef:
    return {
        "InputChannels": ...,
    }


# OutputChannelMappingOutputTypeDef definition

class OutputChannelMappingOutputTypeDef(TypedDict):
    InputChannels: NotRequired[List[int]],
    InputChannelsFineTune: NotRequired[List[float]],

OutputChannelMappingTypeDef#

# OutputChannelMappingTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import OutputChannelMappingTypeDef


def get_value() -> OutputChannelMappingTypeDef:
    return {
        "InputChannels": ...,
    }


# OutputChannelMappingTypeDef definition

class OutputChannelMappingTypeDef(TypedDict):
    InputChannels: NotRequired[Sequence[int]],
    InputChannelsFineTune: NotRequired[Sequence[float]],

ClipLimitsTypeDef#

# ClipLimitsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ClipLimitsTypeDef


def get_value() -> ClipLimitsTypeDef:
    return {
        "MaximumRGBTolerance": ...,
    }


# ClipLimitsTypeDef definition

class ClipLimitsTypeDef(TypedDict):
    MaximumRGBTolerance: NotRequired[int],
    MaximumYUV: NotRequired[int],
    MinimumRGBTolerance: NotRequired[int],
    MinimumYUV: NotRequired[int],

CmafAdditionalManifestOutputTypeDef#

# CmafAdditionalManifestOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CmafAdditionalManifestOutputTypeDef


def get_value() -> CmafAdditionalManifestOutputTypeDef:
    return {
        "ManifestNameModifier": ...,
    }


# CmafAdditionalManifestOutputTypeDef definition

class CmafAdditionalManifestOutputTypeDef(TypedDict):
    ManifestNameModifier: NotRequired[str],
    SelectedOutputs: NotRequired[List[str]],

CmafAdditionalManifestTypeDef#

# CmafAdditionalManifestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CmafAdditionalManifestTypeDef


def get_value() -> CmafAdditionalManifestTypeDef:
    return {
        "ManifestNameModifier": ...,
    }


# CmafAdditionalManifestTypeDef definition

class CmafAdditionalManifestTypeDef(TypedDict):
    ManifestNameModifier: NotRequired[str],
    SelectedOutputs: NotRequired[Sequence[str]],

StaticKeyProviderTypeDef#

# StaticKeyProviderTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import StaticKeyProviderTypeDef


def get_value() -> StaticKeyProviderTypeDef:
    return {
        "KeyFormat": ...,
    }


# StaticKeyProviderTypeDef definition

class StaticKeyProviderTypeDef(TypedDict):
    KeyFormat: NotRequired[str],
    KeyFormatVersions: NotRequired[str],
    StaticKeyValue: NotRequired[str],
    Url: NotRequired[str],

CmafImageBasedTrickPlaySettingsTypeDef#

# CmafImageBasedTrickPlaySettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CmafImageBasedTrickPlaySettingsTypeDef


def get_value() -> CmafImageBasedTrickPlaySettingsTypeDef:
    return {
        "IntervalCadence": ...,
    }


# CmafImageBasedTrickPlaySettingsTypeDef definition

class CmafImageBasedTrickPlaySettingsTypeDef(TypedDict):
    IntervalCadence: NotRequired[CmafIntervalCadenceType],  # (1)
    ThumbnailHeight: NotRequired[int],
    ThumbnailInterval: NotRequired[float],
    ThumbnailWidth: NotRequired[int],
    TileHeight: NotRequired[int],
    TileWidth: NotRequired[int],

See CmafIntervalCadenceType

CmfcSettingsTypeDef#

# CmfcSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CmfcSettingsTypeDef


def get_value() -> CmfcSettingsTypeDef:
    return {
        "AudioDuration": ...,
    }


# CmfcSettingsTypeDef definition

class CmfcSettingsTypeDef(TypedDict):
    AudioDuration: NotRequired[CmfcAudioDurationType],  # (1)
    AudioGroupId: NotRequired[str],
    AudioRenditionSets: NotRequired[str],
    AudioTrackType: NotRequired[CmfcAudioTrackTypeType],  # (2)
    DescriptiveVideoServiceFlag: NotRequired[CmfcDescriptiveVideoServiceFlagType],  # (3)
    IFrameOnlyManifest: NotRequired[CmfcIFrameOnlyManifestType],  # (4)
    KlvMetadata: NotRequired[CmfcKlvMetadataType],  # (5)
    ManifestMetadataSignaling: NotRequired[CmfcManifestMetadataSignalingType],  # (6)
    Scte35Esam: NotRequired[CmfcScte35EsamType],  # (7)
    Scte35Source: NotRequired[CmfcScte35SourceType],  # (8)
    TimedMetadata: NotRequired[CmfcTimedMetadataType],  # (9)
    TimedMetadataBoxVersion: NotRequired[CmfcTimedMetadataBoxVersionType],  # (10)
    TimedMetadataSchemeIdUri: NotRequired[str],
    TimedMetadataValue: NotRequired[str],

ColorConversion3DLUTSettingTypeDef#

# ColorConversion3DLUTSettingTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ColorConversion3DLUTSettingTypeDef


def get_value() -> ColorConversion3DLUTSettingTypeDef:
    return {
        "FileInput": ...,
    }


# ColorConversion3DLUTSettingTypeDef definition

class ColorConversion3DLUTSettingTypeDef(TypedDict):
    FileInput: NotRequired[str],
    InputColorSpace: NotRequired[ColorSpaceType],  # (1)
    InputMasteringLuminance: NotRequired[int],
    OutputColorSpace: NotRequired[ColorSpaceType],  # (1)
    OutputMasteringLuminance: NotRequired[int],

See ColorSpaceType
See ColorSpaceType

Hdr10MetadataTypeDef#

# Hdr10MetadataTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Hdr10MetadataTypeDef


def get_value() -> Hdr10MetadataTypeDef:
    return {
        "BluePrimaryX": ...,
    }


# Hdr10MetadataTypeDef definition

class Hdr10MetadataTypeDef(TypedDict):
    BluePrimaryX: NotRequired[int],
    BluePrimaryY: NotRequired[int],
    GreenPrimaryX: NotRequired[int],
    GreenPrimaryY: NotRequired[int],
    MaxContentLightLevel: NotRequired[int],
    MaxFrameAverageLightLevel: NotRequired[int],
    MaxLuminance: NotRequired[int],
    MinLuminance: NotRequired[int],
    RedPrimaryX: NotRequired[int],
    RedPrimaryY: NotRequired[int],
    WhitePointX: NotRequired[int],
    WhitePointY: NotRequired[int],

F4vSettingsTypeDef#

# F4vSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import F4vSettingsTypeDef


def get_value() -> F4vSettingsTypeDef:
    return {
        "MoovPlacement": ...,
    }


# F4vSettingsTypeDef definition

class F4vSettingsTypeDef(TypedDict):
    MoovPlacement: NotRequired[F4vMoovPlacementType],  # (1)

See F4vMoovPlacementType

M3u8SettingsOutputTypeDef#

# M3u8SettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import M3u8SettingsOutputTypeDef


def get_value() -> M3u8SettingsOutputTypeDef:
    return {
        "AudioDuration": ...,
    }


# M3u8SettingsOutputTypeDef definition

class M3u8SettingsOutputTypeDef(TypedDict):
    AudioDuration: NotRequired[M3u8AudioDurationType],  # (1)
    AudioFramesPerPes: NotRequired[int],
    AudioPids: NotRequired[List[int]],
    AudioPtsOffsetDelta: NotRequired[int],
    DataPTSControl: NotRequired[M3u8DataPtsControlType],  # (2)
    MaxPcrInterval: NotRequired[int],
    NielsenId3: NotRequired[M3u8NielsenId3Type],  # (3)
    PatInterval: NotRequired[int],
    PcrControl: NotRequired[M3u8PcrControlType],  # (4)
    PcrPid: NotRequired[int],
    PmtInterval: NotRequired[int],
    PmtPid: NotRequired[int],
    PrivateMetadataPid: NotRequired[int],
    ProgramNumber: NotRequired[int],
    PtsOffset: NotRequired[int],
    PtsOffsetMode: NotRequired[TsPtsOffsetType],  # (5)
    Scte35Pid: NotRequired[int],
    Scte35Source: NotRequired[M3u8Scte35SourceType],  # (6)
    TimedMetadata: NotRequired[TimedMetadataType],  # (7)
    TimedMetadataPid: NotRequired[int],
    TransportStreamId: NotRequired[int],
    VideoPid: NotRequired[int],

MovSettingsTypeDef#

# MovSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import MovSettingsTypeDef


def get_value() -> MovSettingsTypeDef:
    return {
        "ClapAtom": ...,
    }


# MovSettingsTypeDef definition

class MovSettingsTypeDef(TypedDict):
    ClapAtom: NotRequired[MovClapAtomType],  # (1)
    CslgAtom: NotRequired[MovCslgAtomType],  # (2)
    Mpeg2FourCCControl: NotRequired[MovMpeg2FourCCControlType],  # (3)
    PaddingControl: NotRequired[MovPaddingControlType],  # (4)
    Reference: NotRequired[MovReferenceType],  # (5)

Mp4SettingsTypeDef#

# Mp4SettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Mp4SettingsTypeDef


def get_value() -> Mp4SettingsTypeDef:
    return {
        "AudioDuration": ...,
    }


# Mp4SettingsTypeDef definition

class Mp4SettingsTypeDef(TypedDict):
    AudioDuration: NotRequired[CmfcAudioDurationType],  # (1)
    CslgAtom: NotRequired[Mp4CslgAtomType],  # (2)
    CttsVersion: NotRequired[int],
    FreeSpaceBox: NotRequired[Mp4FreeSpaceBoxType],  # (3)
    MoovPlacement: NotRequired[Mp4MoovPlacementType],  # (4)
    Mp4MajorBrand: NotRequired[str],

MpdSettingsTypeDef#

# MpdSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import MpdSettingsTypeDef


def get_value() -> MpdSettingsTypeDef:
    return {
        "AccessibilityCaptionHints": ...,
    }


# MpdSettingsTypeDef definition

class MpdSettingsTypeDef(TypedDict):
    AccessibilityCaptionHints: NotRequired[MpdAccessibilityCaptionHintsType],  # (1)
    AudioDuration: NotRequired[MpdAudioDurationType],  # (2)
    CaptionContainerType: NotRequired[MpdCaptionContainerTypeType],  # (3)
    KlvMetadata: NotRequired[MpdKlvMetadataType],  # (4)
    ManifestMetadataSignaling: NotRequired[MpdManifestMetadataSignalingType],  # (5)
    Scte35Esam: NotRequired[MpdScte35EsamType],  # (6)
    Scte35Source: NotRequired[MpdScte35SourceType],  # (7)
    TimedMetadata: NotRequired[MpdTimedMetadataType],  # (8)
    TimedMetadataBoxVersion: NotRequired[MpdTimedMetadataBoxVersionType],  # (9)
    TimedMetadataSchemeIdUri: NotRequired[str],
    TimedMetadataValue: NotRequired[str],

M3u8SettingsTypeDef#

# M3u8SettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import M3u8SettingsTypeDef


def get_value() -> M3u8SettingsTypeDef:
    return {
        "AudioDuration": ...,
    }


# M3u8SettingsTypeDef definition

class M3u8SettingsTypeDef(TypedDict):
    AudioDuration: NotRequired[M3u8AudioDurationType],  # (1)
    AudioFramesPerPes: NotRequired[int],
    AudioPids: NotRequired[Sequence[int]],
    AudioPtsOffsetDelta: NotRequired[int],
    DataPTSControl: NotRequired[M3u8DataPtsControlType],  # (2)
    MaxPcrInterval: NotRequired[int],
    NielsenId3: NotRequired[M3u8NielsenId3Type],  # (3)
    PatInterval: NotRequired[int],
    PcrControl: NotRequired[M3u8PcrControlType],  # (4)
    PcrPid: NotRequired[int],
    PmtInterval: NotRequired[int],
    PmtPid: NotRequired[int],
    PrivateMetadataPid: NotRequired[int],
    ProgramNumber: NotRequired[int],
    PtsOffset: NotRequired[int],
    PtsOffsetMode: NotRequired[TsPtsOffsetType],  # (5)
    Scte35Pid: NotRequired[int],
    Scte35Source: NotRequired[M3u8Scte35SourceType],  # (6)
    TimedMetadata: NotRequired[TimedMetadataType],  # (7)
    TimedMetadataPid: NotRequired[int],
    TransportStreamId: NotRequired[int],
    VideoPid: NotRequired[int],

HopDestinationTypeDef#

# HopDestinationTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import HopDestinationTypeDef


def get_value() -> HopDestinationTypeDef:
    return {
        "Priority": ...,
    }


# HopDestinationTypeDef definition

class HopDestinationTypeDef(TypedDict):
    Priority: NotRequired[int],
    Queue: NotRequired[str],
    WaitMinutes: NotRequired[int],

ResponseMetadataTypeDef#

# ResponseMetadataTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ResponseMetadataTypeDef


def get_value() -> ResponseMetadataTypeDef:
    return {
        "RequestId": ...,
    }


# ResponseMetadataTypeDef definition

class ResponseMetadataTypeDef(TypedDict):
    RequestId: str,
    HTTPStatusCode: int,
    HTTPHeaders: Dict[str, str],
    RetryAttempts: int,
    HostId: NotRequired[str],

ReservationPlanSettingsTypeDef#

# ReservationPlanSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ReservationPlanSettingsTypeDef


def get_value() -> ReservationPlanSettingsTypeDef:
    return {
        "Commitment": ...,
    }


# ReservationPlanSettingsTypeDef definition

class ReservationPlanSettingsTypeDef(TypedDict):
    Commitment: CommitmentType,  # (1)
    RenewalType: RenewalTypeType,  # (2)
    ReservedSlots: int,

See CommitmentType
See RenewalTypeType

DashAdditionalManifestOutputTypeDef#

# DashAdditionalManifestOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DashAdditionalManifestOutputTypeDef


def get_value() -> DashAdditionalManifestOutputTypeDef:
    return {
        "ManifestNameModifier": ...,
    }


# DashAdditionalManifestOutputTypeDef definition

class DashAdditionalManifestOutputTypeDef(TypedDict):
    ManifestNameModifier: NotRequired[str],
    SelectedOutputs: NotRequired[List[str]],

DashAdditionalManifestTypeDef#

# DashAdditionalManifestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DashAdditionalManifestTypeDef


def get_value() -> DashAdditionalManifestTypeDef:
    return {
        "ManifestNameModifier": ...,
    }


# DashAdditionalManifestTypeDef definition

class DashAdditionalManifestTypeDef(TypedDict):
    ManifestNameModifier: NotRequired[str],
    SelectedOutputs: NotRequired[Sequence[str]],

DashIsoImageBasedTrickPlaySettingsTypeDef#

# DashIsoImageBasedTrickPlaySettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DashIsoImageBasedTrickPlaySettingsTypeDef


def get_value() -> DashIsoImageBasedTrickPlaySettingsTypeDef:
    return {
        "IntervalCadence": ...,
    }


# DashIsoImageBasedTrickPlaySettingsTypeDef definition

class DashIsoImageBasedTrickPlaySettingsTypeDef(TypedDict):
    IntervalCadence: NotRequired[DashIsoIntervalCadenceType],  # (1)
    ThumbnailHeight: NotRequired[int],
    ThumbnailInterval: NotRequired[float],
    ThumbnailWidth: NotRequired[int],
    TileHeight: NotRequired[int],
    TileWidth: NotRequired[int],

See DashIsoIntervalCadenceType

DataPropertiesTypeDef#

# DataPropertiesTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DataPropertiesTypeDef


def get_value() -> DataPropertiesTypeDef:
    return {
        "LanguageCode": ...,
    }


# DataPropertiesTypeDef definition

class DataPropertiesTypeDef(TypedDict):
    LanguageCode: NotRequired[str],

DeinterlacerTypeDef#

# DeinterlacerTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DeinterlacerTypeDef


def get_value() -> DeinterlacerTypeDef:
    return {
        "Algorithm": ...,
    }


# DeinterlacerTypeDef definition

class DeinterlacerTypeDef(TypedDict):
    Algorithm: NotRequired[DeinterlaceAlgorithmType],  # (1)
    Control: NotRequired[DeinterlacerControlType],  # (2)
    Mode: NotRequired[DeinterlacerModeType],  # (3)

DeleteJobTemplateRequestTypeDef#

# DeleteJobTemplateRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DeleteJobTemplateRequestTypeDef


def get_value() -> DeleteJobTemplateRequestTypeDef:
    return {
        "Name": ...,
    }


# DeleteJobTemplateRequestTypeDef definition

class DeleteJobTemplateRequestTypeDef(TypedDict):
    Name: str,

DeletePresetRequestTypeDef#

# DeletePresetRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DeletePresetRequestTypeDef


def get_value() -> DeletePresetRequestTypeDef:
    return {
        "Name": ...,
    }


# DeletePresetRequestTypeDef definition

class DeletePresetRequestTypeDef(TypedDict):
    Name: str,

DeleteQueueRequestTypeDef#

# DeleteQueueRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DeleteQueueRequestTypeDef


def get_value() -> DeleteQueueRequestTypeDef:
    return {
        "Name": ...,
    }


# DeleteQueueRequestTypeDef definition

class DeleteQueueRequestTypeDef(TypedDict):
    Name: str,

PaginatorConfigTypeDef#

# PaginatorConfigTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import PaginatorConfigTypeDef


def get_value() -> PaginatorConfigTypeDef:
    return {
        "MaxItems": ...,
    }


# PaginatorConfigTypeDef definition

class PaginatorConfigTypeDef(TypedDict):
    MaxItems: NotRequired[int],
    PageSize: NotRequired[int],
    StartingToken: NotRequired[str],

DescribeEndpointsRequestTypeDef#

# DescribeEndpointsRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DescribeEndpointsRequestTypeDef


def get_value() -> DescribeEndpointsRequestTypeDef:
    return {
        "MaxResults": ...,
    }


# DescribeEndpointsRequestTypeDef definition

class DescribeEndpointsRequestTypeDef(TypedDict):
    MaxResults: NotRequired[int],
    Mode: NotRequired[DescribeEndpointsModeType],  # (1)
    NextToken: NotRequired[str],

See DescribeEndpointsModeType

EndpointTypeDef#

# EndpointTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import EndpointTypeDef


def get_value() -> EndpointTypeDef:
    return {
        "Url": ...,
    }


# EndpointTypeDef definition

class EndpointTypeDef(TypedDict):
    Url: NotRequired[str],

DisassociateCertificateRequestTypeDef#

# DisassociateCertificateRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DisassociateCertificateRequestTypeDef


def get_value() -> DisassociateCertificateRequestTypeDef:
    return {
        "Arn": ...,
    }


# DisassociateCertificateRequestTypeDef definition

class DisassociateCertificateRequestTypeDef(TypedDict):
    Arn: str,

DolbyVisionLevel6MetadataTypeDef#

# DolbyVisionLevel6MetadataTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DolbyVisionLevel6MetadataTypeDef


def get_value() -> DolbyVisionLevel6MetadataTypeDef:
    return {
        "MaxCll": ...,
    }


# DolbyVisionLevel6MetadataTypeDef definition

class DolbyVisionLevel6MetadataTypeDef(TypedDict):
    MaxCll: NotRequired[int],
    MaxFall: NotRequired[int],

DvbNitSettingsTypeDef#

# DvbNitSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DvbNitSettingsTypeDef


def get_value() -> DvbNitSettingsTypeDef:
    return {
        "NetworkId": ...,
    }


# DvbNitSettingsTypeDef definition

class DvbNitSettingsTypeDef(TypedDict):
    NetworkId: NotRequired[int],
    NetworkName: NotRequired[str],
    NitInterval: NotRequired[int],

DvbSdtSettingsTypeDef#

# DvbSdtSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DvbSdtSettingsTypeDef


def get_value() -> DvbSdtSettingsTypeDef:
    return {
        "OutputSdt": ...,
    }


# DvbSdtSettingsTypeDef definition

class DvbSdtSettingsTypeDef(TypedDict):
    OutputSdt: NotRequired[OutputSdtType],  # (1)
    SdtInterval: NotRequired[int],
    ServiceName: NotRequired[str],
    ServiceProviderName: NotRequired[str],

See OutputSdtType

DvbTdtSettingsTypeDef#

# DvbTdtSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DvbTdtSettingsTypeDef


def get_value() -> DvbTdtSettingsTypeDef:
    return {
        "TdtInterval": ...,
    }


# DvbTdtSettingsTypeDef definition

class DvbTdtSettingsTypeDef(TypedDict):
    TdtInterval: NotRequired[int],

DynamicAudioSelectorTypeDef#

# DynamicAudioSelectorTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DynamicAudioSelectorTypeDef


def get_value() -> DynamicAudioSelectorTypeDef:
    return {
        "AudioDurationCorrection": ...,
    }


# DynamicAudioSelectorTypeDef definition

class DynamicAudioSelectorTypeDef(TypedDict):
    AudioDurationCorrection: NotRequired[AudioDurationCorrectionType],  # (1)
    ExternalAudioFileInput: NotRequired[str],
    LanguageCode: NotRequired[LanguageCodeType],  # (2)
    Offset: NotRequired[int],
    SelectorType: NotRequired[DynamicAudioSelectorTypeType],  # (3)

EncryptionContractConfigurationTypeDef#

# EncryptionContractConfigurationTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import EncryptionContractConfigurationTypeDef


def get_value() -> EncryptionContractConfigurationTypeDef:
    return {
        "SpekeAudioPreset": ...,
    }


# EncryptionContractConfigurationTypeDef definition

class EncryptionContractConfigurationTypeDef(TypedDict):
    SpekeAudioPreset: NotRequired[PresetSpeke20AudioType],  # (1)
    SpekeVideoPreset: NotRequired[PresetSpeke20VideoType],  # (2)

See PresetSpeke20AudioType
See PresetSpeke20VideoType

EsamManifestConfirmConditionNotificationTypeDef#

# EsamManifestConfirmConditionNotificationTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import EsamManifestConfirmConditionNotificationTypeDef


def get_value() -> EsamManifestConfirmConditionNotificationTypeDef:
    return {
        "MccXml": ...,
    }


# EsamManifestConfirmConditionNotificationTypeDef definition

class EsamManifestConfirmConditionNotificationTypeDef(TypedDict):
    MccXml: NotRequired[str],

EsamSignalProcessingNotificationTypeDef#

# EsamSignalProcessingNotificationTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import EsamSignalProcessingNotificationTypeDef


def get_value() -> EsamSignalProcessingNotificationTypeDef:
    return {
        "SccXml": ...,
    }


# EsamSignalProcessingNotificationTypeDef definition

class EsamSignalProcessingNotificationTypeDef(TypedDict):
    SccXml: NotRequired[str],

ExtendedDataServicesTypeDef#

# ExtendedDataServicesTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ExtendedDataServicesTypeDef


def get_value() -> ExtendedDataServicesTypeDef:
    return {
        "CopyProtectionAction": ...,
    }


# ExtendedDataServicesTypeDef definition

class ExtendedDataServicesTypeDef(TypedDict):
    CopyProtectionAction: NotRequired[CopyProtectionActionType],  # (1)
    VchipAction: NotRequired[VchipActionType],  # (2)

See CopyProtectionActionType
See VchipActionType

FrameCaptureSettingsTypeDef#

# FrameCaptureSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import FrameCaptureSettingsTypeDef


def get_value() -> FrameCaptureSettingsTypeDef:
    return {
        "FramerateDenominator": ...,
    }


# FrameCaptureSettingsTypeDef definition

class FrameCaptureSettingsTypeDef(TypedDict):
    FramerateDenominator: NotRequired[int],
    FramerateNumerator: NotRequired[int],
    MaxCaptures: NotRequired[int],
    Quality: NotRequired[int],

GetJobRequestTypeDef#

# GetJobRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import GetJobRequestTypeDef


def get_value() -> GetJobRequestTypeDef:
    return {
        "Id": ...,
    }


# GetJobRequestTypeDef definition

class GetJobRequestTypeDef(TypedDict):
    Id: str,

GetJobTemplateRequestTypeDef#

# GetJobTemplateRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import GetJobTemplateRequestTypeDef


def get_value() -> GetJobTemplateRequestTypeDef:
    return {
        "Name": ...,
    }


# GetJobTemplateRequestTypeDef definition

class GetJobTemplateRequestTypeDef(TypedDict):
    Name: str,

PolicyTypeDef#

# PolicyTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import PolicyTypeDef


def get_value() -> PolicyTypeDef:
    return {
        "HttpInputs": ...,
    }


# PolicyTypeDef definition

class PolicyTypeDef(TypedDict):
    HttpInputs: NotRequired[InputPolicyType],  # (1)
    HttpsInputs: NotRequired[InputPolicyType],  # (1)
    S3Inputs: NotRequired[InputPolicyType],  # (1)

GetPresetRequestTypeDef#

# GetPresetRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import GetPresetRequestTypeDef


def get_value() -> GetPresetRequestTypeDef:
    return {
        "Name": ...,
    }


# GetPresetRequestTypeDef definition

class GetPresetRequestTypeDef(TypedDict):
    Name: str,

GetQueueRequestTypeDef#

# GetQueueRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import GetQueueRequestTypeDef


def get_value() -> GetQueueRequestTypeDef:
    return {
        "Name": ...,
    }


# GetQueueRequestTypeDef definition

class GetQueueRequestTypeDef(TypedDict):
    Name: str,

GifSettingsTypeDef#

# GifSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import GifSettingsTypeDef


def get_value() -> GifSettingsTypeDef:
    return {
        "FramerateControl": ...,
    }


# GifSettingsTypeDef definition

class GifSettingsTypeDef(TypedDict):
    FramerateControl: NotRequired[GifFramerateControlType],  # (1)
    FramerateConversionAlgorithm: NotRequired[GifFramerateConversionAlgorithmType],  # (2)
    FramerateDenominator: NotRequired[int],
    FramerateNumerator: NotRequired[int],

H264QvbrSettingsTypeDef#

# H264QvbrSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import H264QvbrSettingsTypeDef


def get_value() -> H264QvbrSettingsTypeDef:
    return {
        "MaxAverageBitrate": ...,
    }


# H264QvbrSettingsTypeDef definition

class H264QvbrSettingsTypeDef(TypedDict):
    MaxAverageBitrate: NotRequired[int],
    QvbrQualityLevel: NotRequired[int],
    QvbrQualityLevelFineTune: NotRequired[float],

H265QvbrSettingsTypeDef#

# H265QvbrSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import H265QvbrSettingsTypeDef


def get_value() -> H265QvbrSettingsTypeDef:
    return {
        "MaxAverageBitrate": ...,
    }


# H265QvbrSettingsTypeDef definition

class H265QvbrSettingsTypeDef(TypedDict):
    MaxAverageBitrate: NotRequired[int],
    QvbrQualityLevel: NotRequired[int],
    QvbrQualityLevelFineTune: NotRequired[float],

Hdr10PlusTypeDef#

# Hdr10PlusTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Hdr10PlusTypeDef


def get_value() -> Hdr10PlusTypeDef:
    return {
        "MasteringMonitorNits": ...,
    }


# Hdr10PlusTypeDef definition

class Hdr10PlusTypeDef(TypedDict):
    MasteringMonitorNits: NotRequired[int],
    TargetMonitorNits: NotRequired[int],

HlsAdditionalManifestOutputTypeDef#

# HlsAdditionalManifestOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import HlsAdditionalManifestOutputTypeDef


def get_value() -> HlsAdditionalManifestOutputTypeDef:
    return {
        "ManifestNameModifier": ...,
    }


# HlsAdditionalManifestOutputTypeDef definition

class HlsAdditionalManifestOutputTypeDef(TypedDict):
    ManifestNameModifier: NotRequired[str],
    SelectedOutputs: NotRequired[List[str]],

HlsAdditionalManifestTypeDef#

# HlsAdditionalManifestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import HlsAdditionalManifestTypeDef


def get_value() -> HlsAdditionalManifestTypeDef:
    return {
        "ManifestNameModifier": ...,
    }


# HlsAdditionalManifestTypeDef definition

class HlsAdditionalManifestTypeDef(TypedDict):
    ManifestNameModifier: NotRequired[str],
    SelectedOutputs: NotRequired[Sequence[str]],

HlsCaptionLanguageMappingTypeDef#

# HlsCaptionLanguageMappingTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import HlsCaptionLanguageMappingTypeDef


def get_value() -> HlsCaptionLanguageMappingTypeDef:
    return {
        "CaptionChannel": ...,
    }


# HlsCaptionLanguageMappingTypeDef definition

class HlsCaptionLanguageMappingTypeDef(TypedDict):
    CaptionChannel: NotRequired[int],
    CustomLanguageCode: NotRequired[str],
    LanguageCode: NotRequired[LanguageCodeType],  # (1)
    LanguageDescription: NotRequired[str],

See LanguageCodeType

HlsImageBasedTrickPlaySettingsTypeDef#

# HlsImageBasedTrickPlaySettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import HlsImageBasedTrickPlaySettingsTypeDef


def get_value() -> HlsImageBasedTrickPlaySettingsTypeDef:
    return {
        "IntervalCadence": ...,
    }


# HlsImageBasedTrickPlaySettingsTypeDef definition

class HlsImageBasedTrickPlaySettingsTypeDef(TypedDict):
    IntervalCadence: NotRequired[HlsIntervalCadenceType],  # (1)
    ThumbnailHeight: NotRequired[int],
    ThumbnailInterval: NotRequired[float],
    ThumbnailWidth: NotRequired[int],
    TileHeight: NotRequired[int],
    TileWidth: NotRequired[int],

See HlsIntervalCadenceType

HlsSettingsTypeDef#

# HlsSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import HlsSettingsTypeDef


def get_value() -> HlsSettingsTypeDef:
    return {
        "AudioGroupId": ...,
    }


# HlsSettingsTypeDef definition

class HlsSettingsTypeDef(TypedDict):
    AudioGroupId: NotRequired[str],
    AudioOnlyContainer: NotRequired[HlsAudioOnlyContainerType],  # (1)
    AudioRenditionSets: NotRequired[str],
    AudioTrackType: NotRequired[HlsAudioTrackTypeType],  # (2)
    DescriptiveVideoServiceFlag: NotRequired[HlsDescriptiveVideoServiceFlagType],  # (3)
    IFrameOnlyManifest: NotRequired[HlsIFrameOnlyManifestType],  # (4)
    SegmentModifier: NotRequired[str],

Id3InsertionTypeDef#

# Id3InsertionTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Id3InsertionTypeDef


def get_value() -> Id3InsertionTypeDef:
    return {
        "Id3": ...,
    }


# Id3InsertionTypeDef definition

class Id3InsertionTypeDef(TypedDict):
    Id3: NotRequired[str],
    Timecode: NotRequired[str],

InsertableImageTypeDef#

# InsertableImageTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import InsertableImageTypeDef


def get_value() -> InsertableImageTypeDef:
    return {
        "Duration": ...,
    }


# InsertableImageTypeDef definition

class InsertableImageTypeDef(TypedDict):
    Duration: NotRequired[int],
    FadeIn: NotRequired[int],
    FadeOut: NotRequired[int],
    Height: NotRequired[int],
    ImageInserterInput: NotRequired[str],
    ImageX: NotRequired[int],
    ImageY: NotRequired[int],
    Layer: NotRequired[int],
    Opacity: NotRequired[int],
    StartTime: NotRequired[str],
    Width: NotRequired[int],

InputClippingTypeDef#

# InputClippingTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import InputClippingTypeDef


def get_value() -> InputClippingTypeDef:
    return {
        "EndTimecode": ...,
    }


# InputClippingTypeDef definition

class InputClippingTypeDef(TypedDict):
    EndTimecode: NotRequired[str],
    StartTimecode: NotRequired[str],

InputDecryptionSettingsTypeDef#

# InputDecryptionSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import InputDecryptionSettingsTypeDef


def get_value() -> InputDecryptionSettingsTypeDef:
    return {
        "DecryptionMode": ...,
    }


# InputDecryptionSettingsTypeDef definition

class InputDecryptionSettingsTypeDef(TypedDict):
    DecryptionMode: NotRequired[DecryptionModeType],  # (1)
    EncryptedDecryptionKey: NotRequired[str],
    InitializationVector: NotRequired[str],
    KmsKeyRegion: NotRequired[str],

See DecryptionModeType

InputVideoGeneratorTypeDef#

# InputVideoGeneratorTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import InputVideoGeneratorTypeDef


def get_value() -> InputVideoGeneratorTypeDef:
    return {
        "Channels": ...,
    }


# InputVideoGeneratorTypeDef definition

class InputVideoGeneratorTypeDef(TypedDict):
    Channels: NotRequired[int],
    Duration: NotRequired[int],
    FramerateDenominator: NotRequired[int],
    FramerateNumerator: NotRequired[int],
    SampleRate: NotRequired[int],

RectangleTypeDef#

# RectangleTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import RectangleTypeDef


def get_value() -> RectangleTypeDef:
    return {
        "Height": ...,
    }


# RectangleTypeDef definition

class RectangleTypeDef(TypedDict):
    Height: NotRequired[int],
    Width: NotRequired[int],
    X: NotRequired[int],
    Y: NotRequired[int],

JobEngineVersionTypeDef#

# JobEngineVersionTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import JobEngineVersionTypeDef


def get_value() -> JobEngineVersionTypeDef:
    return {
        "ExpirationDate": ...,
    }


# JobEngineVersionTypeDef definition

class JobEngineVersionTypeDef(TypedDict):
    ExpirationDate: NotRequired[datetime.datetime],
    Version: NotRequired[str],

JobMessagesTypeDef#

# JobMessagesTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import JobMessagesTypeDef


def get_value() -> JobMessagesTypeDef:
    return {
        "Info": ...,
    }


# JobMessagesTypeDef definition

class JobMessagesTypeDef(TypedDict):
    Info: NotRequired[List[str]],
    Warning: NotRequired[List[str]],

KantarWatermarkSettingsTypeDef#

# KantarWatermarkSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import KantarWatermarkSettingsTypeDef


def get_value() -> KantarWatermarkSettingsTypeDef:
    return {
        "ChannelName": ...,
    }


# KantarWatermarkSettingsTypeDef definition

class KantarWatermarkSettingsTypeDef(TypedDict):
    ChannelName: NotRequired[str],
    ContentReference: NotRequired[str],
    CredentialsSecretName: NotRequired[str],
    FileOffset: NotRequired[float],
    KantarLicenseId: NotRequired[int],
    KantarServerUrl: NotRequired[str],
    LogDestination: NotRequired[str],
    Metadata3: NotRequired[str],
    Metadata4: NotRequired[str],
    Metadata5: NotRequired[str],
    Metadata6: NotRequired[str],
    Metadata7: NotRequired[str],
    Metadata8: NotRequired[str],

NielsenConfigurationTypeDef#

# NielsenConfigurationTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import NielsenConfigurationTypeDef


def get_value() -> NielsenConfigurationTypeDef:
    return {
        "BreakoutCode": ...,
    }


# NielsenConfigurationTypeDef definition

class NielsenConfigurationTypeDef(TypedDict):
    BreakoutCode: NotRequired[int],
    DistributorId: NotRequired[str],

NielsenNonLinearWatermarkSettingsTypeDef#

# NielsenNonLinearWatermarkSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import NielsenNonLinearWatermarkSettingsTypeDef


def get_value() -> NielsenNonLinearWatermarkSettingsTypeDef:
    return {
        "ActiveWatermarkProcess": ...,
    }


# NielsenNonLinearWatermarkSettingsTypeDef definition

class NielsenNonLinearWatermarkSettingsTypeDef(TypedDict):
    ActiveWatermarkProcess: NotRequired[NielsenActiveWatermarkProcessTypeType],  # (1)
    AdiFilename: NotRequired[str],
    AssetId: NotRequired[str],
    AssetName: NotRequired[str],
    CbetSourceId: NotRequired[str],
    EpisodeId: NotRequired[str],
    MetadataDestination: NotRequired[str],
    SourceId: NotRequired[int],
    SourceWatermarkStatus: NotRequired[NielsenSourceWatermarkStatusTypeType],  # (2)
    TicServerUrl: NotRequired[str],
    UniqueTicPerAudioTrack: NotRequired[NielsenUniqueTicPerAudioTrackTypeType],  # (3)

TimecodeConfigTypeDef#

# TimecodeConfigTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import TimecodeConfigTypeDef


def get_value() -> TimecodeConfigTypeDef:
    return {
        "Anchor": ...,
    }


# TimecodeConfigTypeDef definition

class TimecodeConfigTypeDef(TypedDict):
    Anchor: NotRequired[str],
    Source: NotRequired[TimecodeSourceType],  # (1)
    Start: NotRequired[str],
    TimestampOffset: NotRequired[str],

See TimecodeSourceType

QueueTransitionTypeDef#

# QueueTransitionTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import QueueTransitionTypeDef


def get_value() -> QueueTransitionTypeDef:
    return {
        "DestinationQueue": ...,
    }


# QueueTransitionTypeDef definition

class QueueTransitionTypeDef(TypedDict):
    DestinationQueue: NotRequired[str],
    SourceQueue: NotRequired[str],
    Timestamp: NotRequired[datetime.datetime],

TimingTypeDef#

# TimingTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import TimingTypeDef


def get_value() -> TimingTypeDef:
    return {
        "FinishTime": ...,
    }


# TimingTypeDef definition

class TimingTypeDef(TypedDict):
    FinishTime: NotRequired[datetime.datetime],
    StartTime: NotRequired[datetime.datetime],
    SubmitTime: NotRequired[datetime.datetime],

WarningGroupTypeDef#

# WarningGroupTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import WarningGroupTypeDef


def get_value() -> WarningGroupTypeDef:
    return {
        "Code": ...,
    }


# WarningGroupTypeDef definition

class WarningGroupTypeDef(TypedDict):
    Code: int,
    Count: int,

ListJobTemplatesRequestTypeDef#

# ListJobTemplatesRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListJobTemplatesRequestTypeDef


def get_value() -> ListJobTemplatesRequestTypeDef:
    return {
        "Category": ...,
    }


# ListJobTemplatesRequestTypeDef definition

class ListJobTemplatesRequestTypeDef(TypedDict):
    Category: NotRequired[str],
    ListBy: NotRequired[JobTemplateListByType],  # (1)
    MaxResults: NotRequired[int],
    NextToken: NotRequired[str],
    Order: NotRequired[OrderType],  # (2)

See JobTemplateListByType
See OrderType

ListJobsRequestTypeDef#

# ListJobsRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListJobsRequestTypeDef


def get_value() -> ListJobsRequestTypeDef:
    return {
        "MaxResults": ...,
    }


# ListJobsRequestTypeDef definition

class ListJobsRequestTypeDef(TypedDict):
    MaxResults: NotRequired[int],
    NextToken: NotRequired[str],
    Order: NotRequired[OrderType],  # (1)
    Queue: NotRequired[str],
    Status: NotRequired[JobStatusType],  # (2)

See OrderType
See JobStatusType

ListPresetsRequestTypeDef#

# ListPresetsRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListPresetsRequestTypeDef


def get_value() -> ListPresetsRequestTypeDef:
    return {
        "Category": ...,
    }


# ListPresetsRequestTypeDef definition

class ListPresetsRequestTypeDef(TypedDict):
    Category: NotRequired[str],
    ListBy: NotRequired[PresetListByType],  # (1)
    MaxResults: NotRequired[int],
    NextToken: NotRequired[str],
    Order: NotRequired[OrderType],  # (2)

See PresetListByType
See OrderType

ListQueuesRequestTypeDef#

# ListQueuesRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListQueuesRequestTypeDef


def get_value() -> ListQueuesRequestTypeDef:
    return {
        "ListBy": ...,
    }


# ListQueuesRequestTypeDef definition

class ListQueuesRequestTypeDef(TypedDict):
    ListBy: NotRequired[QueueListByType],  # (1)
    MaxResults: NotRequired[int],
    NextToken: NotRequired[str],
    Order: NotRequired[OrderType],  # (2)

See QueueListByType
See OrderType

ListTagsForResourceRequestTypeDef#

# ListTagsForResourceRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListTagsForResourceRequestTypeDef


def get_value() -> ListTagsForResourceRequestTypeDef:
    return {
        "Arn": ...,
    }


# ListTagsForResourceRequestTypeDef definition

class ListTagsForResourceRequestTypeDef(TypedDict):
    Arn: str,

ResourceTagsTypeDef#

# ResourceTagsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ResourceTagsTypeDef


def get_value() -> ResourceTagsTypeDef:
    return {
        "Arn": ...,
    }


# ResourceTagsTypeDef definition

class ResourceTagsTypeDef(TypedDict):
    Arn: NotRequired[str],
    Tags: NotRequired[Dict[str, str]],

ListVersionsRequestTypeDef#

# ListVersionsRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListVersionsRequestTypeDef


def get_value() -> ListVersionsRequestTypeDef:
    return {
        "MaxResults": ...,
    }


# ListVersionsRequestTypeDef definition

class ListVersionsRequestTypeDef(TypedDict):
    MaxResults: NotRequired[int],
    NextToken: NotRequired[str],

M2tsScte35EsamTypeDef#

# M2tsScte35EsamTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import M2tsScte35EsamTypeDef


def get_value() -> M2tsScte35EsamTypeDef:
    return {
        "Scte35EsamPid": ...,
    }


# M2tsScte35EsamTypeDef definition

class M2tsScte35EsamTypeDef(TypedDict):
    Scte35EsamPid: NotRequired[int],

MetadataTypeDef#

# MetadataTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import MetadataTypeDef


def get_value() -> MetadataTypeDef:
    return {
        "ETag": ...,
    }


# MetadataTypeDef definition

class MetadataTypeDef(TypedDict):
    ETag: NotRequired[str],
    FileSize: NotRequired[int],
    LastModified: NotRequired[datetime.datetime],
    MimeType: NotRequired[str],

MotionImageInsertionFramerateTypeDef#

# MotionImageInsertionFramerateTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import MotionImageInsertionFramerateTypeDef


def get_value() -> MotionImageInsertionFramerateTypeDef:
    return {
        "FramerateDenominator": ...,
    }


# MotionImageInsertionFramerateTypeDef definition

class MotionImageInsertionFramerateTypeDef(TypedDict):
    FramerateDenominator: NotRequired[int],
    FramerateNumerator: NotRequired[int],

MotionImageInsertionOffsetTypeDef#

# MotionImageInsertionOffsetTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import MotionImageInsertionOffsetTypeDef


def get_value() -> MotionImageInsertionOffsetTypeDef:
    return {
        "ImageX": ...,
    }


# MotionImageInsertionOffsetTypeDef definition

class MotionImageInsertionOffsetTypeDef(TypedDict):
    ImageX: NotRequired[int],
    ImageY: NotRequired[int],

Mpeg2SettingsTypeDef#

# Mpeg2SettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Mpeg2SettingsTypeDef


def get_value() -> Mpeg2SettingsTypeDef:
    return {
        "AdaptiveQuantization": ...,
    }


# Mpeg2SettingsTypeDef definition

class Mpeg2SettingsTypeDef(TypedDict):
    AdaptiveQuantization: NotRequired[Mpeg2AdaptiveQuantizationType],  # (1)
    Bitrate: NotRequired[int],
    CodecLevel: NotRequired[Mpeg2CodecLevelType],  # (2)
    CodecProfile: NotRequired[Mpeg2CodecProfileType],  # (3)
    DynamicSubGop: NotRequired[Mpeg2DynamicSubGopType],  # (4)
    FramerateControl: NotRequired[Mpeg2FramerateControlType],  # (5)
    FramerateConversionAlgorithm: NotRequired[Mpeg2FramerateConversionAlgorithmType],  # (6)
    FramerateDenominator: NotRequired[int],
    FramerateNumerator: NotRequired[int],
    GopClosedCadence: NotRequired[int],
    GopSize: NotRequired[float],
    GopSizeUnits: NotRequired[Mpeg2GopSizeUnitsType],  # (7)
    HrdBufferFinalFillPercentage: NotRequired[int],
    HrdBufferInitialFillPercentage: NotRequired[int],
    HrdBufferSize: NotRequired[int],
    InterlaceMode: NotRequired[Mpeg2InterlaceModeType],  # (8)
    IntraDcPrecision: NotRequired[Mpeg2IntraDcPrecisionType],  # (9)
    MaxBitrate: NotRequired[int],
    MinIInterval: NotRequired[int],
    NumberBFramesBetweenReferenceFrames: NotRequired[int],
    ParControl: NotRequired[Mpeg2ParControlType],  # (10)
    ParDenominator: NotRequired[int],
    ParNumerator: NotRequired[int],
    QualityTuningLevel: NotRequired[Mpeg2QualityTuningLevelType],  # (11)
    RateControlMode: NotRequired[Mpeg2RateControlModeType],  # (12)
    ScanTypeConversionMode: NotRequired[Mpeg2ScanTypeConversionModeType],  # (13)
    SceneChangeDetect: NotRequired[Mpeg2SceneChangeDetectType],  # (14)
    SlowPal: NotRequired[Mpeg2SlowPalType],  # (15)
    Softness: NotRequired[int],
    SpatialAdaptiveQuantization: NotRequired[Mpeg2SpatialAdaptiveQuantizationType],  # (16)
    Syntax: NotRequired[Mpeg2SyntaxType],  # (17)
    Telecine: NotRequired[Mpeg2TelecineType],  # (18)
    TemporalAdaptiveQuantization: NotRequired[Mpeg2TemporalAdaptiveQuantizationType],  # (19)

See Mpeg2AdaptiveQuantizationType
See Mpeg2CodecLevelType
See Mpeg2CodecProfileType
See Mpeg2DynamicSubGopType
See Mpeg2FramerateControlType
See Mpeg2FramerateConversionAlgorithmType
See Mpeg2GopSizeUnitsType
See Mpeg2InterlaceModeType
See Mpeg2IntraDcPrecisionType
See Mpeg2ParControlType
See Mpeg2QualityTuningLevelType
See Mpeg2RateControlModeType
See Mpeg2ScanTypeConversionModeType
See Mpeg2SceneChangeDetectType
See Mpeg2SlowPalType
See Mpeg2SpatialAdaptiveQuantizationType
See Mpeg2SyntaxType
See Mpeg2TelecineType
See Mpeg2TemporalAdaptiveQuantizationType

MsSmoothAdditionalManifestOutputTypeDef#

# MsSmoothAdditionalManifestOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import MsSmoothAdditionalManifestOutputTypeDef


def get_value() -> MsSmoothAdditionalManifestOutputTypeDef:
    return {
        "ManifestNameModifier": ...,
    }


# MsSmoothAdditionalManifestOutputTypeDef definition

class MsSmoothAdditionalManifestOutputTypeDef(TypedDict):
    ManifestNameModifier: NotRequired[str],
    SelectedOutputs: NotRequired[List[str]],

MsSmoothAdditionalManifestTypeDef#

# MsSmoothAdditionalManifestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import MsSmoothAdditionalManifestTypeDef


def get_value() -> MsSmoothAdditionalManifestTypeDef:
    return {
        "ManifestNameModifier": ...,
    }


# MsSmoothAdditionalManifestTypeDef definition

class MsSmoothAdditionalManifestTypeDef(TypedDict):
    ManifestNameModifier: NotRequired[str],
    SelectedOutputs: NotRequired[Sequence[str]],

MxfXavcProfileSettingsTypeDef#

# MxfXavcProfileSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import MxfXavcProfileSettingsTypeDef


def get_value() -> MxfXavcProfileSettingsTypeDef:
    return {
        "DurationMode": ...,
    }


# MxfXavcProfileSettingsTypeDef definition

class MxfXavcProfileSettingsTypeDef(TypedDict):
    DurationMode: NotRequired[MxfXavcDurationModeType],  # (1)
    MaxAncDataSize: NotRequired[int],

See MxfXavcDurationModeType

NexGuardFileMarkerSettingsTypeDef#

# NexGuardFileMarkerSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import NexGuardFileMarkerSettingsTypeDef


def get_value() -> NexGuardFileMarkerSettingsTypeDef:
    return {
        "License": ...,
    }


# NexGuardFileMarkerSettingsTypeDef definition

class NexGuardFileMarkerSettingsTypeDef(TypedDict):
    License: NotRequired[str],
    Payload: NotRequired[int],
    Preset: NotRequired[str],
    Strength: NotRequired[WatermarkingStrengthType],  # (1)

See WatermarkingStrengthType

NoiseReducerFilterSettingsTypeDef#

# NoiseReducerFilterSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import NoiseReducerFilterSettingsTypeDef


def get_value() -> NoiseReducerFilterSettingsTypeDef:
    return {
        "Strength": ...,
    }


# NoiseReducerFilterSettingsTypeDef definition

class NoiseReducerFilterSettingsTypeDef(TypedDict):
    Strength: NotRequired[int],

NoiseReducerSpatialFilterSettingsTypeDef#

# NoiseReducerSpatialFilterSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import NoiseReducerSpatialFilterSettingsTypeDef


def get_value() -> NoiseReducerSpatialFilterSettingsTypeDef:
    return {
        "PostFilterSharpenStrength": ...,
    }


# NoiseReducerSpatialFilterSettingsTypeDef definition

class NoiseReducerSpatialFilterSettingsTypeDef(TypedDict):
    PostFilterSharpenStrength: NotRequired[int],
    Speed: NotRequired[int],
    Strength: NotRequired[int],

NoiseReducerTemporalFilterSettingsTypeDef#

# NoiseReducerTemporalFilterSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import NoiseReducerTemporalFilterSettingsTypeDef


def get_value() -> NoiseReducerTemporalFilterSettingsTypeDef:
    return {
        "AggressiveMode": ...,
    }


# NoiseReducerTemporalFilterSettingsTypeDef definition

class NoiseReducerTemporalFilterSettingsTypeDef(TypedDict):
    AggressiveMode: NotRequired[int],
    PostTemporalSharpening: NotRequired[NoiseFilterPostTemporalSharpeningType],  # (1)
    PostTemporalSharpeningStrength: NotRequired[NoiseFilterPostTemporalSharpeningStrengthType],  # (2)
    Speed: NotRequired[int],
    Strength: NotRequired[int],

VideoDetailTypeDef#

# VideoDetailTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import VideoDetailTypeDef


def get_value() -> VideoDetailTypeDef:
    return {
        "HeightInPx": ...,
    }


# VideoDetailTypeDef definition

class VideoDetailTypeDef(TypedDict):
    HeightInPx: NotRequired[int],
    WidthInPx: NotRequired[int],

ProbeInputFileTypeDef#

# ProbeInputFileTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ProbeInputFileTypeDef


def get_value() -> ProbeInputFileTypeDef:
    return {
        "FileUrl": ...,
    }


# ProbeInputFileTypeDef definition

class ProbeInputFileTypeDef(TypedDict):
    FileUrl: NotRequired[str],

TrackMappingTypeDef#

# TrackMappingTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import TrackMappingTypeDef


def get_value() -> TrackMappingTypeDef:
    return {
        "AudioTrackIndexes": ...,
    }


# TrackMappingTypeDef definition

class TrackMappingTypeDef(TypedDict):
    AudioTrackIndexes: NotRequired[List[int]],
    DataTrackIndexes: NotRequired[List[int]],
    VideoTrackIndexes: NotRequired[List[int]],

ProresSettingsTypeDef#

# ProresSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ProresSettingsTypeDef


def get_value() -> ProresSettingsTypeDef:
    return {
        "ChromaSampling": ...,
    }


# ProresSettingsTypeDef definition

class ProresSettingsTypeDef(TypedDict):
    ChromaSampling: NotRequired[ProresChromaSamplingType],  # (1)
    CodecProfile: NotRequired[ProresCodecProfileType],  # (2)
    FramerateControl: NotRequired[ProresFramerateControlType],  # (3)
    FramerateConversionAlgorithm: NotRequired[ProresFramerateConversionAlgorithmType],  # (4)
    FramerateDenominator: NotRequired[int],
    FramerateNumerator: NotRequired[int],
    InterlaceMode: NotRequired[ProresInterlaceModeType],  # (5)
    ParControl: NotRequired[ProresParControlType],  # (6)
    ParDenominator: NotRequired[int],
    ParNumerator: NotRequired[int],
    ScanTypeConversionMode: NotRequired[ProresScanTypeConversionModeType],  # (7)
    SlowPal: NotRequired[ProresSlowPalType],  # (8)
    Telecine: NotRequired[ProresTelecineType],  # (9)

See ProresChromaSamplingType
See ProresCodecProfileType
See ProresFramerateControlType
See ProresFramerateConversionAlgorithmType
See ProresInterlaceModeType
See ProresParControlType
See ProresScanTypeConversionModeType
See ProresSlowPalType
See ProresTelecineType

ReservationPlanTypeDef#

# ReservationPlanTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ReservationPlanTypeDef


def get_value() -> ReservationPlanTypeDef:
    return {
        "Commitment": ...,
    }


# ReservationPlanTypeDef definition

class ReservationPlanTypeDef(TypedDict):
    Commitment: NotRequired[CommitmentType],  # (1)
    ExpiresAt: NotRequired[datetime.datetime],
    PurchasedAt: NotRequired[datetime.datetime],
    RenewalType: NotRequired[RenewalTypeType],  # (2)
    ReservedSlots: NotRequired[int],
    Status: NotRequired[ReservationPlanStatusType],  # (3)

ServiceOverrideTypeDef#

# ServiceOverrideTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ServiceOverrideTypeDef


def get_value() -> ServiceOverrideTypeDef:
    return {
        "Message": ...,
    }


# ServiceOverrideTypeDef definition

class ServiceOverrideTypeDef(TypedDict):
    Message: NotRequired[str],
    Name: NotRequired[str],
    OverrideValue: NotRequired[str],
    Value: NotRequired[str],

S3DestinationAccessControlTypeDef#

# S3DestinationAccessControlTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import S3DestinationAccessControlTypeDef


def get_value() -> S3DestinationAccessControlTypeDef:
    return {
        "CannedAcl": ...,
    }


# S3DestinationAccessControlTypeDef definition

class S3DestinationAccessControlTypeDef(TypedDict):
    CannedAcl: NotRequired[S3ObjectCannedAclType],  # (1)

See S3ObjectCannedAclType

S3EncryptionSettingsTypeDef#

# S3EncryptionSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import S3EncryptionSettingsTypeDef


def get_value() -> S3EncryptionSettingsTypeDef:
    return {
        "EncryptionType": ...,
    }


# S3EncryptionSettingsTypeDef definition

class S3EncryptionSettingsTypeDef(TypedDict):
    EncryptionType: NotRequired[S3ServerSideEncryptionTypeType],  # (1)
    KmsEncryptionContext: NotRequired[str],
    KmsKeyArn: NotRequired[str],

See S3ServerSideEncryptionTypeType

SearchJobsRequestTypeDef#

# SearchJobsRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import SearchJobsRequestTypeDef


def get_value() -> SearchJobsRequestTypeDef:
    return {
        "InputFile": ...,
    }


# SearchJobsRequestTypeDef definition

class SearchJobsRequestTypeDef(TypedDict):
    InputFile: NotRequired[str],
    MaxResults: NotRequired[int],
    NextToken: NotRequired[str],
    Order: NotRequired[OrderType],  # (1)
    Queue: NotRequired[str],
    Status: NotRequired[JobStatusType],  # (2)

See OrderType
See JobStatusType

TagResourceRequestTypeDef#

# TagResourceRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import TagResourceRequestTypeDef


def get_value() -> TagResourceRequestTypeDef:
    return {
        "Arn": ...,
    }


# TagResourceRequestTypeDef definition

class TagResourceRequestTypeDef(TypedDict):
    Arn: str,
    Tags: Mapping[str, str],

TimecodeBurninTypeDef#

# TimecodeBurninTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import TimecodeBurninTypeDef


def get_value() -> TimecodeBurninTypeDef:
    return {
        "FontSize": ...,
    }


# TimecodeBurninTypeDef definition

class TimecodeBurninTypeDef(TypedDict):
    FontSize: NotRequired[int],
    Position: NotRequired[TimecodeBurninPositionType],  # (1)
    Prefix: NotRequired[str],

See TimecodeBurninPositionType

UncompressedSettingsTypeDef#

# UncompressedSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import UncompressedSettingsTypeDef


def get_value() -> UncompressedSettingsTypeDef:
    return {
        "Fourcc": ...,
    }


# UncompressedSettingsTypeDef definition

class UncompressedSettingsTypeDef(TypedDict):
    Fourcc: NotRequired[UncompressedFourccType],  # (1)
    FramerateControl: NotRequired[UncompressedFramerateControlType],  # (2)
    FramerateConversionAlgorithm: NotRequired[UncompressedFramerateConversionAlgorithmType],  # (3)
    FramerateDenominator: NotRequired[int],
    FramerateNumerator: NotRequired[int],
    InterlaceMode: NotRequired[UncompressedInterlaceModeType],  # (4)
    ScanTypeConversionMode: NotRequired[UncompressedScanTypeConversionModeType],  # (5)
    SlowPal: NotRequired[UncompressedSlowPalType],  # (6)
    Telecine: NotRequired[UncompressedTelecineType],  # (7)

See UncompressedFourccType
See UncompressedFramerateControlType
See UncompressedFramerateConversionAlgorithmType
See UncompressedInterlaceModeType
See UncompressedScanTypeConversionModeType
See UncompressedSlowPalType
See UncompressedTelecineType

UntagResourceRequestTypeDef#

# UntagResourceRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import UntagResourceRequestTypeDef


def get_value() -> UntagResourceRequestTypeDef:
    return {
        "Arn": ...,
    }


# UntagResourceRequestTypeDef definition

class UntagResourceRequestTypeDef(TypedDict):
    Arn: str,
    TagKeys: NotRequired[Sequence[str]],

Vc3SettingsTypeDef#

# Vc3SettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Vc3SettingsTypeDef


def get_value() -> Vc3SettingsTypeDef:
    return {
        "FramerateControl": ...,
    }


# Vc3SettingsTypeDef definition

class Vc3SettingsTypeDef(TypedDict):
    FramerateControl: NotRequired[Vc3FramerateControlType],  # (1)
    FramerateConversionAlgorithm: NotRequired[Vc3FramerateConversionAlgorithmType],  # (2)
    FramerateDenominator: NotRequired[int],
    FramerateNumerator: NotRequired[int],
    InterlaceMode: NotRequired[Vc3InterlaceModeType],  # (3)
    ScanTypeConversionMode: NotRequired[Vc3ScanTypeConversionModeType],  # (4)
    SlowPal: NotRequired[Vc3SlowPalType],  # (5)
    Telecine: NotRequired[Vc3TelecineType],  # (6)
    Vc3Class: NotRequired[Vc3ClassType],  # (7)

Vp8SettingsTypeDef#

# Vp8SettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Vp8SettingsTypeDef


def get_value() -> Vp8SettingsTypeDef:
    return {
        "Bitrate": ...,
    }


# Vp8SettingsTypeDef definition

class Vp8SettingsTypeDef(TypedDict):
    Bitrate: NotRequired[int],
    FramerateControl: NotRequired[Vp8FramerateControlType],  # (1)
    FramerateConversionAlgorithm: NotRequired[Vp8FramerateConversionAlgorithmType],  # (2)
    FramerateDenominator: NotRequired[int],
    FramerateNumerator: NotRequired[int],
    GopSize: NotRequired[float],
    HrdBufferSize: NotRequired[int],
    MaxBitrate: NotRequired[int],
    ParControl: NotRequired[Vp8ParControlType],  # (3)
    ParDenominator: NotRequired[int],
    ParNumerator: NotRequired[int],
    QualityTuningLevel: NotRequired[Vp8QualityTuningLevelType],  # (4)
    RateControlMode: NotRequired[Vp8RateControlModeType],  # (5)

Vp9SettingsTypeDef#

# Vp9SettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Vp9SettingsTypeDef


def get_value() -> Vp9SettingsTypeDef:
    return {
        "Bitrate": ...,
    }


# Vp9SettingsTypeDef definition

class Vp9SettingsTypeDef(TypedDict):
    Bitrate: NotRequired[int],
    FramerateControl: NotRequired[Vp9FramerateControlType],  # (1)
    FramerateConversionAlgorithm: NotRequired[Vp9FramerateConversionAlgorithmType],  # (2)
    FramerateDenominator: NotRequired[int],
    FramerateNumerator: NotRequired[int],
    GopSize: NotRequired[float],
    HrdBufferSize: NotRequired[int],
    MaxBitrate: NotRequired[int],
    ParControl: NotRequired[Vp9ParControlType],  # (3)
    ParDenominator: NotRequired[int],
    ParNumerator: NotRequired[int],
    QualityTuningLevel: NotRequired[Vp9QualityTuningLevelType],  # (4)
    RateControlMode: NotRequired[Vp9RateControlModeType],  # (5)

VideoOverlayInputClippingTypeDef#

# VideoOverlayInputClippingTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import VideoOverlayInputClippingTypeDef


def get_value() -> VideoOverlayInputClippingTypeDef:
    return {
        "EndTimecode": ...,
    }


# VideoOverlayInputClippingTypeDef definition

class VideoOverlayInputClippingTypeDef(TypedDict):
    EndTimecode: NotRequired[str],
    StartTimecode: NotRequired[str],

VideoOverlayPositionTypeDef#

# VideoOverlayPositionTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import VideoOverlayPositionTypeDef


def get_value() -> VideoOverlayPositionTypeDef:
    return {
        "Height": ...,
    }


# VideoOverlayPositionTypeDef definition

class VideoOverlayPositionTypeDef(TypedDict):
    Height: NotRequired[int],
    Unit: NotRequired[VideoOverlayUnitType],  # (1)
    Width: NotRequired[int],
    XPosition: NotRequired[int],
    YPosition: NotRequired[int],

See VideoOverlayUnitType

Xavc4kIntraCbgProfileSettingsTypeDef#

# Xavc4kIntraCbgProfileSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Xavc4kIntraCbgProfileSettingsTypeDef


def get_value() -> Xavc4kIntraCbgProfileSettingsTypeDef:
    return {
        "XavcClass": ...,
    }


# Xavc4kIntraCbgProfileSettingsTypeDef definition

class Xavc4kIntraCbgProfileSettingsTypeDef(TypedDict):
    XavcClass: NotRequired[Xavc4kIntraCbgProfileClassType],  # (1)

See Xavc4kIntraCbgProfileClassType

Xavc4kIntraVbrProfileSettingsTypeDef#

# Xavc4kIntraVbrProfileSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Xavc4kIntraVbrProfileSettingsTypeDef


def get_value() -> Xavc4kIntraVbrProfileSettingsTypeDef:
    return {
        "XavcClass": ...,
    }


# Xavc4kIntraVbrProfileSettingsTypeDef definition

class Xavc4kIntraVbrProfileSettingsTypeDef(TypedDict):
    XavcClass: NotRequired[Xavc4kIntraVbrProfileClassType],  # (1)

See Xavc4kIntraVbrProfileClassType

Xavc4kProfileSettingsTypeDef#

# Xavc4kProfileSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Xavc4kProfileSettingsTypeDef


def get_value() -> Xavc4kProfileSettingsTypeDef:
    return {
        "BitrateClass": ...,
    }


# Xavc4kProfileSettingsTypeDef definition

class Xavc4kProfileSettingsTypeDef(TypedDict):
    BitrateClass: NotRequired[Xavc4kProfileBitrateClassType],  # (1)
    CodecProfile: NotRequired[Xavc4kProfileCodecProfileType],  # (2)
    FlickerAdaptiveQuantization: NotRequired[XavcFlickerAdaptiveQuantizationType],  # (3)
    GopBReference: NotRequired[XavcGopBReferenceType],  # (4)
    GopClosedCadence: NotRequired[int],
    HrdBufferSize: NotRequired[int],
    QualityTuningLevel: NotRequired[Xavc4kProfileQualityTuningLevelType],  # (5)
    Slices: NotRequired[int],

XavcHdIntraCbgProfileSettingsTypeDef#

# XavcHdIntraCbgProfileSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import XavcHdIntraCbgProfileSettingsTypeDef


def get_value() -> XavcHdIntraCbgProfileSettingsTypeDef:
    return {
        "XavcClass": ...,
    }


# XavcHdIntraCbgProfileSettingsTypeDef definition

class XavcHdIntraCbgProfileSettingsTypeDef(TypedDict):
    XavcClass: NotRequired[XavcHdIntraCbgProfileClassType],  # (1)

See XavcHdIntraCbgProfileClassType

XavcHdProfileSettingsTypeDef#

# XavcHdProfileSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import XavcHdProfileSettingsTypeDef


def get_value() -> XavcHdProfileSettingsTypeDef:
    return {
        "BitrateClass": ...,
    }


# XavcHdProfileSettingsTypeDef definition

class XavcHdProfileSettingsTypeDef(TypedDict):
    BitrateClass: NotRequired[XavcHdProfileBitrateClassType],  # (1)
    FlickerAdaptiveQuantization: NotRequired[XavcFlickerAdaptiveQuantizationType],  # (2)
    GopBReference: NotRequired[XavcGopBReferenceType],  # (3)
    GopClosedCadence: NotRequired[int],
    HrdBufferSize: NotRequired[int],
    InterlaceMode: NotRequired[XavcInterlaceModeType],  # (4)
    QualityTuningLevel: NotRequired[XavcHdProfileQualityTuningLevelType],  # (5)
    Slices: NotRequired[int],
    Telecine: NotRequired[XavcHdProfileTelecineType],  # (6)

AudioCodecSettingsTypeDef#

# AudioCodecSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AudioCodecSettingsTypeDef


def get_value() -> AudioCodecSettingsTypeDef:
    return {
        "AacSettings": ...,
    }


# AudioCodecSettingsTypeDef definition

class AudioCodecSettingsTypeDef(TypedDict):
    AacSettings: NotRequired[AacSettingsTypeDef],  # (1)
    Ac3Settings: NotRequired[Ac3SettingsTypeDef],  # (2)
    AiffSettings: NotRequired[AiffSettingsTypeDef],  # (3)
    Codec: NotRequired[AudioCodecType],  # (4)
    Eac3AtmosSettings: NotRequired[Eac3AtmosSettingsTypeDef],  # (5)
    Eac3Settings: NotRequired[Eac3SettingsTypeDef],  # (6)
    FlacSettings: NotRequired[FlacSettingsTypeDef],  # (7)
    Mp2Settings: NotRequired[Mp2SettingsTypeDef],  # (8)
    Mp3Settings: NotRequired[Mp3SettingsTypeDef],  # (9)
    OpusSettings: NotRequired[OpusSettingsTypeDef],  # (10)
    VorbisSettings: NotRequired[VorbisSettingsTypeDef],  # (11)
    WavSettings: NotRequired[WavSettingsTypeDef],  # (12)

AudioPropertiesTypeDef#

# AudioPropertiesTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AudioPropertiesTypeDef


def get_value() -> AudioPropertiesTypeDef:
    return {
        "BitDepth": ...,
    }


# AudioPropertiesTypeDef definition

class AudioPropertiesTypeDef(TypedDict):
    BitDepth: NotRequired[int],
    BitRate: NotRequired[int],
    Channels: NotRequired[int],
    FrameRate: NotRequired[FrameRateTypeDef],  # (1)
    LanguageCode: NotRequired[str],
    SampleRate: NotRequired[int],

See FrameRateTypeDef

VideoPropertiesTypeDef#

# VideoPropertiesTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import VideoPropertiesTypeDef


def get_value() -> VideoPropertiesTypeDef:
    return {
        "BitDepth": ...,
    }


# VideoPropertiesTypeDef definition

class VideoPropertiesTypeDef(TypedDict):
    BitDepth: NotRequired[int],
    BitRate: NotRequired[int],
    ColorPrimaries: NotRequired[ColorPrimariesType],  # (1)
    FrameRate: NotRequired[FrameRateTypeDef],  # (2)
    Height: NotRequired[int],
    MatrixCoefficients: NotRequired[MatrixCoefficientsType],  # (3)
    TransferCharacteristics: NotRequired[TransferCharacteristicsType],  # (4)
    Width: NotRequired[int],

AutomatedAbrRuleOutputTypeDef#

# AutomatedAbrRuleOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AutomatedAbrRuleOutputTypeDef


def get_value() -> AutomatedAbrRuleOutputTypeDef:
    return {
        "AllowedRenditions": ...,
    }


# AutomatedAbrRuleOutputTypeDef definition

class AutomatedAbrRuleOutputTypeDef(TypedDict):
    AllowedRenditions: NotRequired[List[AllowedRenditionSizeTypeDef]],  # (1)
    ForceIncludeRenditions: NotRequired[List[ForceIncludeRenditionSizeTypeDef]],  # (2)
    MinBottomRenditionSize: NotRequired[MinBottomRenditionSizeTypeDef],  # (3)
    MinTopRenditionSize: NotRequired[MinTopRenditionSizeTypeDef],  # (4)
    Type: NotRequired[RuleTypeType],  # (5)

See List[AllowedRenditionSizeTypeDef]
See List[ForceIncludeRenditionSizeTypeDef]
See MinBottomRenditionSizeTypeDef
See MinTopRenditionSizeTypeDef
See RuleTypeType

AutomatedAbrRuleTypeDef#

# AutomatedAbrRuleTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AutomatedAbrRuleTypeDef


def get_value() -> AutomatedAbrRuleTypeDef:
    return {
        "AllowedRenditions": ...,
    }


# AutomatedAbrRuleTypeDef definition

class AutomatedAbrRuleTypeDef(TypedDict):
    AllowedRenditions: NotRequired[Sequence[AllowedRenditionSizeTypeDef]],  # (1)
    ForceIncludeRenditions: NotRequired[Sequence[ForceIncludeRenditionSizeTypeDef]],  # (2)
    MinBottomRenditionSize: NotRequired[MinBottomRenditionSizeTypeDef],  # (3)
    MinTopRenditionSize: NotRequired[MinTopRenditionSizeTypeDef],  # (4)
    Type: NotRequired[RuleTypeType],  # (5)

See Sequence[AllowedRenditionSizeTypeDef]
See Sequence[ForceIncludeRenditionSizeTypeDef]
See MinBottomRenditionSizeTypeDef
See MinTopRenditionSizeTypeDef
See RuleTypeType

Av1SettingsTypeDef#

# Av1SettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import Av1SettingsTypeDef


def get_value() -> Av1SettingsTypeDef:
    return {
        "AdaptiveQuantization": ...,
    }


# Av1SettingsTypeDef definition

class Av1SettingsTypeDef(TypedDict):
    AdaptiveQuantization: NotRequired[Av1AdaptiveQuantizationType],  # (1)
    BitDepth: NotRequired[Av1BitDepthType],  # (2)
    FilmGrainSynthesis: NotRequired[Av1FilmGrainSynthesisType],  # (3)
    FramerateControl: NotRequired[Av1FramerateControlType],  # (4)
    FramerateConversionAlgorithm: NotRequired[Av1FramerateConversionAlgorithmType],  # (5)
    FramerateDenominator: NotRequired[int],
    FramerateNumerator: NotRequired[int],
    GopSize: NotRequired[float],
    MaxBitrate: NotRequired[int],
    NumberBFramesBetweenReferenceFrames: NotRequired[int],
    QvbrSettings: NotRequired[Av1QvbrSettingsTypeDef],  # (6)
    RateControlMode: NotRequired[Av1RateControlModeType],  # (7)
    Slices: NotRequired[int],
    SpatialAdaptiveQuantization: NotRequired[Av1SpatialAdaptiveQuantizationType],  # (8)

AvcIntraSettingsTypeDef#

# AvcIntraSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AvcIntraSettingsTypeDef


def get_value() -> AvcIntraSettingsTypeDef:
    return {
        "AvcIntraClass": ...,
    }


# AvcIntraSettingsTypeDef definition

class AvcIntraSettingsTypeDef(TypedDict):
    AvcIntraClass: NotRequired[AvcIntraClassType],  # (1)
    AvcIntraUhdSettings: NotRequired[AvcIntraUhdSettingsTypeDef],  # (2)
    FramerateControl: NotRequired[AvcIntraFramerateControlType],  # (3)
    FramerateConversionAlgorithm: NotRequired[AvcIntraFramerateConversionAlgorithmType],  # (4)
    FramerateDenominator: NotRequired[int],
    FramerateNumerator: NotRequired[int],
    InterlaceMode: NotRequired[AvcIntraInterlaceModeType],  # (5)
    ScanTypeConversionMode: NotRequired[AvcIntraScanTypeConversionModeType],  # (6)
    SlowPal: NotRequired[AvcIntraSlowPalType],  # (7)
    Telecine: NotRequired[AvcIntraTelecineType],  # (8)

See AvcIntraClassType
See AvcIntraUhdSettingsTypeDef
See AvcIntraFramerateControlType
See AvcIntraFramerateConversionAlgorithmType
See AvcIntraInterlaceModeType
See AvcIntraScanTypeConversionModeType
See AvcIntraSlowPalType
See AvcIntraTelecineType

CaptionDestinationSettingsOutputTypeDef#

# CaptionDestinationSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CaptionDestinationSettingsOutputTypeDef


def get_value() -> CaptionDestinationSettingsOutputTypeDef:
    return {
        "BurninDestinationSettings": ...,
    }


# CaptionDestinationSettingsOutputTypeDef definition

class CaptionDestinationSettingsOutputTypeDef(TypedDict):
    BurninDestinationSettings: NotRequired[BurninDestinationSettingsTypeDef],  # (1)
    DestinationType: NotRequired[CaptionDestinationTypeType],  # (2)
    DvbSubDestinationSettings: NotRequired[DvbSubDestinationSettingsTypeDef],  # (3)
    EmbeddedDestinationSettings: NotRequired[EmbeddedDestinationSettingsTypeDef],  # (4)
    ImscDestinationSettings: NotRequired[ImscDestinationSettingsTypeDef],  # (5)
    SccDestinationSettings: NotRequired[SccDestinationSettingsTypeDef],  # (6)
    SrtDestinationSettings: NotRequired[SrtDestinationSettingsTypeDef],  # (7)
    TeletextDestinationSettings: NotRequired[TeletextDestinationSettingsOutputTypeDef],  # (8)
    TtmlDestinationSettings: NotRequired[TtmlDestinationSettingsTypeDef],  # (9)
    WebvttDestinationSettings: NotRequired[WebvttDestinationSettingsTypeDef],  # (10)

See BurninDestinationSettingsTypeDef
See CaptionDestinationTypeType
See DvbSubDestinationSettingsTypeDef
See EmbeddedDestinationSettingsTypeDef
See ImscDestinationSettingsTypeDef
See SccDestinationSettingsTypeDef
See SrtDestinationSettingsTypeDef
See TeletextDestinationSettingsOutputTypeDef
See TtmlDestinationSettingsTypeDef
See WebvttDestinationSettingsTypeDef

CaptionDestinationSettingsTypeDef#

# CaptionDestinationSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CaptionDestinationSettingsTypeDef


def get_value() -> CaptionDestinationSettingsTypeDef:
    return {
        "BurninDestinationSettings": ...,
    }


# CaptionDestinationSettingsTypeDef definition

class CaptionDestinationSettingsTypeDef(TypedDict):
    BurninDestinationSettings: NotRequired[BurninDestinationSettingsTypeDef],  # (1)
    DestinationType: NotRequired[CaptionDestinationTypeType],  # (2)
    DvbSubDestinationSettings: NotRequired[DvbSubDestinationSettingsTypeDef],  # (3)
    EmbeddedDestinationSettings: NotRequired[EmbeddedDestinationSettingsTypeDef],  # (4)
    ImscDestinationSettings: NotRequired[ImscDestinationSettingsTypeDef],  # (5)
    SccDestinationSettings: NotRequired[SccDestinationSettingsTypeDef],  # (6)
    SrtDestinationSettings: NotRequired[SrtDestinationSettingsTypeDef],  # (7)
    TeletextDestinationSettings: NotRequired[TeletextDestinationSettingsTypeDef],  # (8)
    TtmlDestinationSettings: NotRequired[TtmlDestinationSettingsTypeDef],  # (9)
    WebvttDestinationSettings: NotRequired[WebvttDestinationSettingsTypeDef],  # (10)

FileSourceSettingsTypeDef#

# FileSourceSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import FileSourceSettingsTypeDef


def get_value() -> FileSourceSettingsTypeDef:
    return {
        "ByteRateLimit": ...,
    }


# FileSourceSettingsTypeDef definition

class FileSourceSettingsTypeDef(TypedDict):
    ByteRateLimit: NotRequired[CaptionSourceByteRateLimitType],  # (1)
    Convert608To708: NotRequired[FileSourceConvert608To708Type],  # (2)
    ConvertPaintToPop: NotRequired[CaptionSourceConvertPaintOnToPopOnType],  # (3)
    Framerate: NotRequired[CaptionSourceFramerateTypeDef],  # (4)
    SourceFile: NotRequired[str],
    TimeDelta: NotRequired[int],
    TimeDeltaUnits: NotRequired[FileSourceTimeDeltaUnitsType],  # (5)

See CaptionSourceByteRateLimitType
See FileSourceConvert608To708Type
See CaptionSourceConvertPaintOnToPopOnType
See CaptionSourceFramerateTypeDef
See FileSourceTimeDeltaUnitsType

ChannelMappingOutputTypeDef#

# ChannelMappingOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ChannelMappingOutputTypeDef


def get_value() -> ChannelMappingOutputTypeDef:
    return {
        "OutputChannels": ...,
    }


# ChannelMappingOutputTypeDef definition

class ChannelMappingOutputTypeDef(TypedDict):
    OutputChannels: NotRequired[List[OutputChannelMappingOutputTypeDef]],  # (1)

See List[OutputChannelMappingOutputTypeDef]

ChannelMappingTypeDef#

# ChannelMappingTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ChannelMappingTypeDef


def get_value() -> ChannelMappingTypeDef:
    return {
        "OutputChannels": ...,
    }


# ChannelMappingTypeDef definition

class ChannelMappingTypeDef(TypedDict):
    OutputChannels: NotRequired[Sequence[OutputChannelMappingTypeDef]],  # (1)

See Sequence[OutputChannelMappingTypeDef]

ColorCorrectorTypeDef#

# ColorCorrectorTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ColorCorrectorTypeDef


def get_value() -> ColorCorrectorTypeDef:
    return {
        "Brightness": ...,
    }


# ColorCorrectorTypeDef definition

class ColorCorrectorTypeDef(TypedDict):
    Brightness: NotRequired[int],
    ClipLimits: NotRequired[ClipLimitsTypeDef],  # (1)
    ColorSpaceConversion: NotRequired[ColorSpaceConversionType],  # (2)
    Contrast: NotRequired[int],
    Hdr10Metadata: NotRequired[Hdr10MetadataTypeDef],  # (3)
    HdrToSdrToneMapper: NotRequired[HDRToSDRToneMapperType],  # (4)
    Hue: NotRequired[int],
    MaxLuminance: NotRequired[int],
    SampleRangeConversion: NotRequired[SampleRangeConversionType],  # (5)
    Saturation: NotRequired[int],
    SdrReferenceWhiteLevel: NotRequired[int],

VideoSelectorTypeDef#

# VideoSelectorTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import VideoSelectorTypeDef


def get_value() -> VideoSelectorTypeDef:
    return {
        "AlphaBehavior": ...,
    }


# VideoSelectorTypeDef definition

class VideoSelectorTypeDef(TypedDict):
    AlphaBehavior: NotRequired[AlphaBehaviorType],  # (1)
    ColorSpace: NotRequired[ColorSpaceType],  # (2)
    ColorSpaceUsage: NotRequired[ColorSpaceUsageType],  # (3)
    EmbeddedTimecodeOverride: NotRequired[EmbeddedTimecodeOverrideType],  # (4)
    Hdr10Metadata: NotRequired[Hdr10MetadataTypeDef],  # (5)
    MaxLuminance: NotRequired[int],
    PadVideo: NotRequired[PadVideoType],  # (6)
    Pid: NotRequired[int],
    ProgramNumber: NotRequired[int],
    Rotate: NotRequired[InputRotateType],  # (7)
    SampleRange: NotRequired[InputSampleRangeType],  # (8)

CreateQueueRequestTypeDef#

# CreateQueueRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CreateQueueRequestTypeDef


def get_value() -> CreateQueueRequestTypeDef:
    return {
        "Name": ...,
    }


# CreateQueueRequestTypeDef definition

class CreateQueueRequestTypeDef(TypedDict):
    Name: str,
    ConcurrentJobs: NotRequired[int],
    Description: NotRequired[str],
    PricingPlan: NotRequired[PricingPlanType],  # (1)
    ReservationPlanSettings: NotRequired[ReservationPlanSettingsTypeDef],  # (2)
    Status: NotRequired[QueueStatusType],  # (3)
    Tags: NotRequired[Mapping[str, str]],

UpdateQueueRequestTypeDef#

# UpdateQueueRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import UpdateQueueRequestTypeDef


def get_value() -> UpdateQueueRequestTypeDef:
    return {
        "Name": ...,
    }


# UpdateQueueRequestTypeDef definition

class UpdateQueueRequestTypeDef(TypedDict):
    Name: str,
    ConcurrentJobs: NotRequired[int],
    Description: NotRequired[str],
    ReservationPlanSettings: NotRequired[ReservationPlanSettingsTypeDef],  # (1)
    Status: NotRequired[QueueStatusType],  # (2)

See ReservationPlanSettingsTypeDef
See QueueStatusType

DescribeEndpointsRequestPaginateTypeDef#

# DescribeEndpointsRequestPaginateTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DescribeEndpointsRequestPaginateTypeDef


def get_value() -> DescribeEndpointsRequestPaginateTypeDef:
    return {
        "Mode": ...,
    }


# DescribeEndpointsRequestPaginateTypeDef definition

class DescribeEndpointsRequestPaginateTypeDef(TypedDict):
    Mode: NotRequired[DescribeEndpointsModeType],  # (1)
    PaginationConfig: NotRequired[PaginatorConfigTypeDef],  # (2)

See DescribeEndpointsModeType
See PaginatorConfigTypeDef

ListJobTemplatesRequestPaginateTypeDef#

# ListJobTemplatesRequestPaginateTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListJobTemplatesRequestPaginateTypeDef


def get_value() -> ListJobTemplatesRequestPaginateTypeDef:
    return {
        "Category": ...,
    }


# ListJobTemplatesRequestPaginateTypeDef definition

class ListJobTemplatesRequestPaginateTypeDef(TypedDict):
    Category: NotRequired[str],
    ListBy: NotRequired[JobTemplateListByType],  # (1)
    Order: NotRequired[OrderType],  # (2)
    PaginationConfig: NotRequired[PaginatorConfigTypeDef],  # (3)

ListJobsRequestPaginateTypeDef#

# ListJobsRequestPaginateTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListJobsRequestPaginateTypeDef


def get_value() -> ListJobsRequestPaginateTypeDef:
    return {
        "Order": ...,
    }


# ListJobsRequestPaginateTypeDef definition

class ListJobsRequestPaginateTypeDef(TypedDict):
    Order: NotRequired[OrderType],  # (1)
    Queue: NotRequired[str],
    Status: NotRequired[JobStatusType],  # (2)
    PaginationConfig: NotRequired[PaginatorConfigTypeDef],  # (3)

ListPresetsRequestPaginateTypeDef#

# ListPresetsRequestPaginateTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListPresetsRequestPaginateTypeDef


def get_value() -> ListPresetsRequestPaginateTypeDef:
    return {
        "Category": ...,
    }


# ListPresetsRequestPaginateTypeDef definition

class ListPresetsRequestPaginateTypeDef(TypedDict):
    Category: NotRequired[str],
    ListBy: NotRequired[PresetListByType],  # (1)
    Order: NotRequired[OrderType],  # (2)
    PaginationConfig: NotRequired[PaginatorConfigTypeDef],  # (3)

ListQueuesRequestPaginateTypeDef#

# ListQueuesRequestPaginateTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListQueuesRequestPaginateTypeDef


def get_value() -> ListQueuesRequestPaginateTypeDef:
    return {
        "ListBy": ...,
    }


# ListQueuesRequestPaginateTypeDef definition

class ListQueuesRequestPaginateTypeDef(TypedDict):
    ListBy: NotRequired[QueueListByType],  # (1)
    Order: NotRequired[OrderType],  # (2)
    PaginationConfig: NotRequired[PaginatorConfigTypeDef],  # (3)

ListVersionsRequestPaginateTypeDef#

# ListVersionsRequestPaginateTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListVersionsRequestPaginateTypeDef


def get_value() -> ListVersionsRequestPaginateTypeDef:
    return {
        "PaginationConfig": ...,
    }


# ListVersionsRequestPaginateTypeDef definition

class ListVersionsRequestPaginateTypeDef(TypedDict):
    PaginationConfig: NotRequired[PaginatorConfigTypeDef],  # (1)

See PaginatorConfigTypeDef

SearchJobsRequestPaginateTypeDef#

# SearchJobsRequestPaginateTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import SearchJobsRequestPaginateTypeDef


def get_value() -> SearchJobsRequestPaginateTypeDef:
    return {
        "InputFile": ...,
    }


# SearchJobsRequestPaginateTypeDef definition

class SearchJobsRequestPaginateTypeDef(TypedDict):
    InputFile: NotRequired[str],
    Order: NotRequired[OrderType],  # (1)
    Queue: NotRequired[str],
    Status: NotRequired[JobStatusType],  # (2)
    PaginationConfig: NotRequired[PaginatorConfigTypeDef],  # (3)

DescribeEndpointsResponseTypeDef#

# DescribeEndpointsResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DescribeEndpointsResponseTypeDef


def get_value() -> DescribeEndpointsResponseTypeDef:
    return {
        "Endpoints": ...,
    }


# DescribeEndpointsResponseTypeDef definition

class DescribeEndpointsResponseTypeDef(TypedDict):
    Endpoints: List[EndpointTypeDef],  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)
    NextToken: NotRequired[str],

See List[EndpointTypeDef]
See ResponseMetadataTypeDef

DolbyVisionTypeDef#

# DolbyVisionTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DolbyVisionTypeDef


def get_value() -> DolbyVisionTypeDef:
    return {
        "L6Metadata": ...,
    }


# DolbyVisionTypeDef definition

class DolbyVisionTypeDef(TypedDict):
    L6Metadata: NotRequired[DolbyVisionLevel6MetadataTypeDef],  # (1)
    L6Mode: NotRequired[DolbyVisionLevel6ModeType],  # (2)
    Mapping: NotRequired[DolbyVisionMappingType],  # (3)
    Profile: NotRequired[DolbyVisionProfileType],  # (4)

SpekeKeyProviderCmafOutputTypeDef#

# SpekeKeyProviderCmafOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import SpekeKeyProviderCmafOutputTypeDef


def get_value() -> SpekeKeyProviderCmafOutputTypeDef:
    return {
        "CertificateArn": ...,
    }


# SpekeKeyProviderCmafOutputTypeDef definition

class SpekeKeyProviderCmafOutputTypeDef(TypedDict):
    CertificateArn: NotRequired[str],
    DashSignaledSystemIds: NotRequired[List[str]],
    EncryptionContractConfiguration: NotRequired[EncryptionContractConfigurationTypeDef],  # (1)
    HlsSignaledSystemIds: NotRequired[List[str]],
    ResourceId: NotRequired[str],
    Url: NotRequired[str],

See EncryptionContractConfigurationTypeDef

SpekeKeyProviderCmafTypeDef#

# SpekeKeyProviderCmafTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import SpekeKeyProviderCmafTypeDef


def get_value() -> SpekeKeyProviderCmafTypeDef:
    return {
        "CertificateArn": ...,
    }


# SpekeKeyProviderCmafTypeDef definition

class SpekeKeyProviderCmafTypeDef(TypedDict):
    CertificateArn: NotRequired[str],
    DashSignaledSystemIds: NotRequired[Sequence[str]],
    EncryptionContractConfiguration: NotRequired[EncryptionContractConfigurationTypeDef],  # (1)
    HlsSignaledSystemIds: NotRequired[Sequence[str]],
    ResourceId: NotRequired[str],
    Url: NotRequired[str],

See EncryptionContractConfigurationTypeDef

SpekeKeyProviderOutputTypeDef#

# SpekeKeyProviderOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import SpekeKeyProviderOutputTypeDef


def get_value() -> SpekeKeyProviderOutputTypeDef:
    return {
        "CertificateArn": ...,
    }


# SpekeKeyProviderOutputTypeDef definition

class SpekeKeyProviderOutputTypeDef(TypedDict):
    CertificateArn: NotRequired[str],
    EncryptionContractConfiguration: NotRequired[EncryptionContractConfigurationTypeDef],  # (1)
    ResourceId: NotRequired[str],
    SystemIds: NotRequired[List[str]],
    Url: NotRequired[str],

See EncryptionContractConfigurationTypeDef

SpekeKeyProviderTypeDef#

# SpekeKeyProviderTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import SpekeKeyProviderTypeDef


def get_value() -> SpekeKeyProviderTypeDef:
    return {
        "CertificateArn": ...,
    }


# SpekeKeyProviderTypeDef definition

class SpekeKeyProviderTypeDef(TypedDict):
    CertificateArn: NotRequired[str],
    EncryptionContractConfiguration: NotRequired[EncryptionContractConfigurationTypeDef],  # (1)
    ResourceId: NotRequired[str],
    SystemIds: NotRequired[Sequence[str]],
    Url: NotRequired[str],

See EncryptionContractConfigurationTypeDef

EsamSettingsTypeDef#

# EsamSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import EsamSettingsTypeDef


def get_value() -> EsamSettingsTypeDef:
    return {
        "ManifestConfirmConditionNotification": ...,
    }


# EsamSettingsTypeDef definition

class EsamSettingsTypeDef(TypedDict):
    ManifestConfirmConditionNotification: NotRequired[EsamManifestConfirmConditionNotificationTypeDef],  # (1)
    ResponseSignalPreroll: NotRequired[int],
    SignalProcessingNotification: NotRequired[EsamSignalProcessingNotificationTypeDef],  # (2)

GetPolicyResponseTypeDef#

# GetPolicyResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import GetPolicyResponseTypeDef


def get_value() -> GetPolicyResponseTypeDef:
    return {
        "Policy": ...,
    }


# GetPolicyResponseTypeDef definition

class GetPolicyResponseTypeDef(TypedDict):
    Policy: PolicyTypeDef,  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)

See PolicyTypeDef
See ResponseMetadataTypeDef

PutPolicyRequestTypeDef#

# PutPolicyRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import PutPolicyRequestTypeDef


def get_value() -> PutPolicyRequestTypeDef:
    return {
        "Policy": ...,
    }


# PutPolicyRequestTypeDef definition

class PutPolicyRequestTypeDef(TypedDict):
    Policy: PolicyTypeDef,  # (1)

See PolicyTypeDef

PutPolicyResponseTypeDef#

# PutPolicyResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import PutPolicyResponseTypeDef


def get_value() -> PutPolicyResponseTypeDef:
    return {
        "Policy": ...,
    }


# PutPolicyResponseTypeDef definition

class PutPolicyResponseTypeDef(TypedDict):
    Policy: PolicyTypeDef,  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)

See PolicyTypeDef
See ResponseMetadataTypeDef

H264SettingsTypeDef#

# H264SettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import H264SettingsTypeDef


def get_value() -> H264SettingsTypeDef:
    return {
        "AdaptiveQuantization": ...,
    }


# H264SettingsTypeDef definition

class H264SettingsTypeDef(TypedDict):
    AdaptiveQuantization: NotRequired[H264AdaptiveQuantizationType],  # (1)
    BandwidthReductionFilter: NotRequired[BandwidthReductionFilterTypeDef],  # (2)
    Bitrate: NotRequired[int],
    CodecLevel: NotRequired[H264CodecLevelType],  # (3)
    CodecProfile: NotRequired[H264CodecProfileType],  # (4)
    DynamicSubGop: NotRequired[H264DynamicSubGopType],  # (5)
    EndOfStreamMarkers: NotRequired[H264EndOfStreamMarkersType],  # (6)
    EntropyEncoding: NotRequired[H264EntropyEncodingType],  # (7)
    FieldEncoding: NotRequired[H264FieldEncodingType],  # (8)
    FlickerAdaptiveQuantization: NotRequired[H264FlickerAdaptiveQuantizationType],  # (9)
    FramerateControl: NotRequired[H264FramerateControlType],  # (10)
    FramerateConversionAlgorithm: NotRequired[H264FramerateConversionAlgorithmType],  # (11)
    FramerateDenominator: NotRequired[int],
    FramerateNumerator: NotRequired[int],
    GopBReference: NotRequired[H264GopBReferenceType],  # (12)
    GopClosedCadence: NotRequired[int],
    GopSize: NotRequired[float],
    GopSizeUnits: NotRequired[H264GopSizeUnitsType],  # (13)
    HrdBufferFinalFillPercentage: NotRequired[int],
    HrdBufferInitialFillPercentage: NotRequired[int],
    HrdBufferSize: NotRequired[int],
    InterlaceMode: NotRequired[H264InterlaceModeType],  # (14)
    MaxBitrate: NotRequired[int],
    MinIInterval: NotRequired[int],
    NumberBFramesBetweenReferenceFrames: NotRequired[int],
    NumberReferenceFrames: NotRequired[int],
    ParControl: NotRequired[H264ParControlType],  # (15)
    ParDenominator: NotRequired[int],
    ParNumerator: NotRequired[int],
    QualityTuningLevel: NotRequired[H264QualityTuningLevelType],  # (16)
    QvbrSettings: NotRequired[H264QvbrSettingsTypeDef],  # (17)
    RateControlMode: NotRequired[H264RateControlModeType],  # (18)
    RepeatPps: NotRequired[H264RepeatPpsType],  # (19)
    SaliencyAwareEncoding: NotRequired[H264SaliencyAwareEncodingType],  # (20)
    ScanTypeConversionMode: NotRequired[H264ScanTypeConversionModeType],  # (21)
    SceneChangeDetect: NotRequired[H264SceneChangeDetectType],  # (22)
    Slices: NotRequired[int],
    SlowPal: NotRequired[H264SlowPalType],  # (23)
    Softness: NotRequired[int],
    SpatialAdaptiveQuantization: NotRequired[H264SpatialAdaptiveQuantizationType],  # (24)
    Syntax: NotRequired[H264SyntaxType],  # (25)
    Telecine: NotRequired[H264TelecineType],  # (26)
    TemporalAdaptiveQuantization: NotRequired[H264TemporalAdaptiveQuantizationType],  # (27)
    UnregisteredSeiTimecode: NotRequired[H264UnregisteredSeiTimecodeType],  # (28)
    WriteMp4PackagingType: NotRequired[H264WriteMp4PackagingTypeType],  # (29)

See H264AdaptiveQuantizationType
See BandwidthReductionFilterTypeDef
See H264CodecLevelType
See H264CodecProfileType
See H264DynamicSubGopType
See H264EndOfStreamMarkersType
See H264EntropyEncodingType
See H264FieldEncodingType
See H264FlickerAdaptiveQuantizationType
See H264FramerateControlType
See H264FramerateConversionAlgorithmType
See H264GopBReferenceType
See H264GopSizeUnitsType
See H264InterlaceModeType
See H264ParControlType
See H264QualityTuningLevelType
See H264QvbrSettingsTypeDef
See H264RateControlModeType
See H264RepeatPpsType
See H264SaliencyAwareEncodingType
See H264ScanTypeConversionModeType
See H264SceneChangeDetectType
See H264SlowPalType
See H264SpatialAdaptiveQuantizationType
See H264SyntaxType
See H264TelecineType
See H264TemporalAdaptiveQuantizationType
See H264UnregisteredSeiTimecodeType
See H264WriteMp4PackagingTypeType

H265SettingsTypeDef#

# H265SettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import H265SettingsTypeDef


def get_value() -> H265SettingsTypeDef:
    return {
        "AdaptiveQuantization": ...,
    }


# H265SettingsTypeDef definition

class H265SettingsTypeDef(TypedDict):
    AdaptiveQuantization: NotRequired[H265AdaptiveQuantizationType],  # (1)
    AlternateTransferFunctionSei: NotRequired[H265AlternateTransferFunctionSeiType],  # (2)
    BandwidthReductionFilter: NotRequired[BandwidthReductionFilterTypeDef],  # (3)
    Bitrate: NotRequired[int],
    CodecLevel: NotRequired[H265CodecLevelType],  # (4)
    CodecProfile: NotRequired[H265CodecProfileType],  # (5)
    Deblocking: NotRequired[H265DeblockingType],  # (6)
    DynamicSubGop: NotRequired[H265DynamicSubGopType],  # (7)
    EndOfStreamMarkers: NotRequired[H265EndOfStreamMarkersType],  # (8)
    FlickerAdaptiveQuantization: NotRequired[H265FlickerAdaptiveQuantizationType],  # (9)
    FramerateControl: NotRequired[H265FramerateControlType],  # (10)
    FramerateConversionAlgorithm: NotRequired[H265FramerateConversionAlgorithmType],  # (11)
    FramerateDenominator: NotRequired[int],
    FramerateNumerator: NotRequired[int],
    GopBReference: NotRequired[H265GopBReferenceType],  # (12)
    GopClosedCadence: NotRequired[int],
    GopSize: NotRequired[float],
    GopSizeUnits: NotRequired[H265GopSizeUnitsType],  # (13)
    HrdBufferFinalFillPercentage: NotRequired[int],
    HrdBufferInitialFillPercentage: NotRequired[int],
    HrdBufferSize: NotRequired[int],
    InterlaceMode: NotRequired[H265InterlaceModeType],  # (14)
    MaxBitrate: NotRequired[int],
    MinIInterval: NotRequired[int],
    NumberBFramesBetweenReferenceFrames: NotRequired[int],
    NumberReferenceFrames: NotRequired[int],
    ParControl: NotRequired[H265ParControlType],  # (15)
    ParDenominator: NotRequired[int],
    ParNumerator: NotRequired[int],
    QualityTuningLevel: NotRequired[H265QualityTuningLevelType],  # (16)
    QvbrSettings: NotRequired[H265QvbrSettingsTypeDef],  # (17)
    RateControlMode: NotRequired[H265RateControlModeType],  # (18)
    SampleAdaptiveOffsetFilterMode: NotRequired[H265SampleAdaptiveOffsetFilterModeType],  # (19)
    ScanTypeConversionMode: NotRequired[H265ScanTypeConversionModeType],  # (20)
    SceneChangeDetect: NotRequired[H265SceneChangeDetectType],  # (21)
    Slices: NotRequired[int],
    SlowPal: NotRequired[H265SlowPalType],  # (22)
    SpatialAdaptiveQuantization: NotRequired[H265SpatialAdaptiveQuantizationType],  # (23)
    Telecine: NotRequired[H265TelecineType],  # (24)
    TemporalAdaptiveQuantization: NotRequired[H265TemporalAdaptiveQuantizationType],  # (25)
    TemporalIds: NotRequired[H265TemporalIdsType],  # (26)
    Tiles: NotRequired[H265TilesType],  # (27)
    UnregisteredSeiTimecode: NotRequired[H265UnregisteredSeiTimecodeType],  # (28)
    WriteMp4PackagingType: NotRequired[H265WriteMp4PackagingTypeType],  # (29)

See H265AdaptiveQuantizationType
See H265AlternateTransferFunctionSeiType
See BandwidthReductionFilterTypeDef
See H265CodecLevelType
See H265CodecProfileType
See H265DeblockingType
See H265DynamicSubGopType
See H265EndOfStreamMarkersType
See H265FlickerAdaptiveQuantizationType
See H265FramerateControlType
See H265FramerateConversionAlgorithmType
See H265GopBReferenceType
See H265GopSizeUnitsType
See H265InterlaceModeType
See H265ParControlType
See H265QualityTuningLevelType
See H265QvbrSettingsTypeDef
See H265RateControlModeType
See H265SampleAdaptiveOffsetFilterModeType
See H265ScanTypeConversionModeType
See H265SceneChangeDetectType
See H265SlowPalType
See H265SpatialAdaptiveQuantizationType
See H265TelecineType
See H265TemporalAdaptiveQuantizationType
See H265TemporalIdsType
See H265TilesType
See H265UnregisteredSeiTimecodeType
See H265WriteMp4PackagingTypeType

OutputSettingsTypeDef#

# OutputSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import OutputSettingsTypeDef


def get_value() -> OutputSettingsTypeDef:
    return {
        "HlsSettings": ...,
    }


# OutputSettingsTypeDef definition

class OutputSettingsTypeDef(TypedDict):
    HlsSettings: NotRequired[HlsSettingsTypeDef],  # (1)

See HlsSettingsTypeDef

TimedMetadataInsertionOutputTypeDef#

# TimedMetadataInsertionOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import TimedMetadataInsertionOutputTypeDef


def get_value() -> TimedMetadataInsertionOutputTypeDef:
    return {
        "Id3Insertions": ...,
    }


# TimedMetadataInsertionOutputTypeDef definition

class TimedMetadataInsertionOutputTypeDef(TypedDict):
    Id3Insertions: NotRequired[List[Id3InsertionTypeDef]],  # (1)

See List[Id3InsertionTypeDef]

TimedMetadataInsertionTypeDef#

# TimedMetadataInsertionTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import TimedMetadataInsertionTypeDef


def get_value() -> TimedMetadataInsertionTypeDef:
    return {
        "Id3Insertions": ...,
    }


# TimedMetadataInsertionTypeDef definition

class TimedMetadataInsertionTypeDef(TypedDict):
    Id3Insertions: NotRequired[Sequence[Id3InsertionTypeDef]],  # (1)

See Sequence[Id3InsertionTypeDef]

ImageInserterOutputTypeDef#

# ImageInserterOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ImageInserterOutputTypeDef


def get_value() -> ImageInserterOutputTypeDef:
    return {
        "InsertableImages": ...,
    }


# ImageInserterOutputTypeDef definition

class ImageInserterOutputTypeDef(TypedDict):
    InsertableImages: NotRequired[List[InsertableImageTypeDef]],  # (1)
    SdrReferenceWhiteLevel: NotRequired[int],

See List[InsertableImageTypeDef]

ImageInserterTypeDef#

# ImageInserterTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ImageInserterTypeDef


def get_value() -> ImageInserterTypeDef:
    return {
        "InsertableImages": ...,
    }


# ImageInserterTypeDef definition

class ImageInserterTypeDef(TypedDict):
    InsertableImages: NotRequired[Sequence[InsertableImageTypeDef]],  # (1)
    SdrReferenceWhiteLevel: NotRequired[int],

See Sequence[InsertableImageTypeDef]

ListVersionsResponseTypeDef#

# ListVersionsResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListVersionsResponseTypeDef


def get_value() -> ListVersionsResponseTypeDef:
    return {
        "NextToken": ...,
    }


# ListVersionsResponseTypeDef definition

class ListVersionsResponseTypeDef(TypedDict):
    Versions: List[JobEngineVersionTypeDef],  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)
    NextToken: NotRequired[str],

See List[JobEngineVersionTypeDef]
See ResponseMetadataTypeDef

ListTagsForResourceResponseTypeDef#

# ListTagsForResourceResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListTagsForResourceResponseTypeDef


def get_value() -> ListTagsForResourceResponseTypeDef:
    return {
        "ResourceTags": ...,
    }


# ListTagsForResourceResponseTypeDef definition

class ListTagsForResourceResponseTypeDef(TypedDict):
    ResourceTags: ResourceTagsTypeDef,  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)

See ResourceTagsTypeDef
See ResponseMetadataTypeDef

M2tsSettingsOutputTypeDef#

# M2tsSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import M2tsSettingsOutputTypeDef


def get_value() -> M2tsSettingsOutputTypeDef:
    return {
        "AudioBufferModel": ...,
    }


# M2tsSettingsOutputTypeDef definition

class M2tsSettingsOutputTypeDef(TypedDict):
    AudioBufferModel: NotRequired[M2tsAudioBufferModelType],  # (1)
    AudioDuration: NotRequired[M2tsAudioDurationType],  # (2)
    AudioFramesPerPes: NotRequired[int],
    AudioPids: NotRequired[List[int]],
    AudioPtsOffsetDelta: NotRequired[int],
    Bitrate: NotRequired[int],
    BufferModel: NotRequired[M2tsBufferModelType],  # (3)
    DataPTSControl: NotRequired[M2tsDataPtsControlType],  # (4)
    DvbNitSettings: NotRequired[DvbNitSettingsTypeDef],  # (5)
    DvbSdtSettings: NotRequired[DvbSdtSettingsTypeDef],  # (6)
    DvbSubPids: NotRequired[List[int]],
    DvbTdtSettings: NotRequired[DvbTdtSettingsTypeDef],  # (7)
    DvbTeletextPid: NotRequired[int],
    EbpAudioInterval: NotRequired[M2tsEbpAudioIntervalType],  # (8)
    EbpPlacement: NotRequired[M2tsEbpPlacementType],  # (9)
    EsRateInPes: NotRequired[M2tsEsRateInPesType],  # (10)
    ForceTsVideoEbpOrder: NotRequired[M2tsForceTsVideoEbpOrderType],  # (11)
    FragmentTime: NotRequired[float],
    KlvMetadata: NotRequired[M2tsKlvMetadataType],  # (12)
    MaxPcrInterval: NotRequired[int],
    MinEbpInterval: NotRequired[int],
    NielsenId3: NotRequired[M2tsNielsenId3Type],  # (13)
    NullPacketBitrate: NotRequired[float],
    PatInterval: NotRequired[int],
    PcrControl: NotRequired[M2tsPcrControlType],  # (14)
    PcrPid: NotRequired[int],
    PmtInterval: NotRequired[int],
    PmtPid: NotRequired[int],
    PreventBufferUnderflow: NotRequired[M2tsPreventBufferUnderflowType],  # (15)
    PrivateMetadataPid: NotRequired[int],
    ProgramNumber: NotRequired[int],
    PtsOffset: NotRequired[int],
    PtsOffsetMode: NotRequired[TsPtsOffsetType],  # (16)
    RateMode: NotRequired[M2tsRateModeType],  # (17)
    Scte35Esam: NotRequired[M2tsScte35EsamTypeDef],  # (18)
    Scte35Pid: NotRequired[int],
    Scte35Source: NotRequired[M2tsScte35SourceType],  # (19)
    SegmentationMarkers: NotRequired[M2tsSegmentationMarkersType],  # (20)
    SegmentationStyle: NotRequired[M2tsSegmentationStyleType],  # (21)
    SegmentationTime: NotRequired[float],
    TimedMetadataPid: NotRequired[int],
    TransportStreamId: NotRequired[int],
    VideoPid: NotRequired[int],

M2tsSettingsTypeDef#

# M2tsSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import M2tsSettingsTypeDef


def get_value() -> M2tsSettingsTypeDef:
    return {
        "AudioBufferModel": ...,
    }


# M2tsSettingsTypeDef definition

class M2tsSettingsTypeDef(TypedDict):
    AudioBufferModel: NotRequired[M2tsAudioBufferModelType],  # (1)
    AudioDuration: NotRequired[M2tsAudioDurationType],  # (2)
    AudioFramesPerPes: NotRequired[int],
    AudioPids: NotRequired[Sequence[int]],
    AudioPtsOffsetDelta: NotRequired[int],
    Bitrate: NotRequired[int],
    BufferModel: NotRequired[M2tsBufferModelType],  # (3)
    DataPTSControl: NotRequired[M2tsDataPtsControlType],  # (4)
    DvbNitSettings: NotRequired[DvbNitSettingsTypeDef],  # (5)
    DvbSdtSettings: NotRequired[DvbSdtSettingsTypeDef],  # (6)
    DvbSubPids: NotRequired[Sequence[int]],
    DvbTdtSettings: NotRequired[DvbTdtSettingsTypeDef],  # (7)
    DvbTeletextPid: NotRequired[int],
    EbpAudioInterval: NotRequired[M2tsEbpAudioIntervalType],  # (8)
    EbpPlacement: NotRequired[M2tsEbpPlacementType],  # (9)
    EsRateInPes: NotRequired[M2tsEsRateInPesType],  # (10)
    ForceTsVideoEbpOrder: NotRequired[M2tsForceTsVideoEbpOrderType],  # (11)
    FragmentTime: NotRequired[float],
    KlvMetadata: NotRequired[M2tsKlvMetadataType],  # (12)
    MaxPcrInterval: NotRequired[int],
    MinEbpInterval: NotRequired[int],
    NielsenId3: NotRequired[M2tsNielsenId3Type],  # (13)
    NullPacketBitrate: NotRequired[float],
    PatInterval: NotRequired[int],
    PcrControl: NotRequired[M2tsPcrControlType],  # (14)
    PcrPid: NotRequired[int],
    PmtInterval: NotRequired[int],
    PmtPid: NotRequired[int],
    PreventBufferUnderflow: NotRequired[M2tsPreventBufferUnderflowType],  # (15)
    PrivateMetadataPid: NotRequired[int],
    ProgramNumber: NotRequired[int],
    PtsOffset: NotRequired[int],
    PtsOffsetMode: NotRequired[TsPtsOffsetType],  # (16)
    RateMode: NotRequired[M2tsRateModeType],  # (17)
    Scte35Esam: NotRequired[M2tsScte35EsamTypeDef],  # (18)
    Scte35Pid: NotRequired[int],
    Scte35Source: NotRequired[M2tsScte35SourceType],  # (19)
    SegmentationMarkers: NotRequired[M2tsSegmentationMarkersType],  # (20)
    SegmentationStyle: NotRequired[M2tsSegmentationStyleType],  # (21)
    SegmentationTime: NotRequired[float],
    TimedMetadataPid: NotRequired[int],
    TransportStreamId: NotRequired[int],
    VideoPid: NotRequired[int],

MotionImageInserterTypeDef#

# MotionImageInserterTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import MotionImageInserterTypeDef


def get_value() -> MotionImageInserterTypeDef:
    return {
        "Framerate": ...,
    }


# MotionImageInserterTypeDef definition

class MotionImageInserterTypeDef(TypedDict):
    Framerate: NotRequired[MotionImageInsertionFramerateTypeDef],  # (1)
    Input: NotRequired[str],
    InsertionMode: NotRequired[MotionImageInsertionModeType],  # (2)
    Offset: NotRequired[MotionImageInsertionOffsetTypeDef],  # (3)
    Playback: NotRequired[MotionImagePlaybackType],  # (4)
    StartTime: NotRequired[str],

See MotionImageInsertionFramerateTypeDef
See MotionImageInsertionModeType
See MotionImageInsertionOffsetTypeDef
See MotionImagePlaybackType

MxfSettingsTypeDef#

# MxfSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import MxfSettingsTypeDef


def get_value() -> MxfSettingsTypeDef:
    return {
        "AfdSignaling": ...,
    }


# MxfSettingsTypeDef definition

class MxfSettingsTypeDef(TypedDict):
    AfdSignaling: NotRequired[MxfAfdSignalingType],  # (1)
    Profile: NotRequired[MxfProfileType],  # (2)
    XavcProfileSettings: NotRequired[MxfXavcProfileSettingsTypeDef],  # (3)

PartnerWatermarkingTypeDef#

# PartnerWatermarkingTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import PartnerWatermarkingTypeDef


def get_value() -> PartnerWatermarkingTypeDef:
    return {
        "NexguardFileMarkerSettings": ...,
    }


# PartnerWatermarkingTypeDef definition

class PartnerWatermarkingTypeDef(TypedDict):
    NexguardFileMarkerSettings: NotRequired[NexGuardFileMarkerSettingsTypeDef],  # (1)

See NexGuardFileMarkerSettingsTypeDef

NoiseReducerTypeDef#

# NoiseReducerTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import NoiseReducerTypeDef


def get_value() -> NoiseReducerTypeDef:
    return {
        "Filter": ...,
    }


# NoiseReducerTypeDef definition

class NoiseReducerTypeDef(TypedDict):
    Filter: NotRequired[NoiseReducerFilterType],  # (1)
    FilterSettings: NotRequired[NoiseReducerFilterSettingsTypeDef],  # (2)
    SpatialFilterSettings: NotRequired[NoiseReducerSpatialFilterSettingsTypeDef],  # (3)
    TemporalFilterSettings: NotRequired[NoiseReducerTemporalFilterSettingsTypeDef],  # (4)

OutputDetailTypeDef#

# OutputDetailTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import OutputDetailTypeDef


def get_value() -> OutputDetailTypeDef:
    return {
        "DurationInMs": ...,
    }


# OutputDetailTypeDef definition

class OutputDetailTypeDef(TypedDict):
    DurationInMs: NotRequired[int],
    VideoDetails: NotRequired[VideoDetailTypeDef],  # (1)

See VideoDetailTypeDef

ProbeRequestTypeDef#

# ProbeRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ProbeRequestTypeDef


def get_value() -> ProbeRequestTypeDef:
    return {
        "InputFiles": ...,
    }


# ProbeRequestTypeDef definition

class ProbeRequestTypeDef(TypedDict):
    InputFiles: NotRequired[Sequence[ProbeInputFileTypeDef]],  # (1)

See Sequence[ProbeInputFileTypeDef]

QueueTypeDef#

# QueueTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import QueueTypeDef


def get_value() -> QueueTypeDef:
    return {
        "Arn": ...,
    }


# QueueTypeDef definition

class QueueTypeDef(TypedDict):
    Name: str,
    Arn: NotRequired[str],
    ConcurrentJobs: NotRequired[int],
    CreatedAt: NotRequired[datetime.datetime],
    Description: NotRequired[str],
    LastUpdated: NotRequired[datetime.datetime],
    PricingPlan: NotRequired[PricingPlanType],  # (1)
    ProgressingJobsCount: NotRequired[int],
    ReservationPlan: NotRequired[ReservationPlanTypeDef],  # (2)
    ServiceOverrides: NotRequired[List[ServiceOverrideTypeDef]],  # (3)
    Status: NotRequired[QueueStatusType],  # (4)
    SubmittedJobsCount: NotRequired[int],
    Type: NotRequired[TypeType],  # (5)

See PricingPlanType
See ReservationPlanTypeDef
See List[ServiceOverrideTypeDef]
See QueueStatusType
See TypeType

S3DestinationSettingsTypeDef#

# S3DestinationSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import S3DestinationSettingsTypeDef


def get_value() -> S3DestinationSettingsTypeDef:
    return {
        "AccessControl": ...,
    }


# S3DestinationSettingsTypeDef definition

class S3DestinationSettingsTypeDef(TypedDict):
    AccessControl: NotRequired[S3DestinationAccessControlTypeDef],  # (1)
    Encryption: NotRequired[S3EncryptionSettingsTypeDef],  # (2)
    StorageClass: NotRequired[S3StorageClassType],  # (3)

VideoOverlayInputOutputTypeDef#

# VideoOverlayInputOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import VideoOverlayInputOutputTypeDef


def get_value() -> VideoOverlayInputOutputTypeDef:
    return {
        "FileInput": ...,
    }


# VideoOverlayInputOutputTypeDef definition

class VideoOverlayInputOutputTypeDef(TypedDict):
    FileInput: NotRequired[str],
    InputClippings: NotRequired[List[VideoOverlayInputClippingTypeDef]],  # (1)
    TimecodeSource: NotRequired[InputTimecodeSourceType],  # (2)
    TimecodeStart: NotRequired[str],

See List[VideoOverlayInputClippingTypeDef]
See InputTimecodeSourceType

VideoOverlayInputTypeDef#

# VideoOverlayInputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import VideoOverlayInputTypeDef


def get_value() -> VideoOverlayInputTypeDef:
    return {
        "FileInput": ...,
    }


# VideoOverlayInputTypeDef definition

class VideoOverlayInputTypeDef(TypedDict):
    FileInput: NotRequired[str],
    InputClippings: NotRequired[Sequence[VideoOverlayInputClippingTypeDef]],  # (1)
    TimecodeSource: NotRequired[InputTimecodeSourceType],  # (2)
    TimecodeStart: NotRequired[str],

See Sequence[VideoOverlayInputClippingTypeDef]
See InputTimecodeSourceType

VideoOverlayTransitionTypeDef#

# VideoOverlayTransitionTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import VideoOverlayTransitionTypeDef


def get_value() -> VideoOverlayTransitionTypeDef:
    return {
        "EndPosition": ...,
    }


# VideoOverlayTransitionTypeDef definition

class VideoOverlayTransitionTypeDef(TypedDict):
    EndPosition: NotRequired[VideoOverlayPositionTypeDef],  # (1)
    EndTimecode: NotRequired[str],
    StartTimecode: NotRequired[str],

See VideoOverlayPositionTypeDef

XavcSettingsTypeDef#

# XavcSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import XavcSettingsTypeDef


def get_value() -> XavcSettingsTypeDef:
    return {
        "AdaptiveQuantization": ...,
    }


# XavcSettingsTypeDef definition

class XavcSettingsTypeDef(TypedDict):
    AdaptiveQuantization: NotRequired[XavcAdaptiveQuantizationType],  # (1)
    EntropyEncoding: NotRequired[XavcEntropyEncodingType],  # (2)
    FramerateControl: NotRequired[XavcFramerateControlType],  # (3)
    FramerateConversionAlgorithm: NotRequired[XavcFramerateConversionAlgorithmType],  # (4)
    FramerateDenominator: NotRequired[int],
    FramerateNumerator: NotRequired[int],
    Profile: NotRequired[XavcProfileType],  # (5)
    SlowPal: NotRequired[XavcSlowPalType],  # (6)
    Softness: NotRequired[int],
    SpatialAdaptiveQuantization: NotRequired[XavcSpatialAdaptiveQuantizationType],  # (7)
    TemporalAdaptiveQuantization: NotRequired[XavcTemporalAdaptiveQuantizationType],  # (8)
    Xavc4kIntraCbgProfileSettings: NotRequired[Xavc4kIntraCbgProfileSettingsTypeDef],  # (9)
    Xavc4kIntraVbrProfileSettings: NotRequired[Xavc4kIntraVbrProfileSettingsTypeDef],  # (10)
    Xavc4kProfileSettings: NotRequired[Xavc4kProfileSettingsTypeDef],  # (11)
    XavcHdIntraCbgProfileSettings: NotRequired[XavcHdIntraCbgProfileSettingsTypeDef],  # (12)
    XavcHdProfileSettings: NotRequired[XavcHdProfileSettingsTypeDef],  # (13)

See XavcAdaptiveQuantizationType
See XavcEntropyEncodingType
See XavcFramerateControlType
See XavcFramerateConversionAlgorithmType
See XavcProfileType
See XavcSlowPalType
See XavcSpatialAdaptiveQuantizationType
See XavcTemporalAdaptiveQuantizationType
See Xavc4kIntraCbgProfileSettingsTypeDef
See Xavc4kIntraVbrProfileSettingsTypeDef
See Xavc4kProfileSettingsTypeDef
See XavcHdIntraCbgProfileSettingsTypeDef
See XavcHdProfileSettingsTypeDef

TrackTypeDef#

# TrackTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import TrackTypeDef


def get_value() -> TrackTypeDef:
    return {
        "AudioProperties": ...,
    }


# TrackTypeDef definition

class TrackTypeDef(TypedDict):
    AudioProperties: NotRequired[AudioPropertiesTypeDef],  # (1)
    Codec: NotRequired[CodecType],  # (2)
    DataProperties: NotRequired[DataPropertiesTypeDef],  # (3)
    Duration: NotRequired[float],
    Index: NotRequired[int],
    TrackType: NotRequired[TrackTypeType],  # (4)
    VideoProperties: NotRequired[VideoPropertiesTypeDef],  # (5)

AutomatedAbrSettingsOutputTypeDef#

# AutomatedAbrSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AutomatedAbrSettingsOutputTypeDef


def get_value() -> AutomatedAbrSettingsOutputTypeDef:
    return {
        "MaxAbrBitrate": ...,
    }


# AutomatedAbrSettingsOutputTypeDef definition

class AutomatedAbrSettingsOutputTypeDef(TypedDict):
    MaxAbrBitrate: NotRequired[int],
    MaxQualityLevel: NotRequired[float],
    MaxRenditions: NotRequired[int],
    MinAbrBitrate: NotRequired[int],
    Rules: NotRequired[List[AutomatedAbrRuleOutputTypeDef]],  # (1)

See List[AutomatedAbrRuleOutputTypeDef]

AutomatedAbrSettingsTypeDef#

# AutomatedAbrSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AutomatedAbrSettingsTypeDef


def get_value() -> AutomatedAbrSettingsTypeDef:
    return {
        "MaxAbrBitrate": ...,
    }


# AutomatedAbrSettingsTypeDef definition

class AutomatedAbrSettingsTypeDef(TypedDict):
    MaxAbrBitrate: NotRequired[int],
    MaxQualityLevel: NotRequired[float],
    MaxRenditions: NotRequired[int],
    MinAbrBitrate: NotRequired[int],
    Rules: NotRequired[Sequence[AutomatedAbrRuleTypeDef]],  # (1)

See Sequence[AutomatedAbrRuleTypeDef]

CaptionDescriptionOutputTypeDef#

# CaptionDescriptionOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CaptionDescriptionOutputTypeDef


def get_value() -> CaptionDescriptionOutputTypeDef:
    return {
        "CaptionSelectorName": ...,
    }


# CaptionDescriptionOutputTypeDef definition

class CaptionDescriptionOutputTypeDef(TypedDict):
    CaptionSelectorName: NotRequired[str],
    CustomLanguageCode: NotRequired[str],
    DestinationSettings: NotRequired[CaptionDestinationSettingsOutputTypeDef],  # (1)
    LanguageCode: NotRequired[LanguageCodeType],  # (2)
    LanguageDescription: NotRequired[str],

See CaptionDestinationSettingsOutputTypeDef
See LanguageCodeType

CaptionDescriptionPresetOutputTypeDef#

# CaptionDescriptionPresetOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CaptionDescriptionPresetOutputTypeDef


def get_value() -> CaptionDescriptionPresetOutputTypeDef:
    return {
        "CustomLanguageCode": ...,
    }


# CaptionDescriptionPresetOutputTypeDef definition

class CaptionDescriptionPresetOutputTypeDef(TypedDict):
    CustomLanguageCode: NotRequired[str],
    DestinationSettings: NotRequired[CaptionDestinationSettingsOutputTypeDef],  # (1)
    LanguageCode: NotRequired[LanguageCodeType],  # (2)
    LanguageDescription: NotRequired[str],

See CaptionDestinationSettingsOutputTypeDef
See LanguageCodeType

CaptionDescriptionPresetTypeDef#

# CaptionDescriptionPresetTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CaptionDescriptionPresetTypeDef


def get_value() -> CaptionDescriptionPresetTypeDef:
    return {
        "CustomLanguageCode": ...,
    }


# CaptionDescriptionPresetTypeDef definition

class CaptionDescriptionPresetTypeDef(TypedDict):
    CustomLanguageCode: NotRequired[str],
    DestinationSettings: NotRequired[CaptionDestinationSettingsTypeDef],  # (1)
    LanguageCode: NotRequired[LanguageCodeType],  # (2)
    LanguageDescription: NotRequired[str],

See CaptionDestinationSettingsTypeDef
See LanguageCodeType

CaptionDescriptionTypeDef#

# CaptionDescriptionTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CaptionDescriptionTypeDef


def get_value() -> CaptionDescriptionTypeDef:
    return {
        "CaptionSelectorName": ...,
    }


# CaptionDescriptionTypeDef definition

class CaptionDescriptionTypeDef(TypedDict):
    CaptionSelectorName: NotRequired[str],
    CustomLanguageCode: NotRequired[str],
    DestinationSettings: NotRequired[CaptionDestinationSettingsTypeDef],  # (1)
    LanguageCode: NotRequired[LanguageCodeType],  # (2)
    LanguageDescription: NotRequired[str],

See CaptionDestinationSettingsTypeDef
See LanguageCodeType

CaptionSourceSettingsTypeDef#

# CaptionSourceSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CaptionSourceSettingsTypeDef


def get_value() -> CaptionSourceSettingsTypeDef:
    return {
        "AncillarySourceSettings": ...,
    }


# CaptionSourceSettingsTypeDef definition

class CaptionSourceSettingsTypeDef(TypedDict):
    AncillarySourceSettings: NotRequired[AncillarySourceSettingsTypeDef],  # (1)
    DvbSubSourceSettings: NotRequired[DvbSubSourceSettingsTypeDef],  # (2)
    EmbeddedSourceSettings: NotRequired[EmbeddedSourceSettingsTypeDef],  # (3)
    FileSourceSettings: NotRequired[FileSourceSettingsTypeDef],  # (4)
    SourceType: NotRequired[CaptionSourceTypeType],  # (5)
    TeletextSourceSettings: NotRequired[TeletextSourceSettingsTypeDef],  # (6)
    TrackSourceSettings: NotRequired[TrackSourceSettingsTypeDef],  # (7)
    WebvttHlsSourceSettings: NotRequired[WebvttHlsSourceSettingsTypeDef],  # (8)

RemixSettingsOutputTypeDef#

# RemixSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import RemixSettingsOutputTypeDef


def get_value() -> RemixSettingsOutputTypeDef:
    return {
        "AudioDescriptionAudioChannel": ...,
    }


# RemixSettingsOutputTypeDef definition

class RemixSettingsOutputTypeDef(TypedDict):
    AudioDescriptionAudioChannel: NotRequired[int],
    AudioDescriptionDataChannel: NotRequired[int],
    ChannelMapping: NotRequired[ChannelMappingOutputTypeDef],  # (1)
    ChannelsIn: NotRequired[int],
    ChannelsOut: NotRequired[int],

See ChannelMappingOutputTypeDef

RemixSettingsTypeDef#

# RemixSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import RemixSettingsTypeDef


def get_value() -> RemixSettingsTypeDef:
    return {
        "AudioDescriptionAudioChannel": ...,
    }


# RemixSettingsTypeDef definition

class RemixSettingsTypeDef(TypedDict):
    AudioDescriptionAudioChannel: NotRequired[int],
    AudioDescriptionDataChannel: NotRequired[int],
    ChannelMapping: NotRequired[ChannelMappingTypeDef],  # (1)
    ChannelsIn: NotRequired[int],
    ChannelsOut: NotRequired[int],

See ChannelMappingTypeDef

CmafEncryptionSettingsOutputTypeDef#

# CmafEncryptionSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CmafEncryptionSettingsOutputTypeDef


def get_value() -> CmafEncryptionSettingsOutputTypeDef:
    return {
        "ConstantInitializationVector": ...,
    }


# CmafEncryptionSettingsOutputTypeDef definition

class CmafEncryptionSettingsOutputTypeDef(TypedDict):
    ConstantInitializationVector: NotRequired[str],
    EncryptionMethod: NotRequired[CmafEncryptionTypeType],  # (1)
    InitializationVectorInManifest: NotRequired[CmafInitializationVectorInManifestType],  # (2)
    SpekeKeyProvider: NotRequired[SpekeKeyProviderCmafOutputTypeDef],  # (3)
    StaticKeyProvider: NotRequired[StaticKeyProviderTypeDef],  # (4)
    Type: NotRequired[CmafKeyProviderTypeType],  # (5)

See CmafEncryptionTypeType
See CmafInitializationVectorInManifestType
See SpekeKeyProviderCmafOutputTypeDef
See StaticKeyProviderTypeDef
See CmafKeyProviderTypeType

CmafEncryptionSettingsTypeDef#

# CmafEncryptionSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CmafEncryptionSettingsTypeDef


def get_value() -> CmafEncryptionSettingsTypeDef:
    return {
        "ConstantInitializationVector": ...,
    }


# CmafEncryptionSettingsTypeDef definition

class CmafEncryptionSettingsTypeDef(TypedDict):
    ConstantInitializationVector: NotRequired[str],
    EncryptionMethod: NotRequired[CmafEncryptionTypeType],  # (1)
    InitializationVectorInManifest: NotRequired[CmafInitializationVectorInManifestType],  # (2)
    SpekeKeyProvider: NotRequired[SpekeKeyProviderCmafTypeDef],  # (3)
    StaticKeyProvider: NotRequired[StaticKeyProviderTypeDef],  # (4)
    Type: NotRequired[CmafKeyProviderTypeType],  # (5)

See CmafEncryptionTypeType
See CmafInitializationVectorInManifestType
See SpekeKeyProviderCmafTypeDef
See StaticKeyProviderTypeDef
See CmafKeyProviderTypeType

DashIsoEncryptionSettingsOutputTypeDef#

# DashIsoEncryptionSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DashIsoEncryptionSettingsOutputTypeDef


def get_value() -> DashIsoEncryptionSettingsOutputTypeDef:
    return {
        "PlaybackDeviceCompatibility": ...,
    }


# DashIsoEncryptionSettingsOutputTypeDef definition

class DashIsoEncryptionSettingsOutputTypeDef(TypedDict):
    PlaybackDeviceCompatibility: NotRequired[DashIsoPlaybackDeviceCompatibilityType],  # (1)
    SpekeKeyProvider: NotRequired[SpekeKeyProviderOutputTypeDef],  # (2)

HlsEncryptionSettingsOutputTypeDef#

# HlsEncryptionSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import HlsEncryptionSettingsOutputTypeDef


def get_value() -> HlsEncryptionSettingsOutputTypeDef:
    return {
        "ConstantInitializationVector": ...,
    }


# HlsEncryptionSettingsOutputTypeDef definition

class HlsEncryptionSettingsOutputTypeDef(TypedDict):
    ConstantInitializationVector: NotRequired[str],
    EncryptionMethod: NotRequired[HlsEncryptionTypeType],  # (1)
    InitializationVectorInManifest: NotRequired[HlsInitializationVectorInManifestType],  # (2)
    OfflineEncrypted: NotRequired[HlsOfflineEncryptedType],  # (3)
    SpekeKeyProvider: NotRequired[SpekeKeyProviderOutputTypeDef],  # (4)
    StaticKeyProvider: NotRequired[StaticKeyProviderTypeDef],  # (5)
    Type: NotRequired[HlsKeyProviderTypeType],  # (6)

See HlsEncryptionTypeType
See HlsInitializationVectorInManifestType
See HlsOfflineEncryptedType
See SpekeKeyProviderOutputTypeDef
See StaticKeyProviderTypeDef
See HlsKeyProviderTypeType

MsSmoothEncryptionSettingsOutputTypeDef#

# MsSmoothEncryptionSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import MsSmoothEncryptionSettingsOutputTypeDef


def get_value() -> MsSmoothEncryptionSettingsOutputTypeDef:
    return {
        "SpekeKeyProvider": ...,
    }


# MsSmoothEncryptionSettingsOutputTypeDef definition

class MsSmoothEncryptionSettingsOutputTypeDef(TypedDict):
    SpekeKeyProvider: NotRequired[SpekeKeyProviderOutputTypeDef],  # (1)

See SpekeKeyProviderOutputTypeDef

DashIsoEncryptionSettingsTypeDef#

# DashIsoEncryptionSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DashIsoEncryptionSettingsTypeDef


def get_value() -> DashIsoEncryptionSettingsTypeDef:
    return {
        "PlaybackDeviceCompatibility": ...,
    }


# DashIsoEncryptionSettingsTypeDef definition

class DashIsoEncryptionSettingsTypeDef(TypedDict):
    PlaybackDeviceCompatibility: NotRequired[DashIsoPlaybackDeviceCompatibilityType],  # (1)
    SpekeKeyProvider: NotRequired[SpekeKeyProviderTypeDef],  # (2)

HlsEncryptionSettingsTypeDef#

# HlsEncryptionSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import HlsEncryptionSettingsTypeDef


def get_value() -> HlsEncryptionSettingsTypeDef:
    return {
        "ConstantInitializationVector": ...,
    }


# HlsEncryptionSettingsTypeDef definition

class HlsEncryptionSettingsTypeDef(TypedDict):
    ConstantInitializationVector: NotRequired[str],
    EncryptionMethod: NotRequired[HlsEncryptionTypeType],  # (1)
    InitializationVectorInManifest: NotRequired[HlsInitializationVectorInManifestType],  # (2)
    OfflineEncrypted: NotRequired[HlsOfflineEncryptedType],  # (3)
    SpekeKeyProvider: NotRequired[SpekeKeyProviderTypeDef],  # (4)
    StaticKeyProvider: NotRequired[StaticKeyProviderTypeDef],  # (5)
    Type: NotRequired[HlsKeyProviderTypeType],  # (6)

See HlsEncryptionTypeType
See HlsInitializationVectorInManifestType
See HlsOfflineEncryptedType
See SpekeKeyProviderTypeDef
See StaticKeyProviderTypeDef
See HlsKeyProviderTypeType

MsSmoothEncryptionSettingsTypeDef#

# MsSmoothEncryptionSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import MsSmoothEncryptionSettingsTypeDef


def get_value() -> MsSmoothEncryptionSettingsTypeDef:
    return {
        "SpekeKeyProvider": ...,
    }


# MsSmoothEncryptionSettingsTypeDef definition

class MsSmoothEncryptionSettingsTypeDef(TypedDict):
    SpekeKeyProvider: NotRequired[SpekeKeyProviderTypeDef],  # (1)

See SpekeKeyProviderTypeDef

ContainerSettingsOutputTypeDef#

# ContainerSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ContainerSettingsOutputTypeDef


def get_value() -> ContainerSettingsOutputTypeDef:
    return {
        "CmfcSettings": ...,
    }


# ContainerSettingsOutputTypeDef definition

class ContainerSettingsOutputTypeDef(TypedDict):
    CmfcSettings: NotRequired[CmfcSettingsTypeDef],  # (1)
    Container: NotRequired[ContainerTypeType],  # (2)
    F4vSettings: NotRequired[F4vSettingsTypeDef],  # (3)
    M2tsSettings: NotRequired[M2tsSettingsOutputTypeDef],  # (4)
    M3u8Settings: NotRequired[M3u8SettingsOutputTypeDef],  # (5)
    MovSettings: NotRequired[MovSettingsTypeDef],  # (6)
    Mp4Settings: NotRequired[Mp4SettingsTypeDef],  # (7)
    MpdSettings: NotRequired[MpdSettingsTypeDef],  # (8)
    MxfSettings: NotRequired[MxfSettingsTypeDef],  # (9)

ContainerSettingsTypeDef#

# ContainerSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ContainerSettingsTypeDef


def get_value() -> ContainerSettingsTypeDef:
    return {
        "CmfcSettings": ...,
    }


# ContainerSettingsTypeDef definition

class ContainerSettingsTypeDef(TypedDict):
    CmfcSettings: NotRequired[CmfcSettingsTypeDef],  # (1)
    Container: NotRequired[ContainerTypeType],  # (2)
    F4vSettings: NotRequired[F4vSettingsTypeDef],  # (3)
    M2tsSettings: NotRequired[M2tsSettingsTypeDef],  # (4)
    M3u8Settings: NotRequired[M3u8SettingsTypeDef],  # (5)
    MovSettings: NotRequired[MovSettingsTypeDef],  # (6)
    Mp4Settings: NotRequired[Mp4SettingsTypeDef],  # (7)
    MpdSettings: NotRequired[MpdSettingsTypeDef],  # (8)
    MxfSettings: NotRequired[MxfSettingsTypeDef],  # (9)

VideoPreprocessorOutputTypeDef#

# VideoPreprocessorOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import VideoPreprocessorOutputTypeDef


def get_value() -> VideoPreprocessorOutputTypeDef:
    return {
        "ColorCorrector": ...,
    }


# VideoPreprocessorOutputTypeDef definition

class VideoPreprocessorOutputTypeDef(TypedDict):
    ColorCorrector: NotRequired[ColorCorrectorTypeDef],  # (1)
    Deinterlacer: NotRequired[DeinterlacerTypeDef],  # (2)
    DolbyVision: NotRequired[DolbyVisionTypeDef],  # (3)
    Hdr10Plus: NotRequired[Hdr10PlusTypeDef],  # (4)
    ImageInserter: NotRequired[ImageInserterOutputTypeDef],  # (5)
    NoiseReducer: NotRequired[NoiseReducerTypeDef],  # (6)
    PartnerWatermarking: NotRequired[PartnerWatermarkingTypeDef],  # (7)
    TimecodeBurnin: NotRequired[TimecodeBurninTypeDef],  # (8)

VideoPreprocessorTypeDef#

# VideoPreprocessorTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import VideoPreprocessorTypeDef


def get_value() -> VideoPreprocessorTypeDef:
    return {
        "ColorCorrector": ...,
    }


# VideoPreprocessorTypeDef definition

class VideoPreprocessorTypeDef(TypedDict):
    ColorCorrector: NotRequired[ColorCorrectorTypeDef],  # (1)
    Deinterlacer: NotRequired[DeinterlacerTypeDef],  # (2)
    DolbyVision: NotRequired[DolbyVisionTypeDef],  # (3)
    Hdr10Plus: NotRequired[Hdr10PlusTypeDef],  # (4)
    ImageInserter: NotRequired[ImageInserterTypeDef],  # (5)
    NoiseReducer: NotRequired[NoiseReducerTypeDef],  # (6)
    PartnerWatermarking: NotRequired[PartnerWatermarkingTypeDef],  # (7)
    TimecodeBurnin: NotRequired[TimecodeBurninTypeDef],  # (8)

OutputGroupDetailTypeDef#

# OutputGroupDetailTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import OutputGroupDetailTypeDef


def get_value() -> OutputGroupDetailTypeDef:
    return {
        "OutputDetails": ...,
    }


# OutputGroupDetailTypeDef definition

class OutputGroupDetailTypeDef(TypedDict):
    OutputDetails: NotRequired[List[OutputDetailTypeDef]],  # (1)

See List[OutputDetailTypeDef]

CreateQueueResponseTypeDef#

# CreateQueueResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CreateQueueResponseTypeDef


def get_value() -> CreateQueueResponseTypeDef:
    return {
        "Queue": ...,
    }


# CreateQueueResponseTypeDef definition

class CreateQueueResponseTypeDef(TypedDict):
    Queue: QueueTypeDef,  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)

See QueueTypeDef
See ResponseMetadataTypeDef

GetQueueResponseTypeDef#

# GetQueueResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import GetQueueResponseTypeDef


def get_value() -> GetQueueResponseTypeDef:
    return {
        "Queue": ...,
    }


# GetQueueResponseTypeDef definition

class GetQueueResponseTypeDef(TypedDict):
    Queue: QueueTypeDef,  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)

See QueueTypeDef
See ResponseMetadataTypeDef

ListQueuesResponseTypeDef#

# ListQueuesResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListQueuesResponseTypeDef


def get_value() -> ListQueuesResponseTypeDef:
    return {
        "NextToken": ...,
    }


# ListQueuesResponseTypeDef definition

class ListQueuesResponseTypeDef(TypedDict):
    Queues: List[QueueTypeDef],  # (1)
    TotalConcurrentJobs: int,
    UnallocatedConcurrentJobs: int,
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)
    NextToken: NotRequired[str],

See List[QueueTypeDef]
See ResponseMetadataTypeDef

UpdateQueueResponseTypeDef#

# UpdateQueueResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import UpdateQueueResponseTypeDef


def get_value() -> UpdateQueueResponseTypeDef:
    return {
        "Queue": ...,
    }


# UpdateQueueResponseTypeDef definition

class UpdateQueueResponseTypeDef(TypedDict):
    Queue: QueueTypeDef,  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)

See QueueTypeDef
See ResponseMetadataTypeDef

DestinationSettingsTypeDef#

# DestinationSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DestinationSettingsTypeDef


def get_value() -> DestinationSettingsTypeDef:
    return {
        "S3Settings": ...,
    }


# DestinationSettingsTypeDef definition

class DestinationSettingsTypeDef(TypedDict):
    S3Settings: NotRequired[S3DestinationSettingsTypeDef],  # (1)

See S3DestinationSettingsTypeDef

VideoOverlayOutputTypeDef#

# VideoOverlayOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import VideoOverlayOutputTypeDef


def get_value() -> VideoOverlayOutputTypeDef:
    return {
        "EndTimecode": ...,
    }


# VideoOverlayOutputTypeDef definition

class VideoOverlayOutputTypeDef(TypedDict):
    EndTimecode: NotRequired[str],
    InitialPosition: NotRequired[VideoOverlayPositionTypeDef],  # (1)
    Input: NotRequired[VideoOverlayInputOutputTypeDef],  # (2)
    Playback: NotRequired[VideoOverlayPlayBackModeType],  # (3)
    StartTimecode: NotRequired[str],
    Transitions: NotRequired[List[VideoOverlayTransitionTypeDef]],  # (4)

See VideoOverlayPositionTypeDef
See VideoOverlayInputOutputTypeDef
See VideoOverlayPlayBackModeType
See List[VideoOverlayTransitionTypeDef]

VideoOverlayTypeDef#

# VideoOverlayTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import VideoOverlayTypeDef


def get_value() -> VideoOverlayTypeDef:
    return {
        "EndTimecode": ...,
    }


# VideoOverlayTypeDef definition

class VideoOverlayTypeDef(TypedDict):
    EndTimecode: NotRequired[str],
    InitialPosition: NotRequired[VideoOverlayPositionTypeDef],  # (1)
    Input: NotRequired[VideoOverlayInputTypeDef],  # (2)
    Playback: NotRequired[VideoOverlayPlayBackModeType],  # (3)
    StartTimecode: NotRequired[str],
    Transitions: NotRequired[Sequence[VideoOverlayTransitionTypeDef]],  # (4)

See VideoOverlayPositionTypeDef
See VideoOverlayInputTypeDef
See VideoOverlayPlayBackModeType
See Sequence[VideoOverlayTransitionTypeDef]

VideoCodecSettingsTypeDef#

# VideoCodecSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import VideoCodecSettingsTypeDef


def get_value() -> VideoCodecSettingsTypeDef:
    return {
        "Av1Settings": ...,
    }


# VideoCodecSettingsTypeDef definition

class VideoCodecSettingsTypeDef(TypedDict):
    Av1Settings: NotRequired[Av1SettingsTypeDef],  # (1)
    AvcIntraSettings: NotRequired[AvcIntraSettingsTypeDef],  # (2)
    Codec: NotRequired[VideoCodecType],  # (3)
    FrameCaptureSettings: NotRequired[FrameCaptureSettingsTypeDef],  # (4)
    GifSettings: NotRequired[GifSettingsTypeDef],  # (5)
    H264Settings: NotRequired[H264SettingsTypeDef],  # (6)
    H265Settings: NotRequired[H265SettingsTypeDef],  # (7)
    Mpeg2Settings: NotRequired[Mpeg2SettingsTypeDef],  # (8)
    ProresSettings: NotRequired[ProresSettingsTypeDef],  # (9)
    UncompressedSettings: NotRequired[UncompressedSettingsTypeDef],  # (10)
    Vc3Settings: NotRequired[Vc3SettingsTypeDef],  # (11)
    Vp8Settings: NotRequired[Vp8SettingsTypeDef],  # (12)
    Vp9Settings: NotRequired[Vp9SettingsTypeDef],  # (13)
    XavcSettings: NotRequired[XavcSettingsTypeDef],  # (14)

ContainerTypeDef#

# ContainerTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ContainerTypeDef


def get_value() -> ContainerTypeDef:
    return {
        "Duration": ...,
    }


# ContainerTypeDef definition

class ContainerTypeDef(TypedDict):
    Duration: NotRequired[float],
    Format: NotRequired[FormatType],  # (1)
    Tracks: NotRequired[List[TrackTypeDef]],  # (2)

See FormatType
See List[TrackTypeDef]

AutomatedEncodingSettingsOutputTypeDef#

# AutomatedEncodingSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AutomatedEncodingSettingsOutputTypeDef


def get_value() -> AutomatedEncodingSettingsOutputTypeDef:
    return {
        "AbrSettings": ...,
    }


# AutomatedEncodingSettingsOutputTypeDef definition

class AutomatedEncodingSettingsOutputTypeDef(TypedDict):
    AbrSettings: NotRequired[AutomatedAbrSettingsOutputTypeDef],  # (1)

See AutomatedAbrSettingsOutputTypeDef

AutomatedEncodingSettingsTypeDef#

# AutomatedEncodingSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AutomatedEncodingSettingsTypeDef


def get_value() -> AutomatedEncodingSettingsTypeDef:
    return {
        "AbrSettings": ...,
    }


# AutomatedEncodingSettingsTypeDef definition

class AutomatedEncodingSettingsTypeDef(TypedDict):
    AbrSettings: NotRequired[AutomatedAbrSettingsTypeDef],  # (1)

See AutomatedAbrSettingsTypeDef

CaptionSelectorTypeDef#

# CaptionSelectorTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CaptionSelectorTypeDef


def get_value() -> CaptionSelectorTypeDef:
    return {
        "CustomLanguageCode": ...,
    }


# CaptionSelectorTypeDef definition

class CaptionSelectorTypeDef(TypedDict):
    CustomLanguageCode: NotRequired[str],
    LanguageCode: NotRequired[LanguageCodeType],  # (1)
    SourceSettings: NotRequired[CaptionSourceSettingsTypeDef],  # (2)

See LanguageCodeType
See CaptionSourceSettingsTypeDef

AudioDescriptionOutputTypeDef#

# AudioDescriptionOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AudioDescriptionOutputTypeDef


def get_value() -> AudioDescriptionOutputTypeDef:
    return {
        "AudioChannelTaggingSettings": ...,
    }


# AudioDescriptionOutputTypeDef definition

class AudioDescriptionOutputTypeDef(TypedDict):
    AudioChannelTaggingSettings: NotRequired[AudioChannelTaggingSettingsOutputTypeDef],  # (1)
    AudioNormalizationSettings: NotRequired[AudioNormalizationSettingsTypeDef],  # (2)
    AudioSourceName: NotRequired[str],
    AudioType: NotRequired[int],
    AudioTypeControl: NotRequired[AudioTypeControlType],  # (3)
    CodecSettings: NotRequired[AudioCodecSettingsTypeDef],  # (4)
    CustomLanguageCode: NotRequired[str],
    LanguageCode: NotRequired[LanguageCodeType],  # (5)
    LanguageCodeControl: NotRequired[AudioLanguageCodeControlType],  # (6)
    RemixSettings: NotRequired[RemixSettingsOutputTypeDef],  # (7)
    StreamName: NotRequired[str],

See AudioChannelTaggingSettingsOutputTypeDef
See AudioNormalizationSettingsTypeDef
See AudioTypeControlType
See AudioCodecSettingsTypeDef
See LanguageCodeType
See AudioLanguageCodeControlType
See RemixSettingsOutputTypeDef

AudioSelectorOutputTypeDef#

# AudioSelectorOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AudioSelectorOutputTypeDef


def get_value() -> AudioSelectorOutputTypeDef:
    return {
        "AudioDurationCorrection": ...,
    }


# AudioSelectorOutputTypeDef definition

class AudioSelectorOutputTypeDef(TypedDict):
    AudioDurationCorrection: NotRequired[AudioDurationCorrectionType],  # (1)
    CustomLanguageCode: NotRequired[str],
    DefaultSelection: NotRequired[AudioDefaultSelectionType],  # (2)
    ExternalAudioFileInput: NotRequired[str],
    HlsRenditionGroupSettings: NotRequired[HlsRenditionGroupSettingsTypeDef],  # (3)
    LanguageCode: NotRequired[LanguageCodeType],  # (4)
    Offset: NotRequired[int],
    Pids: NotRequired[List[int]],
    ProgramSelection: NotRequired[int],
    RemixSettings: NotRequired[RemixSettingsOutputTypeDef],  # (5)
    SelectorType: NotRequired[AudioSelectorTypeType],  # (6)
    Tracks: NotRequired[List[int]],

AudioDescriptionTypeDef#

# AudioDescriptionTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AudioDescriptionTypeDef


def get_value() -> AudioDescriptionTypeDef:
    return {
        "AudioChannelTaggingSettings": ...,
    }


# AudioDescriptionTypeDef definition

class AudioDescriptionTypeDef(TypedDict):
    AudioChannelTaggingSettings: NotRequired[AudioChannelTaggingSettingsTypeDef],  # (1)
    AudioNormalizationSettings: NotRequired[AudioNormalizationSettingsTypeDef],  # (2)
    AudioSourceName: NotRequired[str],
    AudioType: NotRequired[int],
    AudioTypeControl: NotRequired[AudioTypeControlType],  # (3)
    CodecSettings: NotRequired[AudioCodecSettingsTypeDef],  # (4)
    CustomLanguageCode: NotRequired[str],
    LanguageCode: NotRequired[LanguageCodeType],  # (5)
    LanguageCodeControl: NotRequired[AudioLanguageCodeControlType],  # (6)
    RemixSettings: NotRequired[RemixSettingsTypeDef],  # (7)
    StreamName: NotRequired[str],

AudioSelectorTypeDef#

# AudioSelectorTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import AudioSelectorTypeDef


def get_value() -> AudioSelectorTypeDef:
    return {
        "AudioDurationCorrection": ...,
    }


# AudioSelectorTypeDef definition

class AudioSelectorTypeDef(TypedDict):
    AudioDurationCorrection: NotRequired[AudioDurationCorrectionType],  # (1)
    CustomLanguageCode: NotRequired[str],
    DefaultSelection: NotRequired[AudioDefaultSelectionType],  # (2)
    ExternalAudioFileInput: NotRequired[str],
    HlsRenditionGroupSettings: NotRequired[HlsRenditionGroupSettingsTypeDef],  # (3)
    LanguageCode: NotRequired[LanguageCodeType],  # (4)
    Offset: NotRequired[int],
    Pids: NotRequired[Sequence[int]],
    ProgramSelection: NotRequired[int],
    RemixSettings: NotRequired[RemixSettingsTypeDef],  # (5)
    SelectorType: NotRequired[AudioSelectorTypeType],  # (6)
    Tracks: NotRequired[Sequence[int]],

CmafGroupSettingsOutputTypeDef#

# CmafGroupSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CmafGroupSettingsOutputTypeDef


def get_value() -> CmafGroupSettingsOutputTypeDef:
    return {
        "AdditionalManifests": ...,
    }


# CmafGroupSettingsOutputTypeDef definition

class CmafGroupSettingsOutputTypeDef(TypedDict):
    AdditionalManifests: NotRequired[List[CmafAdditionalManifestOutputTypeDef]],  # (1)
    BaseUrl: NotRequired[str],
    ClientCache: NotRequired[CmafClientCacheType],  # (2)
    CodecSpecification: NotRequired[CmafCodecSpecificationType],  # (3)
    DashIFrameTrickPlayNameModifier: NotRequired[str],
    DashManifestStyle: NotRequired[DashManifestStyleType],  # (4)
    Destination: NotRequired[str],
    DestinationSettings: NotRequired[DestinationSettingsTypeDef],  # (5)
    Encryption: NotRequired[CmafEncryptionSettingsOutputTypeDef],  # (6)
    FragmentLength: NotRequired[int],
    ImageBasedTrickPlay: NotRequired[CmafImageBasedTrickPlayType],  # (7)
    ImageBasedTrickPlaySettings: NotRequired[CmafImageBasedTrickPlaySettingsTypeDef],  # (8)
    ManifestCompression: NotRequired[CmafManifestCompressionType],  # (9)
    ManifestDurationFormat: NotRequired[CmafManifestDurationFormatType],  # (10)
    MinBufferTime: NotRequired[int],
    MinFinalSegmentLength: NotRequired[float],
    MpdManifestBandwidthType: NotRequired[CmafMpdManifestBandwidthTypeType],  # (11)
    MpdProfile: NotRequired[CmafMpdProfileType],  # (12)
    PtsOffsetHandlingForBFrames: NotRequired[CmafPtsOffsetHandlingForBFramesType],  # (13)
    SegmentControl: NotRequired[CmafSegmentControlType],  # (14)
    SegmentLength: NotRequired[int],
    SegmentLengthControl: NotRequired[CmafSegmentLengthControlType],  # (15)
    StreamInfResolution: NotRequired[CmafStreamInfResolutionType],  # (16)
    TargetDurationCompatibilityMode: NotRequired[CmafTargetDurationCompatibilityModeType],  # (17)
    VideoCompositionOffsets: NotRequired[CmafVideoCompositionOffsetsType],  # (18)
    WriteDashManifest: NotRequired[CmafWriteDASHManifestType],  # (19)
    WriteHlsManifest: NotRequired[CmafWriteHLSManifestType],  # (20)
    WriteSegmentTimelineInRepresentation: NotRequired[CmafWriteSegmentTimelineInRepresentationType],  # (21)

See List[CmafAdditionalManifestOutputTypeDef]
See CmafClientCacheType
See CmafCodecSpecificationType
See DashManifestStyleType
See DestinationSettingsTypeDef
See CmafEncryptionSettingsOutputTypeDef
See CmafImageBasedTrickPlayType
See CmafImageBasedTrickPlaySettingsTypeDef
See CmafManifestCompressionType
See CmafManifestDurationFormatType
See CmafMpdManifestBandwidthTypeType
See CmafMpdProfileType
See CmafPtsOffsetHandlingForBFramesType
See CmafSegmentControlType
See CmafSegmentLengthControlType
See CmafStreamInfResolutionType
See CmafTargetDurationCompatibilityModeType
See CmafVideoCompositionOffsetsType
See CmafWriteDASHManifestType
See CmafWriteHLSManifestType
See CmafWriteSegmentTimelineInRepresentationType

CmafGroupSettingsTypeDef#

# CmafGroupSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CmafGroupSettingsTypeDef


def get_value() -> CmafGroupSettingsTypeDef:
    return {
        "AdditionalManifests": ...,
    }


# CmafGroupSettingsTypeDef definition

class CmafGroupSettingsTypeDef(TypedDict):
    AdditionalManifests: NotRequired[Sequence[CmafAdditionalManifestTypeDef]],  # (1)
    BaseUrl: NotRequired[str],
    ClientCache: NotRequired[CmafClientCacheType],  # (2)
    CodecSpecification: NotRequired[CmafCodecSpecificationType],  # (3)
    DashIFrameTrickPlayNameModifier: NotRequired[str],
    DashManifestStyle: NotRequired[DashManifestStyleType],  # (4)
    Destination: NotRequired[str],
    DestinationSettings: NotRequired[DestinationSettingsTypeDef],  # (5)
    Encryption: NotRequired[CmafEncryptionSettingsTypeDef],  # (6)
    FragmentLength: NotRequired[int],
    ImageBasedTrickPlay: NotRequired[CmafImageBasedTrickPlayType],  # (7)
    ImageBasedTrickPlaySettings: NotRequired[CmafImageBasedTrickPlaySettingsTypeDef],  # (8)
    ManifestCompression: NotRequired[CmafManifestCompressionType],  # (9)
    ManifestDurationFormat: NotRequired[CmafManifestDurationFormatType],  # (10)
    MinBufferTime: NotRequired[int],
    MinFinalSegmentLength: NotRequired[float],
    MpdManifestBandwidthType: NotRequired[CmafMpdManifestBandwidthTypeType],  # (11)
    MpdProfile: NotRequired[CmafMpdProfileType],  # (12)
    PtsOffsetHandlingForBFrames: NotRequired[CmafPtsOffsetHandlingForBFramesType],  # (13)
    SegmentControl: NotRequired[CmafSegmentControlType],  # (14)
    SegmentLength: NotRequired[int],
    SegmentLengthControl: NotRequired[CmafSegmentLengthControlType],  # (15)
    StreamInfResolution: NotRequired[CmafStreamInfResolutionType],  # (16)
    TargetDurationCompatibilityMode: NotRequired[CmafTargetDurationCompatibilityModeType],  # (17)
    VideoCompositionOffsets: NotRequired[CmafVideoCompositionOffsetsType],  # (18)
    WriteDashManifest: NotRequired[CmafWriteDASHManifestType],  # (19)
    WriteHlsManifest: NotRequired[CmafWriteHLSManifestType],  # (20)
    WriteSegmentTimelineInRepresentation: NotRequired[CmafWriteSegmentTimelineInRepresentationType],  # (21)

See Sequence[CmafAdditionalManifestTypeDef]
See CmafClientCacheType
See CmafCodecSpecificationType
See DashManifestStyleType
See DestinationSettingsTypeDef
See CmafEncryptionSettingsTypeDef
See CmafImageBasedTrickPlayType
See CmafImageBasedTrickPlaySettingsTypeDef
See CmafManifestCompressionType
See CmafManifestDurationFormatType
See CmafMpdManifestBandwidthTypeType
See CmafMpdProfileType
See CmafPtsOffsetHandlingForBFramesType
See CmafSegmentControlType
See CmafSegmentLengthControlType
See CmafStreamInfResolutionType
See CmafTargetDurationCompatibilityModeType
See CmafVideoCompositionOffsetsType
See CmafWriteDASHManifestType
See CmafWriteHLSManifestType
See CmafWriteSegmentTimelineInRepresentationType

DashIsoGroupSettingsOutputTypeDef#

# DashIsoGroupSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DashIsoGroupSettingsOutputTypeDef


def get_value() -> DashIsoGroupSettingsOutputTypeDef:
    return {
        "AdditionalManifests": ...,
    }


# DashIsoGroupSettingsOutputTypeDef definition

class DashIsoGroupSettingsOutputTypeDef(TypedDict):
    AdditionalManifests: NotRequired[List[DashAdditionalManifestOutputTypeDef]],  # (1)
    AudioChannelConfigSchemeIdUri: NotRequired[DashIsoGroupAudioChannelConfigSchemeIdUriType],  # (2)
    BaseUrl: NotRequired[str],
    DashIFrameTrickPlayNameModifier: NotRequired[str],
    DashManifestStyle: NotRequired[DashManifestStyleType],  # (3)
    Destination: NotRequired[str],
    DestinationSettings: NotRequired[DestinationSettingsTypeDef],  # (4)
    Encryption: NotRequired[DashIsoEncryptionSettingsOutputTypeDef],  # (5)
    FragmentLength: NotRequired[int],
    HbbtvCompliance: NotRequired[DashIsoHbbtvComplianceType],  # (6)
    ImageBasedTrickPlay: NotRequired[DashIsoImageBasedTrickPlayType],  # (7)
    ImageBasedTrickPlaySettings: NotRequired[DashIsoImageBasedTrickPlaySettingsTypeDef],  # (8)
    MinBufferTime: NotRequired[int],
    MinFinalSegmentLength: NotRequired[float],
    MpdManifestBandwidthType: NotRequired[DashIsoMpdManifestBandwidthTypeType],  # (9)
    MpdProfile: NotRequired[DashIsoMpdProfileType],  # (10)
    PtsOffsetHandlingForBFrames: NotRequired[DashIsoPtsOffsetHandlingForBFramesType],  # (11)
    SegmentControl: NotRequired[DashIsoSegmentControlType],  # (12)
    SegmentLength: NotRequired[int],
    SegmentLengthControl: NotRequired[DashIsoSegmentLengthControlType],  # (13)
    VideoCompositionOffsets: NotRequired[DashIsoVideoCompositionOffsetsType],  # (14)
    WriteSegmentTimelineInRepresentation: NotRequired[DashIsoWriteSegmentTimelineInRepresentationType],  # (15)

See List[DashAdditionalManifestOutputTypeDef]
See DashIsoGroupAudioChannelConfigSchemeIdUriType
See DashManifestStyleType
See DestinationSettingsTypeDef
See DashIsoEncryptionSettingsOutputTypeDef
See DashIsoHbbtvComplianceType
See DashIsoImageBasedTrickPlayType
See DashIsoImageBasedTrickPlaySettingsTypeDef
See DashIsoMpdManifestBandwidthTypeType
See DashIsoMpdProfileType
See DashIsoPtsOffsetHandlingForBFramesType
See DashIsoSegmentControlType
See DashIsoSegmentLengthControlType
See DashIsoVideoCompositionOffsetsType
See DashIsoWriteSegmentTimelineInRepresentationType

DashIsoGroupSettingsTypeDef#

# DashIsoGroupSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import DashIsoGroupSettingsTypeDef


def get_value() -> DashIsoGroupSettingsTypeDef:
    return {
        "AdditionalManifests": ...,
    }


# DashIsoGroupSettingsTypeDef definition

class DashIsoGroupSettingsTypeDef(TypedDict):
    AdditionalManifests: NotRequired[Sequence[DashAdditionalManifestTypeDef]],  # (1)
    AudioChannelConfigSchemeIdUri: NotRequired[DashIsoGroupAudioChannelConfigSchemeIdUriType],  # (2)
    BaseUrl: NotRequired[str],
    DashIFrameTrickPlayNameModifier: NotRequired[str],
    DashManifestStyle: NotRequired[DashManifestStyleType],  # (3)
    Destination: NotRequired[str],
    DestinationSettings: NotRequired[DestinationSettingsTypeDef],  # (4)
    Encryption: NotRequired[DashIsoEncryptionSettingsTypeDef],  # (5)
    FragmentLength: NotRequired[int],
    HbbtvCompliance: NotRequired[DashIsoHbbtvComplianceType],  # (6)
    ImageBasedTrickPlay: NotRequired[DashIsoImageBasedTrickPlayType],  # (7)
    ImageBasedTrickPlaySettings: NotRequired[DashIsoImageBasedTrickPlaySettingsTypeDef],  # (8)
    MinBufferTime: NotRequired[int],
    MinFinalSegmentLength: NotRequired[float],
    MpdManifestBandwidthType: NotRequired[DashIsoMpdManifestBandwidthTypeType],  # (9)
    MpdProfile: NotRequired[DashIsoMpdProfileType],  # (10)
    PtsOffsetHandlingForBFrames: NotRequired[DashIsoPtsOffsetHandlingForBFramesType],  # (11)
    SegmentControl: NotRequired[DashIsoSegmentControlType],  # (12)
    SegmentLength: NotRequired[int],
    SegmentLengthControl: NotRequired[DashIsoSegmentLengthControlType],  # (13)
    VideoCompositionOffsets: NotRequired[DashIsoVideoCompositionOffsetsType],  # (14)
    WriteSegmentTimelineInRepresentation: NotRequired[DashIsoWriteSegmentTimelineInRepresentationType],  # (15)

See Sequence[DashAdditionalManifestTypeDef]
See DashIsoGroupAudioChannelConfigSchemeIdUriType
See DashManifestStyleType
See DestinationSettingsTypeDef
See DashIsoEncryptionSettingsTypeDef
See DashIsoHbbtvComplianceType
See DashIsoImageBasedTrickPlayType
See DashIsoImageBasedTrickPlaySettingsTypeDef
See DashIsoMpdManifestBandwidthTypeType
See DashIsoMpdProfileType
See DashIsoPtsOffsetHandlingForBFramesType
See DashIsoSegmentControlType
See DashIsoSegmentLengthControlType
See DashIsoVideoCompositionOffsetsType
See DashIsoWriteSegmentTimelineInRepresentationType

FileGroupSettingsTypeDef#

# FileGroupSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import FileGroupSettingsTypeDef


def get_value() -> FileGroupSettingsTypeDef:
    return {
        "Destination": ...,
    }


# FileGroupSettingsTypeDef definition

class FileGroupSettingsTypeDef(TypedDict):
    Destination: NotRequired[str],
    DestinationSettings: NotRequired[DestinationSettingsTypeDef],  # (1)

See DestinationSettingsTypeDef

HlsGroupSettingsOutputTypeDef#

# HlsGroupSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import HlsGroupSettingsOutputTypeDef


def get_value() -> HlsGroupSettingsOutputTypeDef:
    return {
        "AdMarkers": ...,
    }


# HlsGroupSettingsOutputTypeDef definition

class HlsGroupSettingsOutputTypeDef(TypedDict):
    AdMarkers: NotRequired[List[HlsAdMarkersType]],  # (1)
    AdditionalManifests: NotRequired[List[HlsAdditionalManifestOutputTypeDef]],  # (2)
    AudioOnlyHeader: NotRequired[HlsAudioOnlyHeaderType],  # (3)
    BaseUrl: NotRequired[str],
    CaptionLanguageMappings: NotRequired[List[HlsCaptionLanguageMappingTypeDef]],  # (4)
    CaptionLanguageSetting: NotRequired[HlsCaptionLanguageSettingType],  # (5)
    CaptionSegmentLengthControl: NotRequired[HlsCaptionSegmentLengthControlType],  # (6)
    ClientCache: NotRequired[HlsClientCacheType],  # (7)
    CodecSpecification: NotRequired[HlsCodecSpecificationType],  # (8)
    Destination: NotRequired[str],
    DestinationSettings: NotRequired[DestinationSettingsTypeDef],  # (9)
    DirectoryStructure: NotRequired[HlsDirectoryStructureType],  # (10)
    Encryption: NotRequired[HlsEncryptionSettingsOutputTypeDef],  # (11)
    ImageBasedTrickPlay: NotRequired[HlsImageBasedTrickPlayType],  # (12)
    ImageBasedTrickPlaySettings: NotRequired[HlsImageBasedTrickPlaySettingsTypeDef],  # (13)
    ManifestCompression: NotRequired[HlsManifestCompressionType],  # (14)
    ManifestDurationFormat: NotRequired[HlsManifestDurationFormatType],  # (15)
    MinFinalSegmentLength: NotRequired[float],
    MinSegmentLength: NotRequired[int],
    OutputSelection: NotRequired[HlsOutputSelectionType],  # (16)
    ProgramDateTime: NotRequired[HlsProgramDateTimeType],  # (17)
    ProgramDateTimePeriod: NotRequired[int],
    ProgressiveWriteHlsManifest: NotRequired[HlsProgressiveWriteHlsManifestType],  # (18)
    SegmentControl: NotRequired[HlsSegmentControlType],  # (19)
    SegmentLength: NotRequired[int],
    SegmentLengthControl: NotRequired[HlsSegmentLengthControlType],  # (20)
    SegmentsPerSubdirectory: NotRequired[int],
    StreamInfResolution: NotRequired[HlsStreamInfResolutionType],  # (21)
    TargetDurationCompatibilityMode: NotRequired[HlsTargetDurationCompatibilityModeType],  # (22)
    TimedMetadataId3Frame: NotRequired[HlsTimedMetadataId3FrameType],  # (23)
    TimedMetadataId3Period: NotRequired[int],
    TimestampDeltaMilliseconds: NotRequired[int],

See List[HlsAdMarkersType]
See List[HlsAdditionalManifestOutputTypeDef]
See HlsAudioOnlyHeaderType
See List[HlsCaptionLanguageMappingTypeDef]
See HlsCaptionLanguageSettingType
See HlsCaptionSegmentLengthControlType
See HlsClientCacheType
See HlsCodecSpecificationType
See DestinationSettingsTypeDef
See HlsDirectoryStructureType
See HlsEncryptionSettingsOutputTypeDef
See HlsImageBasedTrickPlayType
See HlsImageBasedTrickPlaySettingsTypeDef
See HlsManifestCompressionType
See HlsManifestDurationFormatType
See HlsOutputSelectionType
See HlsProgramDateTimeType
See HlsProgressiveWriteHlsManifestType
See HlsSegmentControlType
See HlsSegmentLengthControlType
See HlsStreamInfResolutionType
See HlsTargetDurationCompatibilityModeType
See HlsTimedMetadataId3FrameType

HlsGroupSettingsTypeDef#

# HlsGroupSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import HlsGroupSettingsTypeDef


def get_value() -> HlsGroupSettingsTypeDef:
    return {
        "AdMarkers": ...,
    }


# HlsGroupSettingsTypeDef definition

class HlsGroupSettingsTypeDef(TypedDict):
    AdMarkers: NotRequired[Sequence[HlsAdMarkersType]],  # (1)
    AdditionalManifests: NotRequired[Sequence[HlsAdditionalManifestTypeDef]],  # (2)
    AudioOnlyHeader: NotRequired[HlsAudioOnlyHeaderType],  # (3)
    BaseUrl: NotRequired[str],
    CaptionLanguageMappings: NotRequired[Sequence[HlsCaptionLanguageMappingTypeDef]],  # (4)
    CaptionLanguageSetting: NotRequired[HlsCaptionLanguageSettingType],  # (5)
    CaptionSegmentLengthControl: NotRequired[HlsCaptionSegmentLengthControlType],  # (6)
    ClientCache: NotRequired[HlsClientCacheType],  # (7)
    CodecSpecification: NotRequired[HlsCodecSpecificationType],  # (8)
    Destination: NotRequired[str],
    DestinationSettings: NotRequired[DestinationSettingsTypeDef],  # (9)
    DirectoryStructure: NotRequired[HlsDirectoryStructureType],  # (10)
    Encryption: NotRequired[HlsEncryptionSettingsTypeDef],  # (11)
    ImageBasedTrickPlay: NotRequired[HlsImageBasedTrickPlayType],  # (12)
    ImageBasedTrickPlaySettings: NotRequired[HlsImageBasedTrickPlaySettingsTypeDef],  # (13)
    ManifestCompression: NotRequired[HlsManifestCompressionType],  # (14)
    ManifestDurationFormat: NotRequired[HlsManifestDurationFormatType],  # (15)
    MinFinalSegmentLength: NotRequired[float],
    MinSegmentLength: NotRequired[int],
    OutputSelection: NotRequired[HlsOutputSelectionType],  # (16)
    ProgramDateTime: NotRequired[HlsProgramDateTimeType],  # (17)
    ProgramDateTimePeriod: NotRequired[int],
    ProgressiveWriteHlsManifest: NotRequired[HlsProgressiveWriteHlsManifestType],  # (18)
    SegmentControl: NotRequired[HlsSegmentControlType],  # (19)
    SegmentLength: NotRequired[int],
    SegmentLengthControl: NotRequired[HlsSegmentLengthControlType],  # (20)
    SegmentsPerSubdirectory: NotRequired[int],
    StreamInfResolution: NotRequired[HlsStreamInfResolutionType],  # (21)
    TargetDurationCompatibilityMode: NotRequired[HlsTargetDurationCompatibilityModeType],  # (22)
    TimedMetadataId3Frame: NotRequired[HlsTimedMetadataId3FrameType],  # (23)
    TimedMetadataId3Period: NotRequired[int],
    TimestampDeltaMilliseconds: NotRequired[int],

See Sequence[HlsAdMarkersType]
See Sequence[HlsAdditionalManifestTypeDef]
See HlsAudioOnlyHeaderType
See Sequence[HlsCaptionLanguageMappingTypeDef]
See HlsCaptionLanguageSettingType
See HlsCaptionSegmentLengthControlType
See HlsClientCacheType
See HlsCodecSpecificationType
See DestinationSettingsTypeDef
See HlsDirectoryStructureType
See HlsEncryptionSettingsTypeDef
See HlsImageBasedTrickPlayType
See HlsImageBasedTrickPlaySettingsTypeDef
See HlsManifestCompressionType
See HlsManifestDurationFormatType
See HlsOutputSelectionType
See HlsProgramDateTimeType
See HlsProgressiveWriteHlsManifestType
See HlsSegmentControlType
See HlsSegmentLengthControlType
See HlsStreamInfResolutionType
See HlsTargetDurationCompatibilityModeType
See HlsTimedMetadataId3FrameType

MsSmoothGroupSettingsOutputTypeDef#

# MsSmoothGroupSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import MsSmoothGroupSettingsOutputTypeDef


def get_value() -> MsSmoothGroupSettingsOutputTypeDef:
    return {
        "AdditionalManifests": ...,
    }


# MsSmoothGroupSettingsOutputTypeDef definition

class MsSmoothGroupSettingsOutputTypeDef(TypedDict):
    AdditionalManifests: NotRequired[List[MsSmoothAdditionalManifestOutputTypeDef]],  # (1)
    AudioDeduplication: NotRequired[MsSmoothAudioDeduplicationType],  # (2)
    Destination: NotRequired[str],
    DestinationSettings: NotRequired[DestinationSettingsTypeDef],  # (3)
    Encryption: NotRequired[MsSmoothEncryptionSettingsOutputTypeDef],  # (4)
    FragmentLength: NotRequired[int],
    FragmentLengthControl: NotRequired[MsSmoothFragmentLengthControlType],  # (5)
    ManifestEncoding: NotRequired[MsSmoothManifestEncodingType],  # (6)

See List[MsSmoothAdditionalManifestOutputTypeDef]
See MsSmoothAudioDeduplicationType
See DestinationSettingsTypeDef
See MsSmoothEncryptionSettingsOutputTypeDef
See MsSmoothFragmentLengthControlType
See MsSmoothManifestEncodingType

MsSmoothGroupSettingsTypeDef#

# MsSmoothGroupSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import MsSmoothGroupSettingsTypeDef


def get_value() -> MsSmoothGroupSettingsTypeDef:
    return {
        "AdditionalManifests": ...,
    }


# MsSmoothGroupSettingsTypeDef definition

class MsSmoothGroupSettingsTypeDef(TypedDict):
    AdditionalManifests: NotRequired[Sequence[MsSmoothAdditionalManifestTypeDef]],  # (1)
    AudioDeduplication: NotRequired[MsSmoothAudioDeduplicationType],  # (2)
    Destination: NotRequired[str],
    DestinationSettings: NotRequired[DestinationSettingsTypeDef],  # (3)
    Encryption: NotRequired[MsSmoothEncryptionSettingsTypeDef],  # (4)
    FragmentLength: NotRequired[int],
    FragmentLengthControl: NotRequired[MsSmoothFragmentLengthControlType],  # (5)
    ManifestEncoding: NotRequired[MsSmoothManifestEncodingType],  # (6)

See Sequence[MsSmoothAdditionalManifestTypeDef]
See MsSmoothAudioDeduplicationType
See DestinationSettingsTypeDef
See MsSmoothEncryptionSettingsTypeDef
See MsSmoothFragmentLengthControlType
See MsSmoothManifestEncodingType

VideoDescriptionOutputTypeDef#

# VideoDescriptionOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import VideoDescriptionOutputTypeDef


def get_value() -> VideoDescriptionOutputTypeDef:
    return {
        "AfdSignaling": ...,
    }


# VideoDescriptionOutputTypeDef definition

class VideoDescriptionOutputTypeDef(TypedDict):
    AfdSignaling: NotRequired[AfdSignalingType],  # (1)
    AntiAlias: NotRequired[AntiAliasType],  # (2)
    ChromaPositionMode: NotRequired[ChromaPositionModeType],  # (3)
    CodecSettings: NotRequired[VideoCodecSettingsTypeDef],  # (4)
    ColorMetadata: NotRequired[ColorMetadataType],  # (5)
    Crop: NotRequired[RectangleTypeDef],  # (6)
    DropFrameTimecode: NotRequired[DropFrameTimecodeType],  # (7)
    FixedAfd: NotRequired[int],
    Height: NotRequired[int],
    Position: NotRequired[RectangleTypeDef],  # (6)
    RespondToAfd: NotRequired[RespondToAfdType],  # (9)
    ScalingBehavior: NotRequired[ScalingBehaviorType],  # (10)
    Sharpness: NotRequired[int],
    TimecodeInsertion: NotRequired[VideoTimecodeInsertionType],  # (11)
    TimecodeTrack: NotRequired[TimecodeTrackType],  # (12)
    VideoPreprocessors: NotRequired[VideoPreprocessorOutputTypeDef],  # (13)
    Width: NotRequired[int],

VideoDescriptionTypeDef#

# VideoDescriptionTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import VideoDescriptionTypeDef


def get_value() -> VideoDescriptionTypeDef:
    return {
        "AfdSignaling": ...,
    }


# VideoDescriptionTypeDef definition

class VideoDescriptionTypeDef(TypedDict):
    AfdSignaling: NotRequired[AfdSignalingType],  # (1)
    AntiAlias: NotRequired[AntiAliasType],  # (2)
    ChromaPositionMode: NotRequired[ChromaPositionModeType],  # (3)
    CodecSettings: NotRequired[VideoCodecSettingsTypeDef],  # (4)
    ColorMetadata: NotRequired[ColorMetadataType],  # (5)
    Crop: NotRequired[RectangleTypeDef],  # (6)
    DropFrameTimecode: NotRequired[DropFrameTimecodeType],  # (7)
    FixedAfd: NotRequired[int],
    Height: NotRequired[int],
    Position: NotRequired[RectangleTypeDef],  # (6)
    RespondToAfd: NotRequired[RespondToAfdType],  # (9)
    ScalingBehavior: NotRequired[ScalingBehaviorType],  # (10)
    Sharpness: NotRequired[int],
    TimecodeInsertion: NotRequired[VideoTimecodeInsertionType],  # (11)
    TimecodeTrack: NotRequired[TimecodeTrackType],  # (12)
    VideoPreprocessors: NotRequired[VideoPreprocessorTypeDef],  # (13)
    Width: NotRequired[int],

ProbeResultTypeDef#

# ProbeResultTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ProbeResultTypeDef


def get_value() -> ProbeResultTypeDef:
    return {
        "Container": ...,
    }


# ProbeResultTypeDef definition

class ProbeResultTypeDef(TypedDict):
    Container: NotRequired[ContainerTypeDef],  # (1)
    Metadata: NotRequired[MetadataTypeDef],  # (2)
    TrackMappings: NotRequired[List[TrackMappingTypeDef]],  # (3)

See ContainerTypeDef
See MetadataTypeDef
See List[TrackMappingTypeDef]

InputOutputTypeDef#

# InputOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import InputOutputTypeDef


def get_value() -> InputOutputTypeDef:
    return {
        "AdvancedInputFilter": ...,
    }


# InputOutputTypeDef definition

class InputOutputTypeDef(TypedDict):
    AdvancedInputFilter: NotRequired[AdvancedInputFilterType],  # (1)
    AdvancedInputFilterSettings: NotRequired[AdvancedInputFilterSettingsTypeDef],  # (2)
    AudioSelectorGroups: NotRequired[Dict[str, AudioSelectorGroupOutputTypeDef]],  # (3)
    AudioSelectors: NotRequired[Dict[str, AudioSelectorOutputTypeDef]],  # (4)
    CaptionSelectors: NotRequired[Dict[str, CaptionSelectorTypeDef]],  # (5)
    Crop: NotRequired[RectangleTypeDef],  # (6)
    DeblockFilter: NotRequired[InputDeblockFilterType],  # (7)
    DecryptionSettings: NotRequired[InputDecryptionSettingsTypeDef],  # (8)
    DenoiseFilter: NotRequired[InputDenoiseFilterType],  # (9)
    DolbyVisionMetadataXml: NotRequired[str],
    DynamicAudioSelectors: NotRequired[Dict[str, DynamicAudioSelectorTypeDef]],  # (10)
    FileInput: NotRequired[str],
    FilterEnable: NotRequired[InputFilterEnableType],  # (11)
    FilterStrength: NotRequired[int],
    ImageInserter: NotRequired[ImageInserterOutputTypeDef],  # (12)
    InputClippings: NotRequired[List[InputClippingTypeDef]],  # (13)
    InputScanType: NotRequired[InputScanTypeType],  # (14)
    Position: NotRequired[RectangleTypeDef],  # (6)
    ProgramNumber: NotRequired[int],
    PsiControl: NotRequired[InputPsiControlType],  # (16)
    SupplementalImps: NotRequired[List[str]],
    TimecodeSource: NotRequired[InputTimecodeSourceType],  # (17)
    TimecodeStart: NotRequired[str],
    VideoGenerator: NotRequired[InputVideoGeneratorTypeDef],  # (18)
    VideoOverlays: NotRequired[List[VideoOverlayOutputTypeDef]],  # (19)
    VideoSelector: NotRequired[VideoSelectorTypeDef],  # (20)

See AdvancedInputFilterType
See AdvancedInputFilterSettingsTypeDef
See Dict[str, AudioSelectorGroupOutputTypeDef]
See Dict[str, AudioSelectorOutputTypeDef]
See Dict[str, CaptionSelectorTypeDef]
See RectangleTypeDef
See InputDeblockFilterType
See InputDecryptionSettingsTypeDef
See InputDenoiseFilterType
See Dict[str, DynamicAudioSelectorTypeDef]
See InputFilterEnableType
See ImageInserterOutputTypeDef
See List[InputClippingTypeDef]
See InputScanTypeType
See RectangleTypeDef
See InputPsiControlType
See InputTimecodeSourceType
See InputVideoGeneratorTypeDef
See List[VideoOverlayOutputTypeDef]
See VideoSelectorTypeDef

InputTemplateOutputTypeDef#

# InputTemplateOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import InputTemplateOutputTypeDef


def get_value() -> InputTemplateOutputTypeDef:
    return {
        "AdvancedInputFilter": ...,
    }


# InputTemplateOutputTypeDef definition

class InputTemplateOutputTypeDef(TypedDict):
    AdvancedInputFilter: NotRequired[AdvancedInputFilterType],  # (1)
    AdvancedInputFilterSettings: NotRequired[AdvancedInputFilterSettingsTypeDef],  # (2)
    AudioSelectorGroups: NotRequired[Dict[str, AudioSelectorGroupOutputTypeDef]],  # (3)
    AudioSelectors: NotRequired[Dict[str, AudioSelectorOutputTypeDef]],  # (4)
    CaptionSelectors: NotRequired[Dict[str, CaptionSelectorTypeDef]],  # (5)
    Crop: NotRequired[RectangleTypeDef],  # (6)
    DeblockFilter: NotRequired[InputDeblockFilterType],  # (7)
    DenoiseFilter: NotRequired[InputDenoiseFilterType],  # (8)
    DolbyVisionMetadataXml: NotRequired[str],
    DynamicAudioSelectors: NotRequired[Dict[str, DynamicAudioSelectorTypeDef]],  # (9)
    FilterEnable: NotRequired[InputFilterEnableType],  # (10)
    FilterStrength: NotRequired[int],
    ImageInserter: NotRequired[ImageInserterOutputTypeDef],  # (11)
    InputClippings: NotRequired[List[InputClippingTypeDef]],  # (12)
    InputScanType: NotRequired[InputScanTypeType],  # (13)
    Position: NotRequired[RectangleTypeDef],  # (6)
    ProgramNumber: NotRequired[int],
    PsiControl: NotRequired[InputPsiControlType],  # (15)
    TimecodeSource: NotRequired[InputTimecodeSourceType],  # (16)
    TimecodeStart: NotRequired[str],
    VideoOverlays: NotRequired[List[VideoOverlayOutputTypeDef]],  # (17)
    VideoSelector: NotRequired[VideoSelectorTypeDef],  # (18)

See AdvancedInputFilterType
See AdvancedInputFilterSettingsTypeDef
See Dict[str, AudioSelectorGroupOutputTypeDef]
See Dict[str, AudioSelectorOutputTypeDef]
See Dict[str, CaptionSelectorTypeDef]
See RectangleTypeDef
See InputDeblockFilterType
See InputDenoiseFilterType
See Dict[str, DynamicAudioSelectorTypeDef]
See InputFilterEnableType
See ImageInserterOutputTypeDef
See List[InputClippingTypeDef]
See InputScanTypeType
See RectangleTypeDef
See InputPsiControlType
See InputTimecodeSourceType
See List[VideoOverlayOutputTypeDef]
See VideoSelectorTypeDef

InputTemplateTypeDef#

# InputTemplateTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import InputTemplateTypeDef


def get_value() -> InputTemplateTypeDef:
    return {
        "AdvancedInputFilter": ...,
    }


# InputTemplateTypeDef definition

class InputTemplateTypeDef(TypedDict):
    AdvancedInputFilter: NotRequired[AdvancedInputFilterType],  # (1)
    AdvancedInputFilterSettings: NotRequired[AdvancedInputFilterSettingsTypeDef],  # (2)
    AudioSelectorGroups: NotRequired[Mapping[str, AudioSelectorGroupTypeDef]],  # (3)
    AudioSelectors: NotRequired[Mapping[str, AudioSelectorTypeDef]],  # (4)
    CaptionSelectors: NotRequired[Mapping[str, CaptionSelectorTypeDef]],  # (5)
    Crop: NotRequired[RectangleTypeDef],  # (6)
    DeblockFilter: NotRequired[InputDeblockFilterType],  # (7)
    DenoiseFilter: NotRequired[InputDenoiseFilterType],  # (8)
    DolbyVisionMetadataXml: NotRequired[str],
    DynamicAudioSelectors: NotRequired[Mapping[str, DynamicAudioSelectorTypeDef]],  # (9)
    FilterEnable: NotRequired[InputFilterEnableType],  # (10)
    FilterStrength: NotRequired[int],
    ImageInserter: NotRequired[ImageInserterTypeDef],  # (11)
    InputClippings: NotRequired[Sequence[InputClippingTypeDef]],  # (12)
    InputScanType: NotRequired[InputScanTypeType],  # (13)
    Position: NotRequired[RectangleTypeDef],  # (6)
    ProgramNumber: NotRequired[int],
    PsiControl: NotRequired[InputPsiControlType],  # (15)
    TimecodeSource: NotRequired[InputTimecodeSourceType],  # (16)
    TimecodeStart: NotRequired[str],
    VideoOverlays: NotRequired[Sequence[VideoOverlayTypeDef]],  # (17)
    VideoSelector: NotRequired[VideoSelectorTypeDef],  # (18)

See AdvancedInputFilterType
See AdvancedInputFilterSettingsTypeDef
See Mapping[str, AudioSelectorGroupTypeDef]
See Mapping[str, AudioSelectorTypeDef]
See Mapping[str, CaptionSelectorTypeDef]
See RectangleTypeDef
See InputDeblockFilterType
See InputDenoiseFilterType
See Mapping[str, DynamicAudioSelectorTypeDef]
See InputFilterEnableType
See ImageInserterTypeDef
See Sequence[InputClippingTypeDef]
See InputScanTypeType
See RectangleTypeDef
See InputPsiControlType
See InputTimecodeSourceType
See Sequence[VideoOverlayTypeDef]
See VideoSelectorTypeDef

InputTypeDef#

# InputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import InputTypeDef


def get_value() -> InputTypeDef:
    return {
        "AdvancedInputFilter": ...,
    }


# InputTypeDef definition

class InputTypeDef(TypedDict):
    AdvancedInputFilter: NotRequired[AdvancedInputFilterType],  # (1)
    AdvancedInputFilterSettings: NotRequired[AdvancedInputFilterSettingsTypeDef],  # (2)
    AudioSelectorGroups: NotRequired[Mapping[str, AudioSelectorGroupTypeDef]],  # (3)
    AudioSelectors: NotRequired[Mapping[str, AudioSelectorTypeDef]],  # (4)
    CaptionSelectors: NotRequired[Mapping[str, CaptionSelectorTypeDef]],  # (5)
    Crop: NotRequired[RectangleTypeDef],  # (6)
    DeblockFilter: NotRequired[InputDeblockFilterType],  # (7)
    DecryptionSettings: NotRequired[InputDecryptionSettingsTypeDef],  # (8)
    DenoiseFilter: NotRequired[InputDenoiseFilterType],  # (9)
    DolbyVisionMetadataXml: NotRequired[str],
    DynamicAudioSelectors: NotRequired[Mapping[str, DynamicAudioSelectorTypeDef]],  # (10)
    FileInput: NotRequired[str],
    FilterEnable: NotRequired[InputFilterEnableType],  # (11)
    FilterStrength: NotRequired[int],
    ImageInserter: NotRequired[ImageInserterTypeDef],  # (12)
    InputClippings: NotRequired[Sequence[InputClippingTypeDef]],  # (13)
    InputScanType: NotRequired[InputScanTypeType],  # (14)
    Position: NotRequired[RectangleTypeDef],  # (6)
    ProgramNumber: NotRequired[int],
    PsiControl: NotRequired[InputPsiControlType],  # (16)
    SupplementalImps: NotRequired[Sequence[str]],
    TimecodeSource: NotRequired[InputTimecodeSourceType],  # (17)
    TimecodeStart: NotRequired[str],
    VideoGenerator: NotRequired[InputVideoGeneratorTypeDef],  # (18)
    VideoOverlays: NotRequired[Sequence[VideoOverlayTypeDef]],  # (19)
    VideoSelector: NotRequired[VideoSelectorTypeDef],  # (20)

See AdvancedInputFilterType
See AdvancedInputFilterSettingsTypeDef
See Mapping[str, AudioSelectorGroupTypeDef]
See Mapping[str, AudioSelectorTypeDef]
See Mapping[str, CaptionSelectorTypeDef]
See RectangleTypeDef
See InputDeblockFilterType
See InputDecryptionSettingsTypeDef
See InputDenoiseFilterType
See Mapping[str, DynamicAudioSelectorTypeDef]
See InputFilterEnableType
See ImageInserterTypeDef
See Sequence[InputClippingTypeDef]
See InputScanTypeType
See RectangleTypeDef
See InputPsiControlType
See InputTimecodeSourceType
See InputVideoGeneratorTypeDef
See Sequence[VideoOverlayTypeDef]
See VideoSelectorTypeDef

OutputGroupSettingsOutputTypeDef#

# OutputGroupSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import OutputGroupSettingsOutputTypeDef


def get_value() -> OutputGroupSettingsOutputTypeDef:
    return {
        "CmafGroupSettings": ...,
    }


# OutputGroupSettingsOutputTypeDef definition

class OutputGroupSettingsOutputTypeDef(TypedDict):
    CmafGroupSettings: NotRequired[CmafGroupSettingsOutputTypeDef],  # (1)
    DashIsoGroupSettings: NotRequired[DashIsoGroupSettingsOutputTypeDef],  # (2)
    FileGroupSettings: NotRequired[FileGroupSettingsTypeDef],  # (3)
    HlsGroupSettings: NotRequired[HlsGroupSettingsOutputTypeDef],  # (4)
    MsSmoothGroupSettings: NotRequired[MsSmoothGroupSettingsOutputTypeDef],  # (5)
    Type: NotRequired[OutputGroupTypeType],  # (6)

OutputGroupSettingsTypeDef#

# OutputGroupSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import OutputGroupSettingsTypeDef


def get_value() -> OutputGroupSettingsTypeDef:
    return {
        "CmafGroupSettings": ...,
    }


# OutputGroupSettingsTypeDef definition

class OutputGroupSettingsTypeDef(TypedDict):
    CmafGroupSettings: NotRequired[CmafGroupSettingsTypeDef],  # (1)
    DashIsoGroupSettings: NotRequired[DashIsoGroupSettingsTypeDef],  # (2)
    FileGroupSettings: NotRequired[FileGroupSettingsTypeDef],  # (3)
    HlsGroupSettings: NotRequired[HlsGroupSettingsTypeDef],  # (4)
    MsSmoothGroupSettings: NotRequired[MsSmoothGroupSettingsTypeDef],  # (5)
    Type: NotRequired[OutputGroupTypeType],  # (6)

ExtraTypeDef#

# ExtraTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ExtraTypeDef


def get_value() -> ExtraTypeDef:
    return {
        "AudioDescriptions": ...,
    }


# ExtraTypeDef definition

class ExtraTypeDef(TypedDict):
    AudioDescriptions: NotRequired[List[AudioDescriptionOutputTypeDef]],  # (1)
    CaptionDescriptions: NotRequired[List[CaptionDescriptionOutputTypeDef]],  # (2)
    ContainerSettings: NotRequired[ContainerSettingsOutputTypeDef],  # (3)
    Extension: NotRequired[str],
    NameModifier: NotRequired[str],
    OutputSettings: NotRequired[OutputSettingsTypeDef],  # (4)
    Preset: NotRequired[str],
    VideoDescription: NotRequired[VideoDescriptionOutputTypeDef],  # (5)

See List[AudioDescriptionOutputTypeDef]
See List[CaptionDescriptionOutputTypeDef]
See ContainerSettingsOutputTypeDef
See OutputSettingsTypeDef
See VideoDescriptionOutputTypeDef

PresetSettingsOutputTypeDef#

# PresetSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import PresetSettingsOutputTypeDef


def get_value() -> PresetSettingsOutputTypeDef:
    return {
        "AudioDescriptions": ...,
    }


# PresetSettingsOutputTypeDef definition

class PresetSettingsOutputTypeDef(TypedDict):
    AudioDescriptions: NotRequired[List[AudioDescriptionOutputTypeDef]],  # (1)
    CaptionDescriptions: NotRequired[List[CaptionDescriptionPresetOutputTypeDef]],  # (2)
    ContainerSettings: NotRequired[ContainerSettingsOutputTypeDef],  # (3)
    VideoDescription: NotRequired[VideoDescriptionOutputTypeDef],  # (4)

See List[AudioDescriptionOutputTypeDef]
See List[CaptionDescriptionPresetOutputTypeDef]
See ContainerSettingsOutputTypeDef
See VideoDescriptionOutputTypeDef

OutputTypeDef#

# OutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import OutputTypeDef


def get_value() -> OutputTypeDef:
    return {
        "AudioDescriptions": ...,
    }


# OutputTypeDef definition

class OutputTypeDef(TypedDict):
    AudioDescriptions: NotRequired[Sequence[AudioDescriptionTypeDef]],  # (1)
    CaptionDescriptions: NotRequired[Sequence[CaptionDescriptionTypeDef]],  # (2)
    ContainerSettings: NotRequired[ContainerSettingsTypeDef],  # (3)
    Extension: NotRequired[str],
    NameModifier: NotRequired[str],
    OutputSettings: NotRequired[OutputSettingsTypeDef],  # (4)
    Preset: NotRequired[str],
    VideoDescription: NotRequired[VideoDescriptionTypeDef],  # (5)

See Sequence[AudioDescriptionTypeDef]
See Sequence[CaptionDescriptionTypeDef]
See ContainerSettingsTypeDef
See OutputSettingsTypeDef
See VideoDescriptionTypeDef

PresetSettingsTypeDef#

# PresetSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import PresetSettingsTypeDef


def get_value() -> PresetSettingsTypeDef:
    return {
        "AudioDescriptions": ...,
    }


# PresetSettingsTypeDef definition

class PresetSettingsTypeDef(TypedDict):
    AudioDescriptions: NotRequired[Sequence[AudioDescriptionTypeDef]],  # (1)
    CaptionDescriptions: NotRequired[Sequence[CaptionDescriptionPresetTypeDef]],  # (2)
    ContainerSettings: NotRequired[ContainerSettingsTypeDef],  # (3)
    VideoDescription: NotRequired[VideoDescriptionTypeDef],  # (4)

See Sequence[AudioDescriptionTypeDef]
See Sequence[CaptionDescriptionPresetTypeDef]
See ContainerSettingsTypeDef
See VideoDescriptionTypeDef

ProbeResponseTypeDef#

# ProbeResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ProbeResponseTypeDef


def get_value() -> ProbeResponseTypeDef:
    return {
        "ProbeResults": ...,
    }


# ProbeResponseTypeDef definition

class ProbeResponseTypeDef(TypedDict):
    ProbeResults: List[ProbeResultTypeDef],  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)

See List[ProbeResultTypeDef]
See ResponseMetadataTypeDef

OutputGroupOutputTypeDef#

# OutputGroupOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import OutputGroupOutputTypeDef


def get_value() -> OutputGroupOutputTypeDef:
    return {
        "AutomatedEncodingSettings": ...,
    }


# OutputGroupOutputTypeDef definition

class OutputGroupOutputTypeDef(TypedDict):
    AutomatedEncodingSettings: NotRequired[AutomatedEncodingSettingsOutputTypeDef],  # (1)
    CustomName: NotRequired[str],
    Name: NotRequired[str],
    OutputGroupSettings: NotRequired[OutputGroupSettingsOutputTypeDef],  # (2)
    Outputs: NotRequired[List[ExtraTypeDef]],  # (3)

See AutomatedEncodingSettingsOutputTypeDef
See OutputGroupSettingsOutputTypeDef
See List[ExtraTypeDef]

PresetTypeDef#

# PresetTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import PresetTypeDef


def get_value() -> PresetTypeDef:
    return {
        "Arn": ...,
    }


# PresetTypeDef definition

class PresetTypeDef(TypedDict):
    Name: str,
    Settings: PresetSettingsOutputTypeDef,  # (1)
    Arn: NotRequired[str],
    Category: NotRequired[str],
    CreatedAt: NotRequired[datetime.datetime],
    Description: NotRequired[str],
    LastUpdated: NotRequired[datetime.datetime],
    Type: NotRequired[TypeType],  # (2)

See PresetSettingsOutputTypeDef
See TypeType

OutputGroupTypeDef#

# OutputGroupTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import OutputGroupTypeDef


def get_value() -> OutputGroupTypeDef:
    return {
        "AutomatedEncodingSettings": ...,
    }


# OutputGroupTypeDef definition

class OutputGroupTypeDef(TypedDict):
    AutomatedEncodingSettings: NotRequired[AutomatedEncodingSettingsTypeDef],  # (1)
    CustomName: NotRequired[str],
    Name: NotRequired[str],
    OutputGroupSettings: NotRequired[OutputGroupSettingsTypeDef],  # (2)
    Outputs: NotRequired[Sequence[OutputTypeDef]],  # (3)

See AutomatedEncodingSettingsTypeDef
See OutputGroupSettingsTypeDef
See Sequence[OutputTypeDef]

JobSettingsOutputTypeDef#

# JobSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import JobSettingsOutputTypeDef


def get_value() -> JobSettingsOutputTypeDef:
    return {
        "AdAvailOffset": ...,
    }


# JobSettingsOutputTypeDef definition

class JobSettingsOutputTypeDef(TypedDict):
    AdAvailOffset: NotRequired[int],
    AvailBlanking: NotRequired[AvailBlankingTypeDef],  # (1)
    ColorConversion3DLUTSettings: NotRequired[List[ColorConversion3DLUTSettingTypeDef]],  # (2)
    Esam: NotRequired[EsamSettingsTypeDef],  # (3)
    ExtendedDataServices: NotRequired[ExtendedDataServicesTypeDef],  # (4)
    FollowSource: NotRequired[int],
    Inputs: NotRequired[List[InputOutputTypeDef]],  # (5)
    KantarWatermark: NotRequired[KantarWatermarkSettingsTypeDef],  # (6)
    MotionImageInserter: NotRequired[MotionImageInserterTypeDef],  # (7)
    NielsenConfiguration: NotRequired[NielsenConfigurationTypeDef],  # (8)
    NielsenNonLinearWatermark: NotRequired[NielsenNonLinearWatermarkSettingsTypeDef],  # (9)
    OutputGroups: NotRequired[List[OutputGroupOutputTypeDef]],  # (10)
    TimecodeConfig: NotRequired[TimecodeConfigTypeDef],  # (11)
    TimedMetadataInsertion: NotRequired[TimedMetadataInsertionOutputTypeDef],  # (12)

See AvailBlankingTypeDef
See List[ColorConversion3DLUTSettingTypeDef]
See EsamSettingsTypeDef
See ExtendedDataServicesTypeDef
See List[InputOutputTypeDef]
See KantarWatermarkSettingsTypeDef
See MotionImageInserterTypeDef
See NielsenConfigurationTypeDef
See NielsenNonLinearWatermarkSettingsTypeDef
See List[OutputGroupOutputTypeDef]
See TimecodeConfigTypeDef
See TimedMetadataInsertionOutputTypeDef

JobTemplateSettingsOutputTypeDef#

# JobTemplateSettingsOutputTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import JobTemplateSettingsOutputTypeDef


def get_value() -> JobTemplateSettingsOutputTypeDef:
    return {
        "AdAvailOffset": ...,
    }


# JobTemplateSettingsOutputTypeDef definition

class JobTemplateSettingsOutputTypeDef(TypedDict):
    AdAvailOffset: NotRequired[int],
    AvailBlanking: NotRequired[AvailBlankingTypeDef],  # (1)
    ColorConversion3DLUTSettings: NotRequired[List[ColorConversion3DLUTSettingTypeDef]],  # (2)
    Esam: NotRequired[EsamSettingsTypeDef],  # (3)
    ExtendedDataServices: NotRequired[ExtendedDataServicesTypeDef],  # (4)
    FollowSource: NotRequired[int],
    Inputs: NotRequired[List[InputTemplateOutputTypeDef]],  # (5)
    KantarWatermark: NotRequired[KantarWatermarkSettingsTypeDef],  # (6)
    MotionImageInserter: NotRequired[MotionImageInserterTypeDef],  # (7)
    NielsenConfiguration: NotRequired[NielsenConfigurationTypeDef],  # (8)
    NielsenNonLinearWatermark: NotRequired[NielsenNonLinearWatermarkSettingsTypeDef],  # (9)
    OutputGroups: NotRequired[List[OutputGroupOutputTypeDef]],  # (10)
    TimecodeConfig: NotRequired[TimecodeConfigTypeDef],  # (11)
    TimedMetadataInsertion: NotRequired[TimedMetadataInsertionOutputTypeDef],  # (12)

See AvailBlankingTypeDef
See List[ColorConversion3DLUTSettingTypeDef]
See EsamSettingsTypeDef
See ExtendedDataServicesTypeDef
See List[InputTemplateOutputTypeDef]
See KantarWatermarkSettingsTypeDef
See MotionImageInserterTypeDef
See NielsenConfigurationTypeDef
See NielsenNonLinearWatermarkSettingsTypeDef
See List[OutputGroupOutputTypeDef]
See TimecodeConfigTypeDef
See TimedMetadataInsertionOutputTypeDef

CreatePresetResponseTypeDef#

# CreatePresetResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CreatePresetResponseTypeDef


def get_value() -> CreatePresetResponseTypeDef:
    return {
        "Preset": ...,
    }


# CreatePresetResponseTypeDef definition

class CreatePresetResponseTypeDef(TypedDict):
    Preset: PresetTypeDef,  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)

See PresetTypeDef
See ResponseMetadataTypeDef

GetPresetResponseTypeDef#

# GetPresetResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import GetPresetResponseTypeDef


def get_value() -> GetPresetResponseTypeDef:
    return {
        "Preset": ...,
    }


# GetPresetResponseTypeDef definition

class GetPresetResponseTypeDef(TypedDict):
    Preset: PresetTypeDef,  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)

See PresetTypeDef
See ResponseMetadataTypeDef

ListPresetsResponseTypeDef#

# ListPresetsResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListPresetsResponseTypeDef


def get_value() -> ListPresetsResponseTypeDef:
    return {
        "NextToken": ...,
    }


# ListPresetsResponseTypeDef definition

class ListPresetsResponseTypeDef(TypedDict):
    Presets: List[PresetTypeDef],  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)
    NextToken: NotRequired[str],

See List[PresetTypeDef]
See ResponseMetadataTypeDef

UpdatePresetResponseTypeDef#

# UpdatePresetResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import UpdatePresetResponseTypeDef


def get_value() -> UpdatePresetResponseTypeDef:
    return {
        "Preset": ...,
    }


# UpdatePresetResponseTypeDef definition

class UpdatePresetResponseTypeDef(TypedDict):
    Preset: PresetTypeDef,  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)

See PresetTypeDef
See ResponseMetadataTypeDef

JobSettingsTypeDef#

# JobSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import JobSettingsTypeDef


def get_value() -> JobSettingsTypeDef:
    return {
        "AdAvailOffset": ...,
    }


# JobSettingsTypeDef definition

class JobSettingsTypeDef(TypedDict):
    AdAvailOffset: NotRequired[int],
    AvailBlanking: NotRequired[AvailBlankingTypeDef],  # (1)
    ColorConversion3DLUTSettings: NotRequired[Sequence[ColorConversion3DLUTSettingTypeDef]],  # (2)
    Esam: NotRequired[EsamSettingsTypeDef],  # (3)
    ExtendedDataServices: NotRequired[ExtendedDataServicesTypeDef],  # (4)
    FollowSource: NotRequired[int],
    Inputs: NotRequired[Sequence[InputTypeDef]],  # (5)
    KantarWatermark: NotRequired[KantarWatermarkSettingsTypeDef],  # (6)
    MotionImageInserter: NotRequired[MotionImageInserterTypeDef],  # (7)
    NielsenConfiguration: NotRequired[NielsenConfigurationTypeDef],  # (8)
    NielsenNonLinearWatermark: NotRequired[NielsenNonLinearWatermarkSettingsTypeDef],  # (9)
    OutputGroups: NotRequired[Sequence[OutputGroupTypeDef]],  # (10)
    TimecodeConfig: NotRequired[TimecodeConfigTypeDef],  # (11)
    TimedMetadataInsertion: NotRequired[TimedMetadataInsertionTypeDef],  # (12)

See AvailBlankingTypeDef
See Sequence[ColorConversion3DLUTSettingTypeDef]
See EsamSettingsTypeDef
See ExtendedDataServicesTypeDef
See Sequence[InputTypeDef]
See KantarWatermarkSettingsTypeDef
See MotionImageInserterTypeDef
See NielsenConfigurationTypeDef
See NielsenNonLinearWatermarkSettingsTypeDef
See Sequence[OutputGroupTypeDef]
See TimecodeConfigTypeDef
See TimedMetadataInsertionTypeDef

JobTemplateSettingsTypeDef#

# JobTemplateSettingsTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import JobTemplateSettingsTypeDef


def get_value() -> JobTemplateSettingsTypeDef:
    return {
        "AdAvailOffset": ...,
    }


# JobTemplateSettingsTypeDef definition

class JobTemplateSettingsTypeDef(TypedDict):
    AdAvailOffset: NotRequired[int],
    AvailBlanking: NotRequired[AvailBlankingTypeDef],  # (1)
    ColorConversion3DLUTSettings: NotRequired[Sequence[ColorConversion3DLUTSettingTypeDef]],  # (2)
    Esam: NotRequired[EsamSettingsTypeDef],  # (3)
    ExtendedDataServices: NotRequired[ExtendedDataServicesTypeDef],  # (4)
    FollowSource: NotRequired[int],
    Inputs: NotRequired[Sequence[InputTemplateTypeDef]],  # (5)
    KantarWatermark: NotRequired[KantarWatermarkSettingsTypeDef],  # (6)
    MotionImageInserter: NotRequired[MotionImageInserterTypeDef],  # (7)
    NielsenConfiguration: NotRequired[NielsenConfigurationTypeDef],  # (8)
    NielsenNonLinearWatermark: NotRequired[NielsenNonLinearWatermarkSettingsTypeDef],  # (9)
    OutputGroups: NotRequired[Sequence[OutputGroupTypeDef]],  # (10)
    TimecodeConfig: NotRequired[TimecodeConfigTypeDef],  # (11)
    TimedMetadataInsertion: NotRequired[TimedMetadataInsertionTypeDef],  # (12)

See AvailBlankingTypeDef
See Sequence[ColorConversion3DLUTSettingTypeDef]
See EsamSettingsTypeDef
See ExtendedDataServicesTypeDef
See Sequence[InputTemplateTypeDef]
See KantarWatermarkSettingsTypeDef
See MotionImageInserterTypeDef
See NielsenConfigurationTypeDef
See NielsenNonLinearWatermarkSettingsTypeDef
See Sequence[OutputGroupTypeDef]
See TimecodeConfigTypeDef
See TimedMetadataInsertionTypeDef

CreatePresetRequestTypeDef#

# CreatePresetRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CreatePresetRequestTypeDef


def get_value() -> CreatePresetRequestTypeDef:
    return {
        "Name": ...,
    }


# CreatePresetRequestTypeDef definition

class CreatePresetRequestTypeDef(TypedDict):
    Name: str,
    Settings: PresetSettingsUnionTypeDef,  # (1)
    Category: NotRequired[str],
    Description: NotRequired[str],
    Tags: NotRequired[Mapping[str, str]],

See PresetSettingsUnionTypeDef

UpdatePresetRequestTypeDef#

# UpdatePresetRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import UpdatePresetRequestTypeDef


def get_value() -> UpdatePresetRequestTypeDef:
    return {
        "Name": ...,
    }


# UpdatePresetRequestTypeDef definition

class UpdatePresetRequestTypeDef(TypedDict):
    Name: str,
    Category: NotRequired[str],
    Description: NotRequired[str],
    Settings: NotRequired[PresetSettingsUnionTypeDef],  # (1)

See PresetSettingsUnionTypeDef

JobTypeDef#

# JobTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import JobTypeDef


def get_value() -> JobTypeDef:
    return {
        "AccelerationSettings": ...,
    }


# JobTypeDef definition

class JobTypeDef(TypedDict):
    Role: str,
    Settings: JobSettingsOutputTypeDef,  # (9)
    AccelerationSettings: NotRequired[AccelerationSettingsTypeDef],  # (1)
    AccelerationStatus: NotRequired[AccelerationStatusType],  # (2)
    Arn: NotRequired[str],
    BillingTagsSource: NotRequired[BillingTagsSourceType],  # (3)
    ClientRequestToken: NotRequired[str],
    CreatedAt: NotRequired[datetime.datetime],
    CurrentPhase: NotRequired[JobPhaseType],  # (4)
    ErrorCode: NotRequired[int],
    ErrorMessage: NotRequired[str],
    HopDestinations: NotRequired[List[HopDestinationTypeDef]],  # (5)
    Id: NotRequired[str],
    JobEngineVersionRequested: NotRequired[str],
    JobEngineVersionUsed: NotRequired[str],
    JobPercentComplete: NotRequired[int],
    JobTemplate: NotRequired[str],
    Messages: NotRequired[JobMessagesTypeDef],  # (6)
    OutputGroupDetails: NotRequired[List[OutputGroupDetailTypeDef]],  # (7)
    Priority: NotRequired[int],
    Queue: NotRequired[str],
    QueueTransitions: NotRequired[List[QueueTransitionTypeDef]],  # (8)
    RetryCount: NotRequired[int],
    SimulateReservedQueue: NotRequired[SimulateReservedQueueType],  # (10)
    Status: NotRequired[JobStatusType],  # (11)
    StatusUpdateInterval: NotRequired[StatusUpdateIntervalType],  # (12)
    Timing: NotRequired[TimingTypeDef],  # (13)
    UserMetadata: NotRequired[Dict[str, str]],
    Warnings: NotRequired[List[WarningGroupTypeDef]],  # (14)

See AccelerationSettingsTypeDef
See AccelerationStatusType
See BillingTagsSourceType
See JobPhaseType
See List[HopDestinationTypeDef]
See JobMessagesTypeDef
See List[OutputGroupDetailTypeDef]
See List[QueueTransitionTypeDef]
See JobSettingsOutputTypeDef
See SimulateReservedQueueType
See JobStatusType
See StatusUpdateIntervalType
See TimingTypeDef
See List[WarningGroupTypeDef]

JobTemplateTypeDef#

# JobTemplateTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import JobTemplateTypeDef


def get_value() -> JobTemplateTypeDef:
    return {
        "AccelerationSettings": ...,
    }


# JobTemplateTypeDef definition

class JobTemplateTypeDef(TypedDict):
    Name: str,
    Settings: JobTemplateSettingsOutputTypeDef,  # (3)
    AccelerationSettings: NotRequired[AccelerationSettingsTypeDef],  # (1)
    Arn: NotRequired[str],
    Category: NotRequired[str],
    CreatedAt: NotRequired[datetime.datetime],
    Description: NotRequired[str],
    HopDestinations: NotRequired[List[HopDestinationTypeDef]],  # (2)
    LastUpdated: NotRequired[datetime.datetime],
    Priority: NotRequired[int],
    Queue: NotRequired[str],
    StatusUpdateInterval: NotRequired[StatusUpdateIntervalType],  # (4)
    Type: NotRequired[TypeType],  # (5)

CreateJobResponseTypeDef#

# CreateJobResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CreateJobResponseTypeDef


def get_value() -> CreateJobResponseTypeDef:
    return {
        "Job": ...,
    }


# CreateJobResponseTypeDef definition

class CreateJobResponseTypeDef(TypedDict):
    Job: JobTypeDef,  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)

See JobTypeDef
See ResponseMetadataTypeDef

GetJobResponseTypeDef#

# GetJobResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import GetJobResponseTypeDef


def get_value() -> GetJobResponseTypeDef:
    return {
        "Job": ...,
    }


# GetJobResponseTypeDef definition

class GetJobResponseTypeDef(TypedDict):
    Job: JobTypeDef,  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)

See JobTypeDef
See ResponseMetadataTypeDef

ListJobsResponseTypeDef#

# ListJobsResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListJobsResponseTypeDef


def get_value() -> ListJobsResponseTypeDef:
    return {
        "Jobs": ...,
    }


# ListJobsResponseTypeDef definition

class ListJobsResponseTypeDef(TypedDict):
    Jobs: List[JobTypeDef],  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)
    NextToken: NotRequired[str],

See List[JobTypeDef]
See ResponseMetadataTypeDef

SearchJobsResponseTypeDef#

# SearchJobsResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import SearchJobsResponseTypeDef


def get_value() -> SearchJobsResponseTypeDef:
    return {
        "Jobs": ...,
    }


# SearchJobsResponseTypeDef definition

class SearchJobsResponseTypeDef(TypedDict):
    Jobs: List[JobTypeDef],  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)
    NextToken: NotRequired[str],

See List[JobTypeDef]
See ResponseMetadataTypeDef

CreateJobTemplateResponseTypeDef#

# CreateJobTemplateResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CreateJobTemplateResponseTypeDef


def get_value() -> CreateJobTemplateResponseTypeDef:
    return {
        "JobTemplate": ...,
    }


# CreateJobTemplateResponseTypeDef definition

class CreateJobTemplateResponseTypeDef(TypedDict):
    JobTemplate: JobTemplateTypeDef,  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)

See JobTemplateTypeDef
See ResponseMetadataTypeDef

GetJobTemplateResponseTypeDef#

# GetJobTemplateResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import GetJobTemplateResponseTypeDef


def get_value() -> GetJobTemplateResponseTypeDef:
    return {
        "JobTemplate": ...,
    }


# GetJobTemplateResponseTypeDef definition

class GetJobTemplateResponseTypeDef(TypedDict):
    JobTemplate: JobTemplateTypeDef,  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)

See JobTemplateTypeDef
See ResponseMetadataTypeDef

ListJobTemplatesResponseTypeDef#

# ListJobTemplatesResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import ListJobTemplatesResponseTypeDef


def get_value() -> ListJobTemplatesResponseTypeDef:
    return {
        "JobTemplates": ...,
    }


# ListJobTemplatesResponseTypeDef definition

class ListJobTemplatesResponseTypeDef(TypedDict):
    JobTemplates: List[JobTemplateTypeDef],  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)
    NextToken: NotRequired[str],

See List[JobTemplateTypeDef]
See ResponseMetadataTypeDef

UpdateJobTemplateResponseTypeDef#

# UpdateJobTemplateResponseTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import UpdateJobTemplateResponseTypeDef


def get_value() -> UpdateJobTemplateResponseTypeDef:
    return {
        "JobTemplate": ...,
    }


# UpdateJobTemplateResponseTypeDef definition

class UpdateJobTemplateResponseTypeDef(TypedDict):
    JobTemplate: JobTemplateTypeDef,  # (1)
    ResponseMetadata: ResponseMetadataTypeDef,  # (2)

See JobTemplateTypeDef
See ResponseMetadataTypeDef

CreateJobRequestTypeDef#

# CreateJobRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CreateJobRequestTypeDef


def get_value() -> CreateJobRequestTypeDef:
    return {
        "Role": ...,
    }


# CreateJobRequestTypeDef definition

class CreateJobRequestTypeDef(TypedDict):
    Role: str,
    Settings: JobSettingsUnionTypeDef,  # (1)
    AccelerationSettings: NotRequired[AccelerationSettingsTypeDef],  # (2)
    BillingTagsSource: NotRequired[BillingTagsSourceType],  # (3)
    ClientRequestToken: NotRequired[str],
    HopDestinations: NotRequired[Sequence[HopDestinationTypeDef]],  # (4)
    JobEngineVersion: NotRequired[str],
    JobTemplate: NotRequired[str],
    Priority: NotRequired[int],
    Queue: NotRequired[str],
    SimulateReservedQueue: NotRequired[SimulateReservedQueueType],  # (5)
    StatusUpdateInterval: NotRequired[StatusUpdateIntervalType],  # (6)
    Tags: NotRequired[Mapping[str, str]],
    UserMetadata: NotRequired[Mapping[str, str]],

CreateJobTemplateRequestTypeDef#

# CreateJobTemplateRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import CreateJobTemplateRequestTypeDef


def get_value() -> CreateJobTemplateRequestTypeDef:
    return {
        "Name": ...,
    }


# CreateJobTemplateRequestTypeDef definition

class CreateJobTemplateRequestTypeDef(TypedDict):
    Name: str,
    Settings: JobTemplateSettingsUnionTypeDef,  # (1)
    AccelerationSettings: NotRequired[AccelerationSettingsTypeDef],  # (2)
    Category: NotRequired[str],
    Description: NotRequired[str],
    HopDestinations: NotRequired[Sequence[HopDestinationTypeDef]],  # (3)
    Priority: NotRequired[int],
    Queue: NotRequired[str],
    StatusUpdateInterval: NotRequired[StatusUpdateIntervalType],  # (4)
    Tags: NotRequired[Mapping[str, str]],

See JobTemplateSettingsUnionTypeDef
See AccelerationSettingsTypeDef
See Sequence[HopDestinationTypeDef]
See StatusUpdateIntervalType

UpdateJobTemplateRequestTypeDef#

# UpdateJobTemplateRequestTypeDef TypedDict usage example

from mypy_boto3_mediaconvert.type_defs import UpdateJobTemplateRequestTypeDef


def get_value() -> UpdateJobTemplateRequestTypeDef:
    return {
        "Name": ...,
    }


# UpdateJobTemplateRequestTypeDef definition

class UpdateJobTemplateRequestTypeDef(TypedDict):
    Name: str,
    AccelerationSettings: NotRequired[AccelerationSettingsTypeDef],  # (1)
    Category: NotRequired[str],
    Description: NotRequired[str],
    HopDestinations: NotRequired[Sequence[HopDestinationTypeDef]],  # (2)
    Priority: NotRequired[int],
    Queue: NotRequired[str],
    Settings: NotRequired[JobTemplateSettingsUnionTypeDef],  # (3)
    StatusUpdateInterval: NotRequired[StatusUpdateIntervalType],  # (4)

See AccelerationSettingsTypeDef
See Sequence[HopDestinationTypeDef]
See JobTemplateSettingsUnionTypeDef
See StatusUpdateIntervalType