# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'ChannelAacSettingsArgs',
    'ChannelAc3SettingsArgs',
    'ChannelAncillarySourceSettingsArgs',
    'ChannelArchiveCdnSettingsArgs',
    'ChannelArchiveContainerSettingsArgs',
    'ChannelArchiveGroupSettingsArgs',
    'ChannelArchiveOutputSettingsArgs',
    'ChannelArchiveS3SettingsArgs',
    'ChannelAribDestinationSettingsArgs',
    'ChannelAribSourceSettingsArgs',
    'ChannelAudioChannelMappingArgs',
    'ChannelAudioCodecSettingsArgs',
    'ChannelAudioDescriptionArgs',
    'ChannelAudioLanguageSelectionArgs',
    'ChannelAudioNormalizationSettingsArgs',
    'ChannelAudioOnlyHlsSettingsArgs',
    'ChannelAudioPidSelectionArgs',
    'ChannelAudioSelectorSettingsArgs',
    'ChannelAudioSelectorArgs',
    'ChannelAudioSilenceFailoverSettingsArgs',
    'ChannelAudioTrackSelectionArgs',
    'ChannelAudioTrackArgs',
    'ChannelAutomaticInputFailoverSettingsArgs',
    'ChannelAvailBlankingArgs',
    'ChannelAvailConfigurationArgs',
    'ChannelAvailSettingsArgs',
    'ChannelBlackoutSlateArgs',
    'ChannelBurnInDestinationSettingsArgs',
    'ChannelCaptionDescriptionArgs',
    'ChannelCaptionDestinationSettingsArgs',
    'ChannelCaptionLanguageMappingArgs',
    'ChannelCaptionRectangleArgs',
    'ChannelCaptionSelectorSettingsArgs',
    'ChannelCaptionSelectorArgs',
    'ChannelCdiInputSpecificationArgs',
    'ChannelColorSpacePassthroughSettingsArgs',
    'ChannelDvbNitSettingsArgs',
    'ChannelDvbSdtSettingsArgs',
    'ChannelDvbSubDestinationSettingsArgs',
    'ChannelDvbSubSourceSettingsArgs',
    'ChannelDvbTdtSettingsArgs',
    'ChannelEac3SettingsArgs',
    'ChannelEbuTtDDestinationSettingsArgs',
    'ChannelEmbeddedDestinationSettingsArgs',
    'ChannelEmbeddedPlusScte20DestinationSettingsArgs',
    'ChannelEmbeddedSourceSettingsArgs',
    'ChannelEncoderSettingsArgs',
    'ChannelFailoverConditionSettingsArgs',
    'ChannelFailoverConditionArgs',
    'ChannelFeatureActivationsArgs',
    'ChannelFecOutputSettingsArgs',
    'ChannelFmp4HlsSettingsArgs',
    'ChannelFrameCaptureCdnSettingsArgs',
    'ChannelFrameCaptureGroupSettingsArgs',
    'ChannelFrameCaptureHlsSettingsArgs',
    'ChannelFrameCaptureOutputSettingsArgs',
    'ChannelFrameCaptureS3SettingsArgs',
    'ChannelFrameCaptureSettingsArgs',
    'ChannelGlobalConfigurationArgs',
    'ChannelH264ColorSpaceSettingsArgs',
    'ChannelH264FilterSettingsArgs',
    'ChannelH264SettingsArgs',
    'ChannelH265ColorSpaceSettingsArgs',
    'ChannelH265FilterSettingsArgs',
    'ChannelH265SettingsArgs',
    'ChannelHdr10SettingsArgs',
    'ChannelHlsAkamaiSettingsArgs',
    'ChannelHlsBasicPutSettingsArgs',
    'ChannelHlsCdnSettingsArgs',
    'ChannelHlsGroupSettingsArgs',
    'ChannelHlsInputSettingsArgs',
    'ChannelHlsMediaStoreSettingsArgs',
    'ChannelHlsOutputSettingsArgs',
    'ChannelHlsS3SettingsArgs',
    'ChannelHlsSettingsArgs',
    'ChannelHlsWebdavSettingsArgs',
    'ChannelHtmlMotionGraphicsSettingsArgs',
    'ChannelInputAttachmentArgs',
    'ChannelInputChannelLevelArgs',
    'ChannelInputLocationArgs',
    'ChannelInputLossBehaviorArgs',
    'ChannelInputLossFailoverSettingsArgs',
    'ChannelInputSettingsArgs',
    'ChannelInputSpecificationArgs',
    'ChannelKeyProviderSettingsArgs',
    'ChannelM2tsSettingsArgs',
    'ChannelM3u8SettingsArgs',
    'ChannelMediaPackageGroupSettingsArgs',
    'ChannelMediaPackageOutputDestinationSettingsArgs',
    'ChannelMediaPackageOutputSettingsArgs',
    'ChannelMotionGraphicsConfigurationArgs',
    'ChannelMotionGraphicsSettingsArgs',
    'ChannelMp2SettingsArgs',
    'ChannelMpeg2FilterSettingsArgs',
    'ChannelMpeg2SettingsArgs',
    'ChannelMsSmoothGroupSettingsArgs',
    'ChannelMsSmoothOutputSettingsArgs',
    'ChannelMultiplexGroupSettingsArgs',
    'ChannelMultiplexOutputSettingsArgs',
    'ChannelMultiplexProgramChannelDestinationSettingsArgs',
    'ChannelNetworkInputSettingsArgs',
    'ChannelNielsenConfigurationArgs',
    'ChannelOutputDestinationSettingsArgs',
    'ChannelOutputDestinationArgs',
    'ChannelOutputGroupSettingsArgs',
    'ChannelOutputGroupArgs',
    'ChannelOutputLocationRefArgs',
    'ChannelOutputSettingsArgs',
    'ChannelOutputArgs',
    'ChannelPassThroughSettingsArgs',
    'ChannelRawSettingsArgs',
    'ChannelRec601SettingsArgs',
    'ChannelRec709SettingsArgs',
    'ChannelRemixSettingsArgs',
    'ChannelRtmpCaptionInfoDestinationSettingsArgs',
    'ChannelRtmpGroupSettingsArgs',
    'ChannelRtmpOutputSettingsArgs',
    'ChannelScte20PlusEmbeddedDestinationSettingsArgs',
    'ChannelScte20SourceSettingsArgs',
    'ChannelScte27DestinationSettingsArgs',
    'ChannelScte27SourceSettingsArgs',
    'ChannelScte35SpliceInsertArgs',
    'ChannelScte35TimeSignalAposArgs',
    'ChannelSmpteTtDestinationSettingsArgs',
    'ChannelStandardHlsSettingsArgs',
    'ChannelStaticKeySettingsArgs',
    'ChannelTeletextDestinationSettingsArgs',
    'ChannelTeletextSourceSettingsArgs',
    'ChannelTemporalFilterSettingsArgs',
    'ChannelTimecodeConfigArgs',
    'ChannelTtmlDestinationSettingsArgs',
    'ChannelUdpContainerSettingsArgs',
    'ChannelUdpGroupSettingsArgs',
    'ChannelUdpOutputSettingsArgs',
    'ChannelVideoBlackFailoverSettingsArgs',
    'ChannelVideoCodecSettingsArgs',
    'ChannelVideoDescriptionArgs',
    'ChannelVideoSelectorColorSpaceSettingsArgs',
    'ChannelVideoSelectorPidArgs',
    'ChannelVideoSelectorProgramIdArgs',
    'ChannelVideoSelectorSettingsArgs',
    'ChannelVideoSelectorArgs',
    'ChannelVpcOutputSettingsArgs',
    'ChannelWavSettingsArgs',
    'ChannelWebvttDestinationSettingsArgs',
    'InputInputDestinationRequestArgs',
    'InputInputDeviceSettingsArgs',
    'InputInputSourceRequestArgs',
    'InputInputVpcRequestArgs',
    'InputMediaConnectFlowRequestArgs',
    'InputSecurityGroupInputWhitelistRuleCidrArgs',
]

@pulumi.input_type
class ChannelAacSettingsArgs:
    def __init__(__self__, *,
                 bitrate: Optional[pulumi.Input[float]] = None,
                 coding_mode: Optional[pulumi.Input[str]] = None,
                 input_type: Optional[pulumi.Input[str]] = None,
                 profile: Optional[pulumi.Input[str]] = None,
                 rate_control_mode: Optional[pulumi.Input[str]] = None,
                 raw_format: Optional[pulumi.Input[str]] = None,
                 sample_rate: Optional[pulumi.Input[float]] = None,
                 spec: Optional[pulumi.Input[str]] = None,
                 vbr_quality: Optional[pulumi.Input[str]] = None):
        if bitrate is not None:
            pulumi.set(__self__, "bitrate", bitrate)
        if coding_mode is not None:
            pulumi.set(__self__, "coding_mode", coding_mode)
        if input_type is not None:
            pulumi.set(__self__, "input_type", input_type)
        if profile is not None:
            pulumi.set(__self__, "profile", profile)
        if rate_control_mode is not None:
            pulumi.set(__self__, "rate_control_mode", rate_control_mode)
        if raw_format is not None:
            pulumi.set(__self__, "raw_format", raw_format)
        if sample_rate is not None:
            pulumi.set(__self__, "sample_rate", sample_rate)
        if spec is not None:
            pulumi.set(__self__, "spec", spec)
        if vbr_quality is not None:
            pulumi.set(__self__, "vbr_quality", vbr_quality)

    @property
    @pulumi.getter
    def bitrate(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "bitrate")

    @bitrate.setter
    def bitrate(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "bitrate", value)

    @property
    @pulumi.getter(name="codingMode")
    def coding_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "coding_mode")

    @coding_mode.setter
    def coding_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "coding_mode", value)

    @property
    @pulumi.getter(name="inputType")
    def input_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "input_type")

    @input_type.setter
    def input_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "input_type", value)

    @property
    @pulumi.getter
    def profile(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "profile")

    @profile.setter
    def profile(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "profile", value)

    @property
    @pulumi.getter(name="rateControlMode")
    def rate_control_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "rate_control_mode")

    @rate_control_mode.setter
    def rate_control_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "rate_control_mode", value)

    @property
    @pulumi.getter(name="rawFormat")
    def raw_format(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "raw_format")

    @raw_format.setter
    def raw_format(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "raw_format", value)

    @property
    @pulumi.getter(name="sampleRate")
    def sample_rate(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "sample_rate")

    @sample_rate.setter
    def sample_rate(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "sample_rate", value)

    @property
    @pulumi.getter
    def spec(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "spec")

    @spec.setter
    def spec(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "spec", value)

    @property
    @pulumi.getter(name="vbrQuality")
    def vbr_quality(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "vbr_quality")

    @vbr_quality.setter
    def vbr_quality(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vbr_quality", value)


@pulumi.input_type
class ChannelAc3SettingsArgs:
    def __init__(__self__, *,
                 bitrate: Optional[pulumi.Input[float]] = None,
                 bitstream_mode: Optional[pulumi.Input[str]] = None,
                 coding_mode: Optional[pulumi.Input[str]] = None,
                 dialnorm: Optional[pulumi.Input[int]] = None,
                 drc_profile: Optional[pulumi.Input[str]] = None,
                 lfe_filter: Optional[pulumi.Input[str]] = None,
                 metadata_control: Optional[pulumi.Input[str]] = None):
        if bitrate is not None:
            pulumi.set(__self__, "bitrate", bitrate)
        if bitstream_mode is not None:
            pulumi.set(__self__, "bitstream_mode", bitstream_mode)
        if coding_mode is not None:
            pulumi.set(__self__, "coding_mode", coding_mode)
        if dialnorm is not None:
            pulumi.set(__self__, "dialnorm", dialnorm)
        if drc_profile is not None:
            pulumi.set(__self__, "drc_profile", drc_profile)
        if lfe_filter is not None:
            pulumi.set(__self__, "lfe_filter", lfe_filter)
        if metadata_control is not None:
            pulumi.set(__self__, "metadata_control", metadata_control)

    @property
    @pulumi.getter
    def bitrate(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "bitrate")

    @bitrate.setter
    def bitrate(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "bitrate", value)

    @property
    @pulumi.getter(name="bitstreamMode")
    def bitstream_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "bitstream_mode")

    @bitstream_mode.setter
    def bitstream_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "bitstream_mode", value)

    @property
    @pulumi.getter(name="codingMode")
    def coding_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "coding_mode")

    @coding_mode.setter
    def coding_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "coding_mode", value)

    @property
    @pulumi.getter
    def dialnorm(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "dialnorm")

    @dialnorm.setter
    def dialnorm(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "dialnorm", value)

    @property
    @pulumi.getter(name="drcProfile")
    def drc_profile(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "drc_profile")

    @drc_profile.setter
    def drc_profile(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "drc_profile", value)

    @property
    @pulumi.getter(name="lfeFilter")
    def lfe_filter(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "lfe_filter")

    @lfe_filter.setter
    def lfe_filter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "lfe_filter", value)

    @property
    @pulumi.getter(name="metadataControl")
    def metadata_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "metadata_control")

    @metadata_control.setter
    def metadata_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "metadata_control", value)


@pulumi.input_type
class ChannelAncillarySourceSettingsArgs:
    def __init__(__self__, *,
                 source_ancillary_channel_number: Optional[pulumi.Input[int]] = None):
        if source_ancillary_channel_number is not None:
            pulumi.set(__self__, "source_ancillary_channel_number", source_ancillary_channel_number)

    @property
    @pulumi.getter(name="sourceAncillaryChannelNumber")
    def source_ancillary_channel_number(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "source_ancillary_channel_number")

    @source_ancillary_channel_number.setter
    def source_ancillary_channel_number(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "source_ancillary_channel_number", value)


@pulumi.input_type
class ChannelArchiveCdnSettingsArgs:
    def __init__(__self__, *,
                 archive_s3_settings: Optional[pulumi.Input['ChannelArchiveS3SettingsArgs']] = None):
        if archive_s3_settings is not None:
            pulumi.set(__self__, "archive_s3_settings", archive_s3_settings)

    @property
    @pulumi.getter(name="archiveS3Settings")
    def archive_s3_settings(self) -> Optional[pulumi.Input['ChannelArchiveS3SettingsArgs']]:
        return pulumi.get(self, "archive_s3_settings")

    @archive_s3_settings.setter
    def archive_s3_settings(self, value: Optional[pulumi.Input['ChannelArchiveS3SettingsArgs']]):
        pulumi.set(self, "archive_s3_settings", value)


@pulumi.input_type
class ChannelArchiveContainerSettingsArgs:
    def __init__(__self__, *,
                 m2ts_settings: Optional[pulumi.Input['ChannelM2tsSettingsArgs']] = None,
                 raw_settings: Optional[pulumi.Input['ChannelRawSettingsArgs']] = None):
        if m2ts_settings is not None:
            pulumi.set(__self__, "m2ts_settings", m2ts_settings)
        if raw_settings is not None:
            pulumi.set(__self__, "raw_settings", raw_settings)

    @property
    @pulumi.getter(name="m2tsSettings")
    def m2ts_settings(self) -> Optional[pulumi.Input['ChannelM2tsSettingsArgs']]:
        return pulumi.get(self, "m2ts_settings")

    @m2ts_settings.setter
    def m2ts_settings(self, value: Optional[pulumi.Input['ChannelM2tsSettingsArgs']]):
        pulumi.set(self, "m2ts_settings", value)

    @property
    @pulumi.getter(name="rawSettings")
    def raw_settings(self) -> Optional[pulumi.Input['ChannelRawSettingsArgs']]:
        return pulumi.get(self, "raw_settings")

    @raw_settings.setter
    def raw_settings(self, value: Optional[pulumi.Input['ChannelRawSettingsArgs']]):
        pulumi.set(self, "raw_settings", value)


@pulumi.input_type
class ChannelArchiveGroupSettingsArgs:
    def __init__(__self__, *,
                 archive_cdn_settings: Optional[pulumi.Input['ChannelArchiveCdnSettingsArgs']] = None,
                 destination: Optional[pulumi.Input['ChannelOutputLocationRefArgs']] = None,
                 rollover_interval: Optional[pulumi.Input[int]] = None):
        if archive_cdn_settings is not None:
            pulumi.set(__self__, "archive_cdn_settings", archive_cdn_settings)
        if destination is not None:
            pulumi.set(__self__, "destination", destination)
        if rollover_interval is not None:
            pulumi.set(__self__, "rollover_interval", rollover_interval)

    @property
    @pulumi.getter(name="archiveCdnSettings")
    def archive_cdn_settings(self) -> Optional[pulumi.Input['ChannelArchiveCdnSettingsArgs']]:
        return pulumi.get(self, "archive_cdn_settings")

    @archive_cdn_settings.setter
    def archive_cdn_settings(self, value: Optional[pulumi.Input['ChannelArchiveCdnSettingsArgs']]):
        pulumi.set(self, "archive_cdn_settings", value)

    @property
    @pulumi.getter
    def destination(self) -> Optional[pulumi.Input['ChannelOutputLocationRefArgs']]:
        return pulumi.get(self, "destination")

    @destination.setter
    def destination(self, value: Optional[pulumi.Input['ChannelOutputLocationRefArgs']]):
        pulumi.set(self, "destination", value)

    @property
    @pulumi.getter(name="rolloverInterval")
    def rollover_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "rollover_interval")

    @rollover_interval.setter
    def rollover_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "rollover_interval", value)


@pulumi.input_type
class ChannelArchiveOutputSettingsArgs:
    def __init__(__self__, *,
                 container_settings: Optional[pulumi.Input['ChannelArchiveContainerSettingsArgs']] = None,
                 extension: Optional[pulumi.Input[str]] = None,
                 name_modifier: Optional[pulumi.Input[str]] = None):
        if container_settings is not None:
            pulumi.set(__self__, "container_settings", container_settings)
        if extension is not None:
            pulumi.set(__self__, "extension", extension)
        if name_modifier is not None:
            pulumi.set(__self__, "name_modifier", name_modifier)

    @property
    @pulumi.getter(name="containerSettings")
    def container_settings(self) -> Optional[pulumi.Input['ChannelArchiveContainerSettingsArgs']]:
        return pulumi.get(self, "container_settings")

    @container_settings.setter
    def container_settings(self, value: Optional[pulumi.Input['ChannelArchiveContainerSettingsArgs']]):
        pulumi.set(self, "container_settings", value)

    @property
    @pulumi.getter
    def extension(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "extension")

    @extension.setter
    def extension(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "extension", value)

    @property
    @pulumi.getter(name="nameModifier")
    def name_modifier(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "name_modifier")

    @name_modifier.setter
    def name_modifier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name_modifier", value)


@pulumi.input_type
class ChannelArchiveS3SettingsArgs:
    def __init__(__self__, *,
                 canned_acl: Optional[pulumi.Input[str]] = None):
        if canned_acl is not None:
            pulumi.set(__self__, "canned_acl", canned_acl)

    @property
    @pulumi.getter(name="cannedAcl")
    def canned_acl(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "canned_acl")

    @canned_acl.setter
    def canned_acl(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "canned_acl", value)


@pulumi.input_type
class ChannelAribDestinationSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelAribSourceSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelAudioChannelMappingArgs:
    def __init__(__self__, *,
                 input_channel_levels: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelInputChannelLevelArgs']]]] = None,
                 output_channel: Optional[pulumi.Input[int]] = None):
        if input_channel_levels is not None:
            pulumi.set(__self__, "input_channel_levels", input_channel_levels)
        if output_channel is not None:
            pulumi.set(__self__, "output_channel", output_channel)

    @property
    @pulumi.getter(name="inputChannelLevels")
    def input_channel_levels(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ChannelInputChannelLevelArgs']]]]:
        return pulumi.get(self, "input_channel_levels")

    @input_channel_levels.setter
    def input_channel_levels(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelInputChannelLevelArgs']]]]):
        pulumi.set(self, "input_channel_levels", value)

    @property
    @pulumi.getter(name="outputChannel")
    def output_channel(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "output_channel")

    @output_channel.setter
    def output_channel(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "output_channel", value)


@pulumi.input_type
class ChannelAudioCodecSettingsArgs:
    def __init__(__self__, *,
                 aac_settings: Optional[pulumi.Input['ChannelAacSettingsArgs']] = None,
                 ac3_settings: Optional[pulumi.Input['ChannelAc3SettingsArgs']] = None,
                 eac3_settings: Optional[pulumi.Input['ChannelEac3SettingsArgs']] = None,
                 mp2_settings: Optional[pulumi.Input['ChannelMp2SettingsArgs']] = None,
                 pass_through_settings: Optional[pulumi.Input['ChannelPassThroughSettingsArgs']] = None,
                 wav_settings: Optional[pulumi.Input['ChannelWavSettingsArgs']] = None):
        if aac_settings is not None:
            pulumi.set(__self__, "aac_settings", aac_settings)
        if ac3_settings is not None:
            pulumi.set(__self__, "ac3_settings", ac3_settings)
        if eac3_settings is not None:
            pulumi.set(__self__, "eac3_settings", eac3_settings)
        if mp2_settings is not None:
            pulumi.set(__self__, "mp2_settings", mp2_settings)
        if pass_through_settings is not None:
            pulumi.set(__self__, "pass_through_settings", pass_through_settings)
        if wav_settings is not None:
            pulumi.set(__self__, "wav_settings", wav_settings)

    @property
    @pulumi.getter(name="aacSettings")
    def aac_settings(self) -> Optional[pulumi.Input['ChannelAacSettingsArgs']]:
        return pulumi.get(self, "aac_settings")

    @aac_settings.setter
    def aac_settings(self, value: Optional[pulumi.Input['ChannelAacSettingsArgs']]):
        pulumi.set(self, "aac_settings", value)

    @property
    @pulumi.getter(name="ac3Settings")
    def ac3_settings(self) -> Optional[pulumi.Input['ChannelAc3SettingsArgs']]:
        return pulumi.get(self, "ac3_settings")

    @ac3_settings.setter
    def ac3_settings(self, value: Optional[pulumi.Input['ChannelAc3SettingsArgs']]):
        pulumi.set(self, "ac3_settings", value)

    @property
    @pulumi.getter(name="eac3Settings")
    def eac3_settings(self) -> Optional[pulumi.Input['ChannelEac3SettingsArgs']]:
        return pulumi.get(self, "eac3_settings")

    @eac3_settings.setter
    def eac3_settings(self, value: Optional[pulumi.Input['ChannelEac3SettingsArgs']]):
        pulumi.set(self, "eac3_settings", value)

    @property
    @pulumi.getter(name="mp2Settings")
    def mp2_settings(self) -> Optional[pulumi.Input['ChannelMp2SettingsArgs']]:
        return pulumi.get(self, "mp2_settings")

    @mp2_settings.setter
    def mp2_settings(self, value: Optional[pulumi.Input['ChannelMp2SettingsArgs']]):
        pulumi.set(self, "mp2_settings", value)

    @property
    @pulumi.getter(name="passThroughSettings")
    def pass_through_settings(self) -> Optional[pulumi.Input['ChannelPassThroughSettingsArgs']]:
        return pulumi.get(self, "pass_through_settings")

    @pass_through_settings.setter
    def pass_through_settings(self, value: Optional[pulumi.Input['ChannelPassThroughSettingsArgs']]):
        pulumi.set(self, "pass_through_settings", value)

    @property
    @pulumi.getter(name="wavSettings")
    def wav_settings(self) -> Optional[pulumi.Input['ChannelWavSettingsArgs']]:
        return pulumi.get(self, "wav_settings")

    @wav_settings.setter
    def wav_settings(self, value: Optional[pulumi.Input['ChannelWavSettingsArgs']]):
        pulumi.set(self, "wav_settings", value)


@pulumi.input_type
class ChannelAudioDescriptionArgs:
    def __init__(__self__, *,
                 audio_normalization_settings: Optional[pulumi.Input['ChannelAudioNormalizationSettingsArgs']] = None,
                 audio_selector_name: Optional[pulumi.Input[str]] = None,
                 audio_type: Optional[pulumi.Input[str]] = None,
                 audio_type_control: Optional[pulumi.Input[str]] = None,
                 codec_settings: Optional[pulumi.Input['ChannelAudioCodecSettingsArgs']] = None,
                 language_code: Optional[pulumi.Input[str]] = None,
                 language_code_control: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 remix_settings: Optional[pulumi.Input['ChannelRemixSettingsArgs']] = None,
                 stream_name: Optional[pulumi.Input[str]] = None):
        if audio_normalization_settings is not None:
            pulumi.set(__self__, "audio_normalization_settings", audio_normalization_settings)
        if audio_selector_name is not None:
            pulumi.set(__self__, "audio_selector_name", audio_selector_name)
        if audio_type is not None:
            pulumi.set(__self__, "audio_type", audio_type)
        if audio_type_control is not None:
            pulumi.set(__self__, "audio_type_control", audio_type_control)
        if codec_settings is not None:
            pulumi.set(__self__, "codec_settings", codec_settings)
        if language_code is not None:
            pulumi.set(__self__, "language_code", language_code)
        if language_code_control is not None:
            pulumi.set(__self__, "language_code_control", language_code_control)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if remix_settings is not None:
            pulumi.set(__self__, "remix_settings", remix_settings)
        if stream_name is not None:
            pulumi.set(__self__, "stream_name", stream_name)

    @property
    @pulumi.getter(name="audioNormalizationSettings")
    def audio_normalization_settings(self) -> Optional[pulumi.Input['ChannelAudioNormalizationSettingsArgs']]:
        return pulumi.get(self, "audio_normalization_settings")

    @audio_normalization_settings.setter
    def audio_normalization_settings(self, value: Optional[pulumi.Input['ChannelAudioNormalizationSettingsArgs']]):
        pulumi.set(self, "audio_normalization_settings", value)

    @property
    @pulumi.getter(name="audioSelectorName")
    def audio_selector_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "audio_selector_name")

    @audio_selector_name.setter
    def audio_selector_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "audio_selector_name", value)

    @property
    @pulumi.getter(name="audioType")
    def audio_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "audio_type")

    @audio_type.setter
    def audio_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "audio_type", value)

    @property
    @pulumi.getter(name="audioTypeControl")
    def audio_type_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "audio_type_control")

    @audio_type_control.setter
    def audio_type_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "audio_type_control", value)

    @property
    @pulumi.getter(name="codecSettings")
    def codec_settings(self) -> Optional[pulumi.Input['ChannelAudioCodecSettingsArgs']]:
        return pulumi.get(self, "codec_settings")

    @codec_settings.setter
    def codec_settings(self, value: Optional[pulumi.Input['ChannelAudioCodecSettingsArgs']]):
        pulumi.set(self, "codec_settings", value)

    @property
    @pulumi.getter(name="languageCode")
    def language_code(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "language_code")

    @language_code.setter
    def language_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "language_code", value)

    @property
    @pulumi.getter(name="languageCodeControl")
    def language_code_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "language_code_control")

    @language_code_control.setter
    def language_code_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "language_code_control", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="remixSettings")
    def remix_settings(self) -> Optional[pulumi.Input['ChannelRemixSettingsArgs']]:
        return pulumi.get(self, "remix_settings")

    @remix_settings.setter
    def remix_settings(self, value: Optional[pulumi.Input['ChannelRemixSettingsArgs']]):
        pulumi.set(self, "remix_settings", value)

    @property
    @pulumi.getter(name="streamName")
    def stream_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "stream_name")

    @stream_name.setter
    def stream_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "stream_name", value)


@pulumi.input_type
class ChannelAudioLanguageSelectionArgs:
    def __init__(__self__, *,
                 language_code: Optional[pulumi.Input[str]] = None,
                 language_selection_policy: Optional[pulumi.Input[str]] = None):
        if language_code is not None:
            pulumi.set(__self__, "language_code", language_code)
        if language_selection_policy is not None:
            pulumi.set(__self__, "language_selection_policy", language_selection_policy)

    @property
    @pulumi.getter(name="languageCode")
    def language_code(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "language_code")

    @language_code.setter
    def language_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "language_code", value)

    @property
    @pulumi.getter(name="languageSelectionPolicy")
    def language_selection_policy(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "language_selection_policy")

    @language_selection_policy.setter
    def language_selection_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "language_selection_policy", value)


@pulumi.input_type
class ChannelAudioNormalizationSettingsArgs:
    def __init__(__self__, *,
                 algorithm: Optional[pulumi.Input[str]] = None,
                 algorithm_control: Optional[pulumi.Input[str]] = None,
                 target_lkfs: Optional[pulumi.Input[float]] = None):
        if algorithm is not None:
            pulumi.set(__self__, "algorithm", algorithm)
        if algorithm_control is not None:
            pulumi.set(__self__, "algorithm_control", algorithm_control)
        if target_lkfs is not None:
            pulumi.set(__self__, "target_lkfs", target_lkfs)

    @property
    @pulumi.getter
    def algorithm(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "algorithm")

    @algorithm.setter
    def algorithm(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "algorithm", value)

    @property
    @pulumi.getter(name="algorithmControl")
    def algorithm_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "algorithm_control")

    @algorithm_control.setter
    def algorithm_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "algorithm_control", value)

    @property
    @pulumi.getter(name="targetLkfs")
    def target_lkfs(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "target_lkfs")

    @target_lkfs.setter
    def target_lkfs(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "target_lkfs", value)


@pulumi.input_type
class ChannelAudioOnlyHlsSettingsArgs:
    def __init__(__self__, *,
                 audio_group_id: Optional[pulumi.Input[str]] = None,
                 audio_only_image: Optional[pulumi.Input['ChannelInputLocationArgs']] = None,
                 audio_track_type: Optional[pulumi.Input[str]] = None,
                 segment_type: Optional[pulumi.Input[str]] = None):
        if audio_group_id is not None:
            pulumi.set(__self__, "audio_group_id", audio_group_id)
        if audio_only_image is not None:
            pulumi.set(__self__, "audio_only_image", audio_only_image)
        if audio_track_type is not None:
            pulumi.set(__self__, "audio_track_type", audio_track_type)
        if segment_type is not None:
            pulumi.set(__self__, "segment_type", segment_type)

    @property
    @pulumi.getter(name="audioGroupId")
    def audio_group_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "audio_group_id")

    @audio_group_id.setter
    def audio_group_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "audio_group_id", value)

    @property
    @pulumi.getter(name="audioOnlyImage")
    def audio_only_image(self) -> Optional[pulumi.Input['ChannelInputLocationArgs']]:
        return pulumi.get(self, "audio_only_image")

    @audio_only_image.setter
    def audio_only_image(self, value: Optional[pulumi.Input['ChannelInputLocationArgs']]):
        pulumi.set(self, "audio_only_image", value)

    @property
    @pulumi.getter(name="audioTrackType")
    def audio_track_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "audio_track_type")

    @audio_track_type.setter
    def audio_track_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "audio_track_type", value)

    @property
    @pulumi.getter(name="segmentType")
    def segment_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "segment_type")

    @segment_type.setter
    def segment_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "segment_type", value)


@pulumi.input_type
class ChannelAudioPidSelectionArgs:
    def __init__(__self__, *,
                 pid: Optional[pulumi.Input[int]] = None):
        if pid is not None:
            pulumi.set(__self__, "pid", pid)

    @property
    @pulumi.getter
    def pid(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "pid")

    @pid.setter
    def pid(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "pid", value)


@pulumi.input_type
class ChannelAudioSelectorSettingsArgs:
    def __init__(__self__, *,
                 audio_language_selection: Optional[pulumi.Input['ChannelAudioLanguageSelectionArgs']] = None,
                 audio_pid_selection: Optional[pulumi.Input['ChannelAudioPidSelectionArgs']] = None,
                 audio_track_selection: Optional[pulumi.Input['ChannelAudioTrackSelectionArgs']] = None):
        if audio_language_selection is not None:
            pulumi.set(__self__, "audio_language_selection", audio_language_selection)
        if audio_pid_selection is not None:
            pulumi.set(__self__, "audio_pid_selection", audio_pid_selection)
        if audio_track_selection is not None:
            pulumi.set(__self__, "audio_track_selection", audio_track_selection)

    @property
    @pulumi.getter(name="audioLanguageSelection")
    def audio_language_selection(self) -> Optional[pulumi.Input['ChannelAudioLanguageSelectionArgs']]:
        return pulumi.get(self, "audio_language_selection")

    @audio_language_selection.setter
    def audio_language_selection(self, value: Optional[pulumi.Input['ChannelAudioLanguageSelectionArgs']]):
        pulumi.set(self, "audio_language_selection", value)

    @property
    @pulumi.getter(name="audioPidSelection")
    def audio_pid_selection(self) -> Optional[pulumi.Input['ChannelAudioPidSelectionArgs']]:
        return pulumi.get(self, "audio_pid_selection")

    @audio_pid_selection.setter
    def audio_pid_selection(self, value: Optional[pulumi.Input['ChannelAudioPidSelectionArgs']]):
        pulumi.set(self, "audio_pid_selection", value)

    @property
    @pulumi.getter(name="audioTrackSelection")
    def audio_track_selection(self) -> Optional[pulumi.Input['ChannelAudioTrackSelectionArgs']]:
        return pulumi.get(self, "audio_track_selection")

    @audio_track_selection.setter
    def audio_track_selection(self, value: Optional[pulumi.Input['ChannelAudioTrackSelectionArgs']]):
        pulumi.set(self, "audio_track_selection", value)


@pulumi.input_type
class ChannelAudioSelectorArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 selector_settings: Optional[pulumi.Input['ChannelAudioSelectorSettingsArgs']] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if selector_settings is not None:
            pulumi.set(__self__, "selector_settings", selector_settings)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="selectorSettings")
    def selector_settings(self) -> Optional[pulumi.Input['ChannelAudioSelectorSettingsArgs']]:
        return pulumi.get(self, "selector_settings")

    @selector_settings.setter
    def selector_settings(self, value: Optional[pulumi.Input['ChannelAudioSelectorSettingsArgs']]):
        pulumi.set(self, "selector_settings", value)


@pulumi.input_type
class ChannelAudioSilenceFailoverSettingsArgs:
    def __init__(__self__, *,
                 audio_selector_name: Optional[pulumi.Input[str]] = None,
                 audio_silence_threshold_msec: Optional[pulumi.Input[int]] = None):
        if audio_selector_name is not None:
            pulumi.set(__self__, "audio_selector_name", audio_selector_name)
        if audio_silence_threshold_msec is not None:
            pulumi.set(__self__, "audio_silence_threshold_msec", audio_silence_threshold_msec)

    @property
    @pulumi.getter(name="audioSelectorName")
    def audio_selector_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "audio_selector_name")

    @audio_selector_name.setter
    def audio_selector_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "audio_selector_name", value)

    @property
    @pulumi.getter(name="audioSilenceThresholdMsec")
    def audio_silence_threshold_msec(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "audio_silence_threshold_msec")

    @audio_silence_threshold_msec.setter
    def audio_silence_threshold_msec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "audio_silence_threshold_msec", value)


@pulumi.input_type
class ChannelAudioTrackSelectionArgs:
    def __init__(__self__, *,
                 tracks: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelAudioTrackArgs']]]] = None):
        if tracks is not None:
            pulumi.set(__self__, "tracks", tracks)

    @property
    @pulumi.getter
    def tracks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ChannelAudioTrackArgs']]]]:
        return pulumi.get(self, "tracks")

    @tracks.setter
    def tracks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelAudioTrackArgs']]]]):
        pulumi.set(self, "tracks", value)


@pulumi.input_type
class ChannelAudioTrackArgs:
    def __init__(__self__, *,
                 track: Optional[pulumi.Input[int]] = None):
        if track is not None:
            pulumi.set(__self__, "track", track)

    @property
    @pulumi.getter
    def track(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "track")

    @track.setter
    def track(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "track", value)


@pulumi.input_type
class ChannelAutomaticInputFailoverSettingsArgs:
    def __init__(__self__, *,
                 error_clear_time_msec: Optional[pulumi.Input[int]] = None,
                 failover_conditions: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelFailoverConditionArgs']]]] = None,
                 input_preference: Optional[pulumi.Input[str]] = None,
                 secondary_input_id: Optional[pulumi.Input[str]] = None):
        if error_clear_time_msec is not None:
            pulumi.set(__self__, "error_clear_time_msec", error_clear_time_msec)
        if failover_conditions is not None:
            pulumi.set(__self__, "failover_conditions", failover_conditions)
        if input_preference is not None:
            pulumi.set(__self__, "input_preference", input_preference)
        if secondary_input_id is not None:
            pulumi.set(__self__, "secondary_input_id", secondary_input_id)

    @property
    @pulumi.getter(name="errorClearTimeMsec")
    def error_clear_time_msec(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "error_clear_time_msec")

    @error_clear_time_msec.setter
    def error_clear_time_msec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "error_clear_time_msec", value)

    @property
    @pulumi.getter(name="failoverConditions")
    def failover_conditions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ChannelFailoverConditionArgs']]]]:
        return pulumi.get(self, "failover_conditions")

    @failover_conditions.setter
    def failover_conditions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelFailoverConditionArgs']]]]):
        pulumi.set(self, "failover_conditions", value)

    @property
    @pulumi.getter(name="inputPreference")
    def input_preference(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "input_preference")

    @input_preference.setter
    def input_preference(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "input_preference", value)

    @property
    @pulumi.getter(name="secondaryInputId")
    def secondary_input_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "secondary_input_id")

    @secondary_input_id.setter
    def secondary_input_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "secondary_input_id", value)


@pulumi.input_type
class ChannelAvailBlankingArgs:
    def __init__(__self__, *,
                 avail_blanking_image: Optional[pulumi.Input['ChannelInputLocationArgs']] = None,
                 state: Optional[pulumi.Input[str]] = None):
        if avail_blanking_image is not None:
            pulumi.set(__self__, "avail_blanking_image", avail_blanking_image)
        if state is not None:
            pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter(name="availBlankingImage")
    def avail_blanking_image(self) -> Optional[pulumi.Input['ChannelInputLocationArgs']]:
        return pulumi.get(self, "avail_blanking_image")

    @avail_blanking_image.setter
    def avail_blanking_image(self, value: Optional[pulumi.Input['ChannelInputLocationArgs']]):
        pulumi.set(self, "avail_blanking_image", value)

    @property
    @pulumi.getter
    def state(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "state")

    @state.setter
    def state(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "state", value)


@pulumi.input_type
class ChannelAvailConfigurationArgs:
    def __init__(__self__, *,
                 avail_settings: Optional[pulumi.Input['ChannelAvailSettingsArgs']] = None):
        if avail_settings is not None:
            pulumi.set(__self__, "avail_settings", avail_settings)

    @property
    @pulumi.getter(name="availSettings")
    def avail_settings(self) -> Optional[pulumi.Input['ChannelAvailSettingsArgs']]:
        return pulumi.get(self, "avail_settings")

    @avail_settings.setter
    def avail_settings(self, value: Optional[pulumi.Input['ChannelAvailSettingsArgs']]):
        pulumi.set(self, "avail_settings", value)


@pulumi.input_type
class ChannelAvailSettingsArgs:
    def __init__(__self__, *,
                 scte35_splice_insert: Optional[pulumi.Input['ChannelScte35SpliceInsertArgs']] = None,
                 scte35_time_signal_apos: Optional[pulumi.Input['ChannelScte35TimeSignalAposArgs']] = None):
        if scte35_splice_insert is not None:
            pulumi.set(__self__, "scte35_splice_insert", scte35_splice_insert)
        if scte35_time_signal_apos is not None:
            pulumi.set(__self__, "scte35_time_signal_apos", scte35_time_signal_apos)

    @property
    @pulumi.getter(name="scte35SpliceInsert")
    def scte35_splice_insert(self) -> Optional[pulumi.Input['ChannelScte35SpliceInsertArgs']]:
        return pulumi.get(self, "scte35_splice_insert")

    @scte35_splice_insert.setter
    def scte35_splice_insert(self, value: Optional[pulumi.Input['ChannelScte35SpliceInsertArgs']]):
        pulumi.set(self, "scte35_splice_insert", value)

    @property
    @pulumi.getter(name="scte35TimeSignalApos")
    def scte35_time_signal_apos(self) -> Optional[pulumi.Input['ChannelScte35TimeSignalAposArgs']]:
        return pulumi.get(self, "scte35_time_signal_apos")

    @scte35_time_signal_apos.setter
    def scte35_time_signal_apos(self, value: Optional[pulumi.Input['ChannelScte35TimeSignalAposArgs']]):
        pulumi.set(self, "scte35_time_signal_apos", value)


@pulumi.input_type
class ChannelBlackoutSlateArgs:
    def __init__(__self__, *,
                 blackout_slate_image: Optional[pulumi.Input['ChannelInputLocationArgs']] = None,
                 network_end_blackout: Optional[pulumi.Input[str]] = None,
                 network_end_blackout_image: Optional[pulumi.Input['ChannelInputLocationArgs']] = None,
                 network_id: Optional[pulumi.Input[str]] = None,
                 state: Optional[pulumi.Input[str]] = None):
        if blackout_slate_image is not None:
            pulumi.set(__self__, "blackout_slate_image", blackout_slate_image)
        if network_end_blackout is not None:
            pulumi.set(__self__, "network_end_blackout", network_end_blackout)
        if network_end_blackout_image is not None:
            pulumi.set(__self__, "network_end_blackout_image", network_end_blackout_image)
        if network_id is not None:
            pulumi.set(__self__, "network_id", network_id)
        if state is not None:
            pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter(name="blackoutSlateImage")
    def blackout_slate_image(self) -> Optional[pulumi.Input['ChannelInputLocationArgs']]:
        return pulumi.get(self, "blackout_slate_image")

    @blackout_slate_image.setter
    def blackout_slate_image(self, value: Optional[pulumi.Input['ChannelInputLocationArgs']]):
        pulumi.set(self, "blackout_slate_image", value)

    @property
    @pulumi.getter(name="networkEndBlackout")
    def network_end_blackout(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "network_end_blackout")

    @network_end_blackout.setter
    def network_end_blackout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_end_blackout", value)

    @property
    @pulumi.getter(name="networkEndBlackoutImage")
    def network_end_blackout_image(self) -> Optional[pulumi.Input['ChannelInputLocationArgs']]:
        return pulumi.get(self, "network_end_blackout_image")

    @network_end_blackout_image.setter
    def network_end_blackout_image(self, value: Optional[pulumi.Input['ChannelInputLocationArgs']]):
        pulumi.set(self, "network_end_blackout_image", value)

    @property
    @pulumi.getter(name="networkId")
    def network_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "network_id")

    @network_id.setter
    def network_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_id", value)

    @property
    @pulumi.getter
    def state(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "state")

    @state.setter
    def state(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "state", value)


@pulumi.input_type
class ChannelBurnInDestinationSettingsArgs:
    def __init__(__self__, *,
                 alignment: Optional[pulumi.Input[str]] = None,
                 background_color: Optional[pulumi.Input[str]] = None,
                 background_opacity: Optional[pulumi.Input[int]] = None,
                 font: Optional[pulumi.Input['ChannelInputLocationArgs']] = None,
                 font_color: Optional[pulumi.Input[str]] = None,
                 font_opacity: Optional[pulumi.Input[int]] = None,
                 font_resolution: Optional[pulumi.Input[int]] = None,
                 font_size: Optional[pulumi.Input[str]] = None,
                 outline_color: Optional[pulumi.Input[str]] = None,
                 outline_size: Optional[pulumi.Input[int]] = None,
                 shadow_color: Optional[pulumi.Input[str]] = None,
                 shadow_opacity: Optional[pulumi.Input[int]] = None,
                 shadow_x_offset: Optional[pulumi.Input[int]] = None,
                 shadow_y_offset: Optional[pulumi.Input[int]] = None,
                 teletext_grid_control: Optional[pulumi.Input[str]] = None,
                 x_position: Optional[pulumi.Input[int]] = None,
                 y_position: Optional[pulumi.Input[int]] = None):
        if alignment is not None:
            pulumi.set(__self__, "alignment", alignment)
        if background_color is not None:
            pulumi.set(__self__, "background_color", background_color)
        if background_opacity is not None:
            pulumi.set(__self__, "background_opacity", background_opacity)
        if font is not None:
            pulumi.set(__self__, "font", font)
        if font_color is not None:
            pulumi.set(__self__, "font_color", font_color)
        if font_opacity is not None:
            pulumi.set(__self__, "font_opacity", font_opacity)
        if font_resolution is not None:
            pulumi.set(__self__, "font_resolution", font_resolution)
        if font_size is not None:
            pulumi.set(__self__, "font_size", font_size)
        if outline_color is not None:
            pulumi.set(__self__, "outline_color", outline_color)
        if outline_size is not None:
            pulumi.set(__self__, "outline_size", outline_size)
        if shadow_color is not None:
            pulumi.set(__self__, "shadow_color", shadow_color)
        if shadow_opacity is not None:
            pulumi.set(__self__, "shadow_opacity", shadow_opacity)
        if shadow_x_offset is not None:
            pulumi.set(__self__, "shadow_x_offset", shadow_x_offset)
        if shadow_y_offset is not None:
            pulumi.set(__self__, "shadow_y_offset", shadow_y_offset)
        if teletext_grid_control is not None:
            pulumi.set(__self__, "teletext_grid_control", teletext_grid_control)
        if x_position is not None:
            pulumi.set(__self__, "x_position", x_position)
        if y_position is not None:
            pulumi.set(__self__, "y_position", y_position)

    @property
    @pulumi.getter
    def alignment(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "alignment")

    @alignment.setter
    def alignment(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "alignment", value)

    @property
    @pulumi.getter(name="backgroundColor")
    def background_color(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "background_color")

    @background_color.setter
    def background_color(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "background_color", value)

    @property
    @pulumi.getter(name="backgroundOpacity")
    def background_opacity(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "background_opacity")

    @background_opacity.setter
    def background_opacity(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "background_opacity", value)

    @property
    @pulumi.getter
    def font(self) -> Optional[pulumi.Input['ChannelInputLocationArgs']]:
        return pulumi.get(self, "font")

    @font.setter
    def font(self, value: Optional[pulumi.Input['ChannelInputLocationArgs']]):
        pulumi.set(self, "font", value)

    @property
    @pulumi.getter(name="fontColor")
    def font_color(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "font_color")

    @font_color.setter
    def font_color(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "font_color", value)

    @property
    @pulumi.getter(name="fontOpacity")
    def font_opacity(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "font_opacity")

    @font_opacity.setter
    def font_opacity(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "font_opacity", value)

    @property
    @pulumi.getter(name="fontResolution")
    def font_resolution(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "font_resolution")

    @font_resolution.setter
    def font_resolution(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "font_resolution", value)

    @property
    @pulumi.getter(name="fontSize")
    def font_size(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "font_size")

    @font_size.setter
    def font_size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "font_size", value)

    @property
    @pulumi.getter(name="outlineColor")
    def outline_color(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "outline_color")

    @outline_color.setter
    def outline_color(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "outline_color", value)

    @property
    @pulumi.getter(name="outlineSize")
    def outline_size(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "outline_size")

    @outline_size.setter
    def outline_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "outline_size", value)

    @property
    @pulumi.getter(name="shadowColor")
    def shadow_color(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "shadow_color")

    @shadow_color.setter
    def shadow_color(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "shadow_color", value)

    @property
    @pulumi.getter(name="shadowOpacity")
    def shadow_opacity(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "shadow_opacity")

    @shadow_opacity.setter
    def shadow_opacity(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "shadow_opacity", value)

    @property
    @pulumi.getter(name="shadowXOffset")
    def shadow_x_offset(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "shadow_x_offset")

    @shadow_x_offset.setter
    def shadow_x_offset(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "shadow_x_offset", value)

    @property
    @pulumi.getter(name="shadowYOffset")
    def shadow_y_offset(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "shadow_y_offset")

    @shadow_y_offset.setter
    def shadow_y_offset(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "shadow_y_offset", value)

    @property
    @pulumi.getter(name="teletextGridControl")
    def teletext_grid_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "teletext_grid_control")

    @teletext_grid_control.setter
    def teletext_grid_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "teletext_grid_control", value)

    @property
    @pulumi.getter(name="xPosition")
    def x_position(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "x_position")

    @x_position.setter
    def x_position(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "x_position", value)

    @property
    @pulumi.getter(name="yPosition")
    def y_position(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "y_position")

    @y_position.setter
    def y_position(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "y_position", value)


@pulumi.input_type
class ChannelCaptionDescriptionArgs:
    def __init__(__self__, *,
                 caption_selector_name: Optional[pulumi.Input[str]] = None,
                 destination_settings: Optional[pulumi.Input['ChannelCaptionDestinationSettingsArgs']] = None,
                 language_code: Optional[pulumi.Input[str]] = None,
                 language_description: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None):
        if caption_selector_name is not None:
            pulumi.set(__self__, "caption_selector_name", caption_selector_name)
        if destination_settings is not None:
            pulumi.set(__self__, "destination_settings", destination_settings)
        if language_code is not None:
            pulumi.set(__self__, "language_code", language_code)
        if language_description is not None:
            pulumi.set(__self__, "language_description", language_description)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter(name="captionSelectorName")
    def caption_selector_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "caption_selector_name")

    @caption_selector_name.setter
    def caption_selector_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "caption_selector_name", value)

    @property
    @pulumi.getter(name="destinationSettings")
    def destination_settings(self) -> Optional[pulumi.Input['ChannelCaptionDestinationSettingsArgs']]:
        return pulumi.get(self, "destination_settings")

    @destination_settings.setter
    def destination_settings(self, value: Optional[pulumi.Input['ChannelCaptionDestinationSettingsArgs']]):
        pulumi.set(self, "destination_settings", value)

    @property
    @pulumi.getter(name="languageCode")
    def language_code(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "language_code")

    @language_code.setter
    def language_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "language_code", value)

    @property
    @pulumi.getter(name="languageDescription")
    def language_description(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "language_description")

    @language_description.setter
    def language_description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "language_description", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class ChannelCaptionDestinationSettingsArgs:
    def __init__(__self__, *,
                 arib_destination_settings: Optional[pulumi.Input['ChannelAribDestinationSettingsArgs']] = None,
                 burn_in_destination_settings: Optional[pulumi.Input['ChannelBurnInDestinationSettingsArgs']] = None,
                 dvb_sub_destination_settings: Optional[pulumi.Input['ChannelDvbSubDestinationSettingsArgs']] = None,
                 ebu_tt_d_destination_settings: Optional[pulumi.Input['ChannelEbuTtDDestinationSettingsArgs']] = None,
                 embedded_destination_settings: Optional[pulumi.Input['ChannelEmbeddedDestinationSettingsArgs']] = None,
                 embedded_plus_scte20_destination_settings: Optional[pulumi.Input['ChannelEmbeddedPlusScte20DestinationSettingsArgs']] = None,
                 rtmp_caption_info_destination_settings: Optional[pulumi.Input['ChannelRtmpCaptionInfoDestinationSettingsArgs']] = None,
                 scte20_plus_embedded_destination_settings: Optional[pulumi.Input['ChannelScte20PlusEmbeddedDestinationSettingsArgs']] = None,
                 scte27_destination_settings: Optional[pulumi.Input['ChannelScte27DestinationSettingsArgs']] = None,
                 smpte_tt_destination_settings: Optional[pulumi.Input['ChannelSmpteTtDestinationSettingsArgs']] = None,
                 teletext_destination_settings: Optional[pulumi.Input['ChannelTeletextDestinationSettingsArgs']] = None,
                 ttml_destination_settings: Optional[pulumi.Input['ChannelTtmlDestinationSettingsArgs']] = None,
                 webvtt_destination_settings: Optional[pulumi.Input['ChannelWebvttDestinationSettingsArgs']] = None):
        if arib_destination_settings is not None:
            pulumi.set(__self__, "arib_destination_settings", arib_destination_settings)
        if burn_in_destination_settings is not None:
            pulumi.set(__self__, "burn_in_destination_settings", burn_in_destination_settings)
        if dvb_sub_destination_settings is not None:
            pulumi.set(__self__, "dvb_sub_destination_settings", dvb_sub_destination_settings)
        if ebu_tt_d_destination_settings is not None:
            pulumi.set(__self__, "ebu_tt_d_destination_settings", ebu_tt_d_destination_settings)
        if embedded_destination_settings is not None:
            pulumi.set(__self__, "embedded_destination_settings", embedded_destination_settings)
        if embedded_plus_scte20_destination_settings is not None:
            pulumi.set(__self__, "embedded_plus_scte20_destination_settings", embedded_plus_scte20_destination_settings)
        if rtmp_caption_info_destination_settings is not None:
            pulumi.set(__self__, "rtmp_caption_info_destination_settings", rtmp_caption_info_destination_settings)
        if scte20_plus_embedded_destination_settings is not None:
            pulumi.set(__self__, "scte20_plus_embedded_destination_settings", scte20_plus_embedded_destination_settings)
        if scte27_destination_settings is not None:
            pulumi.set(__self__, "scte27_destination_settings", scte27_destination_settings)
        if smpte_tt_destination_settings is not None:
            pulumi.set(__self__, "smpte_tt_destination_settings", smpte_tt_destination_settings)
        if teletext_destination_settings is not None:
            pulumi.set(__self__, "teletext_destination_settings", teletext_destination_settings)
        if ttml_destination_settings is not None:
            pulumi.set(__self__, "ttml_destination_settings", ttml_destination_settings)
        if webvtt_destination_settings is not None:
            pulumi.set(__self__, "webvtt_destination_settings", webvtt_destination_settings)

    @property
    @pulumi.getter(name="aribDestinationSettings")
    def arib_destination_settings(self) -> Optional[pulumi.Input['ChannelAribDestinationSettingsArgs']]:
        return pulumi.get(self, "arib_destination_settings")

    @arib_destination_settings.setter
    def arib_destination_settings(self, value: Optional[pulumi.Input['ChannelAribDestinationSettingsArgs']]):
        pulumi.set(self, "arib_destination_settings", value)

    @property
    @pulumi.getter(name="burnInDestinationSettings")
    def burn_in_destination_settings(self) -> Optional[pulumi.Input['ChannelBurnInDestinationSettingsArgs']]:
        return pulumi.get(self, "burn_in_destination_settings")

    @burn_in_destination_settings.setter
    def burn_in_destination_settings(self, value: Optional[pulumi.Input['ChannelBurnInDestinationSettingsArgs']]):
        pulumi.set(self, "burn_in_destination_settings", value)

    @property
    @pulumi.getter(name="dvbSubDestinationSettings")
    def dvb_sub_destination_settings(self) -> Optional[pulumi.Input['ChannelDvbSubDestinationSettingsArgs']]:
        return pulumi.get(self, "dvb_sub_destination_settings")

    @dvb_sub_destination_settings.setter
    def dvb_sub_destination_settings(self, value: Optional[pulumi.Input['ChannelDvbSubDestinationSettingsArgs']]):
        pulumi.set(self, "dvb_sub_destination_settings", value)

    @property
    @pulumi.getter(name="ebuTtDDestinationSettings")
    def ebu_tt_d_destination_settings(self) -> Optional[pulumi.Input['ChannelEbuTtDDestinationSettingsArgs']]:
        return pulumi.get(self, "ebu_tt_d_destination_settings")

    @ebu_tt_d_destination_settings.setter
    def ebu_tt_d_destination_settings(self, value: Optional[pulumi.Input['ChannelEbuTtDDestinationSettingsArgs']]):
        pulumi.set(self, "ebu_tt_d_destination_settings", value)

    @property
    @pulumi.getter(name="embeddedDestinationSettings")
    def embedded_destination_settings(self) -> Optional[pulumi.Input['ChannelEmbeddedDestinationSettingsArgs']]:
        return pulumi.get(self, "embedded_destination_settings")

    @embedded_destination_settings.setter
    def embedded_destination_settings(self, value: Optional[pulumi.Input['ChannelEmbeddedDestinationSettingsArgs']]):
        pulumi.set(self, "embedded_destination_settings", value)

    @property
    @pulumi.getter(name="embeddedPlusScte20DestinationSettings")
    def embedded_plus_scte20_destination_settings(self) -> Optional[pulumi.Input['ChannelEmbeddedPlusScte20DestinationSettingsArgs']]:
        return pulumi.get(self, "embedded_plus_scte20_destination_settings")

    @embedded_plus_scte20_destination_settings.setter
    def embedded_plus_scte20_destination_settings(self, value: Optional[pulumi.Input['ChannelEmbeddedPlusScte20DestinationSettingsArgs']]):
        pulumi.set(self, "embedded_plus_scte20_destination_settings", value)

    @property
    @pulumi.getter(name="rtmpCaptionInfoDestinationSettings")
    def rtmp_caption_info_destination_settings(self) -> Optional[pulumi.Input['ChannelRtmpCaptionInfoDestinationSettingsArgs']]:
        return pulumi.get(self, "rtmp_caption_info_destination_settings")

    @rtmp_caption_info_destination_settings.setter
    def rtmp_caption_info_destination_settings(self, value: Optional[pulumi.Input['ChannelRtmpCaptionInfoDestinationSettingsArgs']]):
        pulumi.set(self, "rtmp_caption_info_destination_settings", value)

    @property
    @pulumi.getter(name="scte20PlusEmbeddedDestinationSettings")
    def scte20_plus_embedded_destination_settings(self) -> Optional[pulumi.Input['ChannelScte20PlusEmbeddedDestinationSettingsArgs']]:
        return pulumi.get(self, "scte20_plus_embedded_destination_settings")

    @scte20_plus_embedded_destination_settings.setter
    def scte20_plus_embedded_destination_settings(self, value: Optional[pulumi.Input['ChannelScte20PlusEmbeddedDestinationSettingsArgs']]):
        pulumi.set(self, "scte20_plus_embedded_destination_settings", value)

    @property
    @pulumi.getter(name="scte27DestinationSettings")
    def scte27_destination_settings(self) -> Optional[pulumi.Input['ChannelScte27DestinationSettingsArgs']]:
        return pulumi.get(self, "scte27_destination_settings")

    @scte27_destination_settings.setter
    def scte27_destination_settings(self, value: Optional[pulumi.Input['ChannelScte27DestinationSettingsArgs']]):
        pulumi.set(self, "scte27_destination_settings", value)

    @property
    @pulumi.getter(name="smpteTtDestinationSettings")
    def smpte_tt_destination_settings(self) -> Optional[pulumi.Input['ChannelSmpteTtDestinationSettingsArgs']]:
        return pulumi.get(self, "smpte_tt_destination_settings")

    @smpte_tt_destination_settings.setter
    def smpte_tt_destination_settings(self, value: Optional[pulumi.Input['ChannelSmpteTtDestinationSettingsArgs']]):
        pulumi.set(self, "smpte_tt_destination_settings", value)

    @property
    @pulumi.getter(name="teletextDestinationSettings")
    def teletext_destination_settings(self) -> Optional[pulumi.Input['ChannelTeletextDestinationSettingsArgs']]:
        return pulumi.get(self, "teletext_destination_settings")

    @teletext_destination_settings.setter
    def teletext_destination_settings(self, value: Optional[pulumi.Input['ChannelTeletextDestinationSettingsArgs']]):
        pulumi.set(self, "teletext_destination_settings", value)

    @property
    @pulumi.getter(name="ttmlDestinationSettings")
    def ttml_destination_settings(self) -> Optional[pulumi.Input['ChannelTtmlDestinationSettingsArgs']]:
        return pulumi.get(self, "ttml_destination_settings")

    @ttml_destination_settings.setter
    def ttml_destination_settings(self, value: Optional[pulumi.Input['ChannelTtmlDestinationSettingsArgs']]):
        pulumi.set(self, "ttml_destination_settings", value)

    @property
    @pulumi.getter(name="webvttDestinationSettings")
    def webvtt_destination_settings(self) -> Optional[pulumi.Input['ChannelWebvttDestinationSettingsArgs']]:
        return pulumi.get(self, "webvtt_destination_settings")

    @webvtt_destination_settings.setter
    def webvtt_destination_settings(self, value: Optional[pulumi.Input['ChannelWebvttDestinationSettingsArgs']]):
        pulumi.set(self, "webvtt_destination_settings", value)


@pulumi.input_type
class ChannelCaptionLanguageMappingArgs:
    def __init__(__self__, *,
                 caption_channel: Optional[pulumi.Input[int]] = None,
                 language_code: Optional[pulumi.Input[str]] = None,
                 language_description: Optional[pulumi.Input[str]] = None):
        if caption_channel is not None:
            pulumi.set(__self__, "caption_channel", caption_channel)
        if language_code is not None:
            pulumi.set(__self__, "language_code", language_code)
        if language_description is not None:
            pulumi.set(__self__, "language_description", language_description)

    @property
    @pulumi.getter(name="captionChannel")
    def caption_channel(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "caption_channel")

    @caption_channel.setter
    def caption_channel(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "caption_channel", value)

    @property
    @pulumi.getter(name="languageCode")
    def language_code(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "language_code")

    @language_code.setter
    def language_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "language_code", value)

    @property
    @pulumi.getter(name="languageDescription")
    def language_description(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "language_description")

    @language_description.setter
    def language_description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "language_description", value)


@pulumi.input_type
class ChannelCaptionRectangleArgs:
    def __init__(__self__, *,
                 height: Optional[pulumi.Input[float]] = None,
                 left_offset: Optional[pulumi.Input[float]] = None,
                 top_offset: Optional[pulumi.Input[float]] = None,
                 width: Optional[pulumi.Input[float]] = None):
        if height is not None:
            pulumi.set(__self__, "height", height)
        if left_offset is not None:
            pulumi.set(__self__, "left_offset", left_offset)
        if top_offset is not None:
            pulumi.set(__self__, "top_offset", top_offset)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def height(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "height")

    @height.setter
    def height(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "height", value)

    @property
    @pulumi.getter(name="leftOffset")
    def left_offset(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "left_offset")

    @left_offset.setter
    def left_offset(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "left_offset", value)

    @property
    @pulumi.getter(name="topOffset")
    def top_offset(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "top_offset")

    @top_offset.setter
    def top_offset(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "top_offset", value)

    @property
    @pulumi.getter
    def width(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "width")

    @width.setter
    def width(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "width", value)


@pulumi.input_type
class ChannelCaptionSelectorSettingsArgs:
    def __init__(__self__, *,
                 ancillary_source_settings: Optional[pulumi.Input['ChannelAncillarySourceSettingsArgs']] = None,
                 arib_source_settings: Optional[pulumi.Input['ChannelAribSourceSettingsArgs']] = None,
                 dvb_sub_source_settings: Optional[pulumi.Input['ChannelDvbSubSourceSettingsArgs']] = None,
                 embedded_source_settings: Optional[pulumi.Input['ChannelEmbeddedSourceSettingsArgs']] = None,
                 scte20_source_settings: Optional[pulumi.Input['ChannelScte20SourceSettingsArgs']] = None,
                 scte27_source_settings: Optional[pulumi.Input['ChannelScte27SourceSettingsArgs']] = None,
                 teletext_source_settings: Optional[pulumi.Input['ChannelTeletextSourceSettingsArgs']] = None):
        if ancillary_source_settings is not None:
            pulumi.set(__self__, "ancillary_source_settings", ancillary_source_settings)
        if arib_source_settings is not None:
            pulumi.set(__self__, "arib_source_settings", arib_source_settings)
        if dvb_sub_source_settings is not None:
            pulumi.set(__self__, "dvb_sub_source_settings", dvb_sub_source_settings)
        if embedded_source_settings is not None:
            pulumi.set(__self__, "embedded_source_settings", embedded_source_settings)
        if scte20_source_settings is not None:
            pulumi.set(__self__, "scte20_source_settings", scte20_source_settings)
        if scte27_source_settings is not None:
            pulumi.set(__self__, "scte27_source_settings", scte27_source_settings)
        if teletext_source_settings is not None:
            pulumi.set(__self__, "teletext_source_settings", teletext_source_settings)

    @property
    @pulumi.getter(name="ancillarySourceSettings")
    def ancillary_source_settings(self) -> Optional[pulumi.Input['ChannelAncillarySourceSettingsArgs']]:
        return pulumi.get(self, "ancillary_source_settings")

    @ancillary_source_settings.setter
    def ancillary_source_settings(self, value: Optional[pulumi.Input['ChannelAncillarySourceSettingsArgs']]):
        pulumi.set(self, "ancillary_source_settings", value)

    @property
    @pulumi.getter(name="aribSourceSettings")
    def arib_source_settings(self) -> Optional[pulumi.Input['ChannelAribSourceSettingsArgs']]:
        return pulumi.get(self, "arib_source_settings")

    @arib_source_settings.setter
    def arib_source_settings(self, value: Optional[pulumi.Input['ChannelAribSourceSettingsArgs']]):
        pulumi.set(self, "arib_source_settings", value)

    @property
    @pulumi.getter(name="dvbSubSourceSettings")
    def dvb_sub_source_settings(self) -> Optional[pulumi.Input['ChannelDvbSubSourceSettingsArgs']]:
        return pulumi.get(self, "dvb_sub_source_settings")

    @dvb_sub_source_settings.setter
    def dvb_sub_source_settings(self, value: Optional[pulumi.Input['ChannelDvbSubSourceSettingsArgs']]):
        pulumi.set(self, "dvb_sub_source_settings", value)

    @property
    @pulumi.getter(name="embeddedSourceSettings")
    def embedded_source_settings(self) -> Optional[pulumi.Input['ChannelEmbeddedSourceSettingsArgs']]:
        return pulumi.get(self, "embedded_source_settings")

    @embedded_source_settings.setter
    def embedded_source_settings(self, value: Optional[pulumi.Input['ChannelEmbeddedSourceSettingsArgs']]):
        pulumi.set(self, "embedded_source_settings", value)

    @property
    @pulumi.getter(name="scte20SourceSettings")
    def scte20_source_settings(self) -> Optional[pulumi.Input['ChannelScte20SourceSettingsArgs']]:
        return pulumi.get(self, "scte20_source_settings")

    @scte20_source_settings.setter
    def scte20_source_settings(self, value: Optional[pulumi.Input['ChannelScte20SourceSettingsArgs']]):
        pulumi.set(self, "scte20_source_settings", value)

    @property
    @pulumi.getter(name="scte27SourceSettings")
    def scte27_source_settings(self) -> Optional[pulumi.Input['ChannelScte27SourceSettingsArgs']]:
        return pulumi.get(self, "scte27_source_settings")

    @scte27_source_settings.setter
    def scte27_source_settings(self, value: Optional[pulumi.Input['ChannelScte27SourceSettingsArgs']]):
        pulumi.set(self, "scte27_source_settings", value)

    @property
    @pulumi.getter(name="teletextSourceSettings")
    def teletext_source_settings(self) -> Optional[pulumi.Input['ChannelTeletextSourceSettingsArgs']]:
        return pulumi.get(self, "teletext_source_settings")

    @teletext_source_settings.setter
    def teletext_source_settings(self, value: Optional[pulumi.Input['ChannelTeletextSourceSettingsArgs']]):
        pulumi.set(self, "teletext_source_settings", value)


@pulumi.input_type
class ChannelCaptionSelectorArgs:
    def __init__(__self__, *,
                 language_code: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 selector_settings: Optional[pulumi.Input['ChannelCaptionSelectorSettingsArgs']] = None):
        if language_code is not None:
            pulumi.set(__self__, "language_code", language_code)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if selector_settings is not None:
            pulumi.set(__self__, "selector_settings", selector_settings)

    @property
    @pulumi.getter(name="languageCode")
    def language_code(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "language_code")

    @language_code.setter
    def language_code(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "language_code", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="selectorSettings")
    def selector_settings(self) -> Optional[pulumi.Input['ChannelCaptionSelectorSettingsArgs']]:
        return pulumi.get(self, "selector_settings")

    @selector_settings.setter
    def selector_settings(self, value: Optional[pulumi.Input['ChannelCaptionSelectorSettingsArgs']]):
        pulumi.set(self, "selector_settings", value)


@pulumi.input_type
class ChannelCdiInputSpecificationArgs:
    def __init__(__self__, *,
                 resolution: Optional[pulumi.Input[str]] = None):
        if resolution is not None:
            pulumi.set(__self__, "resolution", resolution)

    @property
    @pulumi.getter
    def resolution(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resolution")

    @resolution.setter
    def resolution(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resolution", value)


@pulumi.input_type
class ChannelColorSpacePassthroughSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelDvbNitSettingsArgs:
    def __init__(__self__, *,
                 network_id: Optional[pulumi.Input[int]] = None,
                 network_name: Optional[pulumi.Input[str]] = None,
                 rep_interval: Optional[pulumi.Input[int]] = None):
        if network_id is not None:
            pulumi.set(__self__, "network_id", network_id)
        if network_name is not None:
            pulumi.set(__self__, "network_name", network_name)
        if rep_interval is not None:
            pulumi.set(__self__, "rep_interval", rep_interval)

    @property
    @pulumi.getter(name="networkId")
    def network_id(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "network_id")

    @network_id.setter
    def network_id(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "network_id", value)

    @property
    @pulumi.getter(name="networkName")
    def network_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "network_name")

    @network_name.setter
    def network_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "network_name", value)

    @property
    @pulumi.getter(name="repInterval")
    def rep_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "rep_interval")

    @rep_interval.setter
    def rep_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "rep_interval", value)


@pulumi.input_type
class ChannelDvbSdtSettingsArgs:
    def __init__(__self__, *,
                 output_sdt: Optional[pulumi.Input[str]] = None,
                 rep_interval: Optional[pulumi.Input[int]] = None,
                 service_name: Optional[pulumi.Input[str]] = None,
                 service_provider_name: Optional[pulumi.Input[str]] = None):
        if output_sdt is not None:
            pulumi.set(__self__, "output_sdt", output_sdt)
        if rep_interval is not None:
            pulumi.set(__self__, "rep_interval", rep_interval)
        if service_name is not None:
            pulumi.set(__self__, "service_name", service_name)
        if service_provider_name is not None:
            pulumi.set(__self__, "service_provider_name", service_provider_name)

    @property
    @pulumi.getter(name="outputSdt")
    def output_sdt(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "output_sdt")

    @output_sdt.setter
    def output_sdt(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "output_sdt", value)

    @property
    @pulumi.getter(name="repInterval")
    def rep_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "rep_interval")

    @rep_interval.setter
    def rep_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "rep_interval", value)

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "service_name")

    @service_name.setter
    def service_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_name", value)

    @property
    @pulumi.getter(name="serviceProviderName")
    def service_provider_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "service_provider_name")

    @service_provider_name.setter
    def service_provider_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_provider_name", value)


@pulumi.input_type
class ChannelDvbSubDestinationSettingsArgs:
    def __init__(__self__, *,
                 alignment: Optional[pulumi.Input[str]] = None,
                 background_color: Optional[pulumi.Input[str]] = None,
                 background_opacity: Optional[pulumi.Input[int]] = None,
                 font: Optional[pulumi.Input['ChannelInputLocationArgs']] = None,
                 font_color: Optional[pulumi.Input[str]] = None,
                 font_opacity: Optional[pulumi.Input[int]] = None,
                 font_resolution: Optional[pulumi.Input[int]] = None,
                 font_size: Optional[pulumi.Input[str]] = None,
                 outline_color: Optional[pulumi.Input[str]] = None,
                 outline_size: Optional[pulumi.Input[int]] = None,
                 shadow_color: Optional[pulumi.Input[str]] = None,
                 shadow_opacity: Optional[pulumi.Input[int]] = None,
                 shadow_x_offset: Optional[pulumi.Input[int]] = None,
                 shadow_y_offset: Optional[pulumi.Input[int]] = None,
                 teletext_grid_control: Optional[pulumi.Input[str]] = None,
                 x_position: Optional[pulumi.Input[int]] = None,
                 y_position: Optional[pulumi.Input[int]] = None):
        if alignment is not None:
            pulumi.set(__self__, "alignment", alignment)
        if background_color is not None:
            pulumi.set(__self__, "background_color", background_color)
        if background_opacity is not None:
            pulumi.set(__self__, "background_opacity", background_opacity)
        if font is not None:
            pulumi.set(__self__, "font", font)
        if font_color is not None:
            pulumi.set(__self__, "font_color", font_color)
        if font_opacity is not None:
            pulumi.set(__self__, "font_opacity", font_opacity)
        if font_resolution is not None:
            pulumi.set(__self__, "font_resolution", font_resolution)
        if font_size is not None:
            pulumi.set(__self__, "font_size", font_size)
        if outline_color is not None:
            pulumi.set(__self__, "outline_color", outline_color)
        if outline_size is not None:
            pulumi.set(__self__, "outline_size", outline_size)
        if shadow_color is not None:
            pulumi.set(__self__, "shadow_color", shadow_color)
        if shadow_opacity is not None:
            pulumi.set(__self__, "shadow_opacity", shadow_opacity)
        if shadow_x_offset is not None:
            pulumi.set(__self__, "shadow_x_offset", shadow_x_offset)
        if shadow_y_offset is not None:
            pulumi.set(__self__, "shadow_y_offset", shadow_y_offset)
        if teletext_grid_control is not None:
            pulumi.set(__self__, "teletext_grid_control", teletext_grid_control)
        if x_position is not None:
            pulumi.set(__self__, "x_position", x_position)
        if y_position is not None:
            pulumi.set(__self__, "y_position", y_position)

    @property
    @pulumi.getter
    def alignment(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "alignment")

    @alignment.setter
    def alignment(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "alignment", value)

    @property
    @pulumi.getter(name="backgroundColor")
    def background_color(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "background_color")

    @background_color.setter
    def background_color(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "background_color", value)

    @property
    @pulumi.getter(name="backgroundOpacity")
    def background_opacity(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "background_opacity")

    @background_opacity.setter
    def background_opacity(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "background_opacity", value)

    @property
    @pulumi.getter
    def font(self) -> Optional[pulumi.Input['ChannelInputLocationArgs']]:
        return pulumi.get(self, "font")

    @font.setter
    def font(self, value: Optional[pulumi.Input['ChannelInputLocationArgs']]):
        pulumi.set(self, "font", value)

    @property
    @pulumi.getter(name="fontColor")
    def font_color(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "font_color")

    @font_color.setter
    def font_color(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "font_color", value)

    @property
    @pulumi.getter(name="fontOpacity")
    def font_opacity(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "font_opacity")

    @font_opacity.setter
    def font_opacity(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "font_opacity", value)

    @property
    @pulumi.getter(name="fontResolution")
    def font_resolution(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "font_resolution")

    @font_resolution.setter
    def font_resolution(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "font_resolution", value)

    @property
    @pulumi.getter(name="fontSize")
    def font_size(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "font_size")

    @font_size.setter
    def font_size(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "font_size", value)

    @property
    @pulumi.getter(name="outlineColor")
    def outline_color(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "outline_color")

    @outline_color.setter
    def outline_color(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "outline_color", value)

    @property
    @pulumi.getter(name="outlineSize")
    def outline_size(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "outline_size")

    @outline_size.setter
    def outline_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "outline_size", value)

    @property
    @pulumi.getter(name="shadowColor")
    def shadow_color(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "shadow_color")

    @shadow_color.setter
    def shadow_color(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "shadow_color", value)

    @property
    @pulumi.getter(name="shadowOpacity")
    def shadow_opacity(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "shadow_opacity")

    @shadow_opacity.setter
    def shadow_opacity(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "shadow_opacity", value)

    @property
    @pulumi.getter(name="shadowXOffset")
    def shadow_x_offset(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "shadow_x_offset")

    @shadow_x_offset.setter
    def shadow_x_offset(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "shadow_x_offset", value)

    @property
    @pulumi.getter(name="shadowYOffset")
    def shadow_y_offset(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "shadow_y_offset")

    @shadow_y_offset.setter
    def shadow_y_offset(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "shadow_y_offset", value)

    @property
    @pulumi.getter(name="teletextGridControl")
    def teletext_grid_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "teletext_grid_control")

    @teletext_grid_control.setter
    def teletext_grid_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "teletext_grid_control", value)

    @property
    @pulumi.getter(name="xPosition")
    def x_position(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "x_position")

    @x_position.setter
    def x_position(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "x_position", value)

    @property
    @pulumi.getter(name="yPosition")
    def y_position(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "y_position")

    @y_position.setter
    def y_position(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "y_position", value)


@pulumi.input_type
class ChannelDvbSubSourceSettingsArgs:
    def __init__(__self__, *,
                 pid: Optional[pulumi.Input[int]] = None):
        if pid is not None:
            pulumi.set(__self__, "pid", pid)

    @property
    @pulumi.getter
    def pid(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "pid")

    @pid.setter
    def pid(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "pid", value)


@pulumi.input_type
class ChannelDvbTdtSettingsArgs:
    def __init__(__self__, *,
                 rep_interval: Optional[pulumi.Input[int]] = None):
        if rep_interval is not None:
            pulumi.set(__self__, "rep_interval", rep_interval)

    @property
    @pulumi.getter(name="repInterval")
    def rep_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "rep_interval")

    @rep_interval.setter
    def rep_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "rep_interval", value)


@pulumi.input_type
class ChannelEac3SettingsArgs:
    def __init__(__self__, *,
                 attenuation_control: Optional[pulumi.Input[str]] = None,
                 bitrate: Optional[pulumi.Input[float]] = None,
                 bitstream_mode: Optional[pulumi.Input[str]] = None,
                 coding_mode: Optional[pulumi.Input[str]] = None,
                 dc_filter: Optional[pulumi.Input[str]] = None,
                 dialnorm: Optional[pulumi.Input[int]] = None,
                 drc_line: Optional[pulumi.Input[str]] = None,
                 drc_rf: Optional[pulumi.Input[str]] = None,
                 lfe_control: Optional[pulumi.Input[str]] = None,
                 lfe_filter: Optional[pulumi.Input[str]] = None,
                 lo_ro_center_mix_level: Optional[pulumi.Input[float]] = None,
                 lo_ro_surround_mix_level: Optional[pulumi.Input[float]] = None,
                 lt_rt_center_mix_level: Optional[pulumi.Input[float]] = None,
                 lt_rt_surround_mix_level: Optional[pulumi.Input[float]] = None,
                 metadata_control: Optional[pulumi.Input[str]] = None,
                 passthrough_control: Optional[pulumi.Input[str]] = None,
                 phase_control: Optional[pulumi.Input[str]] = None,
                 stereo_downmix: Optional[pulumi.Input[str]] = None,
                 surround_ex_mode: Optional[pulumi.Input[str]] = None,
                 surround_mode: Optional[pulumi.Input[str]] = None):
        if attenuation_control is not None:
            pulumi.set(__self__, "attenuation_control", attenuation_control)
        if bitrate is not None:
            pulumi.set(__self__, "bitrate", bitrate)
        if bitstream_mode is not None:
            pulumi.set(__self__, "bitstream_mode", bitstream_mode)
        if coding_mode is not None:
            pulumi.set(__self__, "coding_mode", coding_mode)
        if dc_filter is not None:
            pulumi.set(__self__, "dc_filter", dc_filter)
        if dialnorm is not None:
            pulumi.set(__self__, "dialnorm", dialnorm)
        if drc_line is not None:
            pulumi.set(__self__, "drc_line", drc_line)
        if drc_rf is not None:
            pulumi.set(__self__, "drc_rf", drc_rf)
        if lfe_control is not None:
            pulumi.set(__self__, "lfe_control", lfe_control)
        if lfe_filter is not None:
            pulumi.set(__self__, "lfe_filter", lfe_filter)
        if lo_ro_center_mix_level is not None:
            pulumi.set(__self__, "lo_ro_center_mix_level", lo_ro_center_mix_level)
        if lo_ro_surround_mix_level is not None:
            pulumi.set(__self__, "lo_ro_surround_mix_level", lo_ro_surround_mix_level)
        if lt_rt_center_mix_level is not None:
            pulumi.set(__self__, "lt_rt_center_mix_level", lt_rt_center_mix_level)
        if lt_rt_surround_mix_level is not None:
            pulumi.set(__self__, "lt_rt_surround_mix_level", lt_rt_surround_mix_level)
        if metadata_control is not None:
            pulumi.set(__self__, "metadata_control", metadata_control)
        if passthrough_control is not None:
            pulumi.set(__self__, "passthrough_control", passthrough_control)
        if phase_control is not None:
            pulumi.set(__self__, "phase_control", phase_control)
        if stereo_downmix is not None:
            pulumi.set(__self__, "stereo_downmix", stereo_downmix)
        if surround_ex_mode is not None:
            pulumi.set(__self__, "surround_ex_mode", surround_ex_mode)
        if surround_mode is not None:
            pulumi.set(__self__, "surround_mode", surround_mode)

    @property
    @pulumi.getter(name="attenuationControl")
    def attenuation_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "attenuation_control")

    @attenuation_control.setter
    def attenuation_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "attenuation_control", value)

    @property
    @pulumi.getter
    def bitrate(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "bitrate")

    @bitrate.setter
    def bitrate(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "bitrate", value)

    @property
    @pulumi.getter(name="bitstreamMode")
    def bitstream_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "bitstream_mode")

    @bitstream_mode.setter
    def bitstream_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "bitstream_mode", value)

    @property
    @pulumi.getter(name="codingMode")
    def coding_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "coding_mode")

    @coding_mode.setter
    def coding_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "coding_mode", value)

    @property
    @pulumi.getter(name="dcFilter")
    def dc_filter(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "dc_filter")

    @dc_filter.setter
    def dc_filter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dc_filter", value)

    @property
    @pulumi.getter
    def dialnorm(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "dialnorm")

    @dialnorm.setter
    def dialnorm(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "dialnorm", value)

    @property
    @pulumi.getter(name="drcLine")
    def drc_line(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "drc_line")

    @drc_line.setter
    def drc_line(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "drc_line", value)

    @property
    @pulumi.getter(name="drcRf")
    def drc_rf(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "drc_rf")

    @drc_rf.setter
    def drc_rf(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "drc_rf", value)

    @property
    @pulumi.getter(name="lfeControl")
    def lfe_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "lfe_control")

    @lfe_control.setter
    def lfe_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "lfe_control", value)

    @property
    @pulumi.getter(name="lfeFilter")
    def lfe_filter(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "lfe_filter")

    @lfe_filter.setter
    def lfe_filter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "lfe_filter", value)

    @property
    @pulumi.getter(name="loRoCenterMixLevel")
    def lo_ro_center_mix_level(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "lo_ro_center_mix_level")

    @lo_ro_center_mix_level.setter
    def lo_ro_center_mix_level(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "lo_ro_center_mix_level", value)

    @property
    @pulumi.getter(name="loRoSurroundMixLevel")
    def lo_ro_surround_mix_level(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "lo_ro_surround_mix_level")

    @lo_ro_surround_mix_level.setter
    def lo_ro_surround_mix_level(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "lo_ro_surround_mix_level", value)

    @property
    @pulumi.getter(name="ltRtCenterMixLevel")
    def lt_rt_center_mix_level(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "lt_rt_center_mix_level")

    @lt_rt_center_mix_level.setter
    def lt_rt_center_mix_level(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "lt_rt_center_mix_level", value)

    @property
    @pulumi.getter(name="ltRtSurroundMixLevel")
    def lt_rt_surround_mix_level(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "lt_rt_surround_mix_level")

    @lt_rt_surround_mix_level.setter
    def lt_rt_surround_mix_level(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "lt_rt_surround_mix_level", value)

    @property
    @pulumi.getter(name="metadataControl")
    def metadata_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "metadata_control")

    @metadata_control.setter
    def metadata_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "metadata_control", value)

    @property
    @pulumi.getter(name="passthroughControl")
    def passthrough_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "passthrough_control")

    @passthrough_control.setter
    def passthrough_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "passthrough_control", value)

    @property
    @pulumi.getter(name="phaseControl")
    def phase_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "phase_control")

    @phase_control.setter
    def phase_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "phase_control", value)

    @property
    @pulumi.getter(name="stereoDownmix")
    def stereo_downmix(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "stereo_downmix")

    @stereo_downmix.setter
    def stereo_downmix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "stereo_downmix", value)

    @property
    @pulumi.getter(name="surroundExMode")
    def surround_ex_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "surround_ex_mode")

    @surround_ex_mode.setter
    def surround_ex_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "surround_ex_mode", value)

    @property
    @pulumi.getter(name="surroundMode")
    def surround_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "surround_mode")

    @surround_mode.setter
    def surround_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "surround_mode", value)


@pulumi.input_type
class ChannelEbuTtDDestinationSettingsArgs:
    def __init__(__self__, *,
                 copyright_holder: Optional[pulumi.Input[str]] = None,
                 fill_line_gap: Optional[pulumi.Input[str]] = None,
                 font_family: Optional[pulumi.Input[str]] = None,
                 style_control: Optional[pulumi.Input[str]] = None):
        if copyright_holder is not None:
            pulumi.set(__self__, "copyright_holder", copyright_holder)
        if fill_line_gap is not None:
            pulumi.set(__self__, "fill_line_gap", fill_line_gap)
        if font_family is not None:
            pulumi.set(__self__, "font_family", font_family)
        if style_control is not None:
            pulumi.set(__self__, "style_control", style_control)

    @property
    @pulumi.getter(name="copyrightHolder")
    def copyright_holder(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "copyright_holder")

    @copyright_holder.setter
    def copyright_holder(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "copyright_holder", value)

    @property
    @pulumi.getter(name="fillLineGap")
    def fill_line_gap(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "fill_line_gap")

    @fill_line_gap.setter
    def fill_line_gap(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "fill_line_gap", value)

    @property
    @pulumi.getter(name="fontFamily")
    def font_family(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "font_family")

    @font_family.setter
    def font_family(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "font_family", value)

    @property
    @pulumi.getter(name="styleControl")
    def style_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "style_control")

    @style_control.setter
    def style_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "style_control", value)


@pulumi.input_type
class ChannelEmbeddedDestinationSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelEmbeddedPlusScte20DestinationSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelEmbeddedSourceSettingsArgs:
    def __init__(__self__, *,
                 convert608_to708: Optional[pulumi.Input[str]] = None,
                 scte20_detection: Optional[pulumi.Input[str]] = None,
                 source608_channel_number: Optional[pulumi.Input[int]] = None,
                 source608_track_number: Optional[pulumi.Input[int]] = None):
        if convert608_to708 is not None:
            pulumi.set(__self__, "convert608_to708", convert608_to708)
        if scte20_detection is not None:
            pulumi.set(__self__, "scte20_detection", scte20_detection)
        if source608_channel_number is not None:
            pulumi.set(__self__, "source608_channel_number", source608_channel_number)
        if source608_track_number is not None:
            pulumi.set(__self__, "source608_track_number", source608_track_number)

    @property
    @pulumi.getter(name="convert608To708")
    def convert608_to708(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "convert608_to708")

    @convert608_to708.setter
    def convert608_to708(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "convert608_to708", value)

    @property
    @pulumi.getter(name="scte20Detection")
    def scte20_detection(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "scte20_detection")

    @scte20_detection.setter
    def scte20_detection(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scte20_detection", value)

    @property
    @pulumi.getter(name="source608ChannelNumber")
    def source608_channel_number(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "source608_channel_number")

    @source608_channel_number.setter
    def source608_channel_number(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "source608_channel_number", value)

    @property
    @pulumi.getter(name="source608TrackNumber")
    def source608_track_number(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "source608_track_number")

    @source608_track_number.setter
    def source608_track_number(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "source608_track_number", value)


@pulumi.input_type
class ChannelEncoderSettingsArgs:
    def __init__(__self__, *,
                 audio_descriptions: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelAudioDescriptionArgs']]]] = None,
                 avail_blanking: Optional[pulumi.Input['ChannelAvailBlankingArgs']] = None,
                 avail_configuration: Optional[pulumi.Input['ChannelAvailConfigurationArgs']] = None,
                 blackout_slate: Optional[pulumi.Input['ChannelBlackoutSlateArgs']] = None,
                 caption_descriptions: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelCaptionDescriptionArgs']]]] = None,
                 feature_activations: Optional[pulumi.Input['ChannelFeatureActivationsArgs']] = None,
                 global_configuration: Optional[pulumi.Input['ChannelGlobalConfigurationArgs']] = None,
                 motion_graphics_configuration: Optional[pulumi.Input['ChannelMotionGraphicsConfigurationArgs']] = None,
                 nielsen_configuration: Optional[pulumi.Input['ChannelNielsenConfigurationArgs']] = None,
                 output_groups: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelOutputGroupArgs']]]] = None,
                 timecode_config: Optional[pulumi.Input['ChannelTimecodeConfigArgs']] = None,
                 video_descriptions: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelVideoDescriptionArgs']]]] = None):
        if audio_descriptions is not None:
            pulumi.set(__self__, "audio_descriptions", audio_descriptions)
        if avail_blanking is not None:
            pulumi.set(__self__, "avail_blanking", avail_blanking)
        if avail_configuration is not None:
            pulumi.set(__self__, "avail_configuration", avail_configuration)
        if blackout_slate is not None:
            pulumi.set(__self__, "blackout_slate", blackout_slate)
        if caption_descriptions is not None:
            pulumi.set(__self__, "caption_descriptions", caption_descriptions)
        if feature_activations is not None:
            pulumi.set(__self__, "feature_activations", feature_activations)
        if global_configuration is not None:
            pulumi.set(__self__, "global_configuration", global_configuration)
        if motion_graphics_configuration is not None:
            pulumi.set(__self__, "motion_graphics_configuration", motion_graphics_configuration)
        if nielsen_configuration is not None:
            pulumi.set(__self__, "nielsen_configuration", nielsen_configuration)
        if output_groups is not None:
            pulumi.set(__self__, "output_groups", output_groups)
        if timecode_config is not None:
            pulumi.set(__self__, "timecode_config", timecode_config)
        if video_descriptions is not None:
            pulumi.set(__self__, "video_descriptions", video_descriptions)

    @property
    @pulumi.getter(name="audioDescriptions")
    def audio_descriptions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ChannelAudioDescriptionArgs']]]]:
        return pulumi.get(self, "audio_descriptions")

    @audio_descriptions.setter
    def audio_descriptions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelAudioDescriptionArgs']]]]):
        pulumi.set(self, "audio_descriptions", value)

    @property
    @pulumi.getter(name="availBlanking")
    def avail_blanking(self) -> Optional[pulumi.Input['ChannelAvailBlankingArgs']]:
        return pulumi.get(self, "avail_blanking")

    @avail_blanking.setter
    def avail_blanking(self, value: Optional[pulumi.Input['ChannelAvailBlankingArgs']]):
        pulumi.set(self, "avail_blanking", value)

    @property
    @pulumi.getter(name="availConfiguration")
    def avail_configuration(self) -> Optional[pulumi.Input['ChannelAvailConfigurationArgs']]:
        return pulumi.get(self, "avail_configuration")

    @avail_configuration.setter
    def avail_configuration(self, value: Optional[pulumi.Input['ChannelAvailConfigurationArgs']]):
        pulumi.set(self, "avail_configuration", value)

    @property
    @pulumi.getter(name="blackoutSlate")
    def blackout_slate(self) -> Optional[pulumi.Input['ChannelBlackoutSlateArgs']]:
        return pulumi.get(self, "blackout_slate")

    @blackout_slate.setter
    def blackout_slate(self, value: Optional[pulumi.Input['ChannelBlackoutSlateArgs']]):
        pulumi.set(self, "blackout_slate", value)

    @property
    @pulumi.getter(name="captionDescriptions")
    def caption_descriptions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ChannelCaptionDescriptionArgs']]]]:
        return pulumi.get(self, "caption_descriptions")

    @caption_descriptions.setter
    def caption_descriptions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelCaptionDescriptionArgs']]]]):
        pulumi.set(self, "caption_descriptions", value)

    @property
    @pulumi.getter(name="featureActivations")
    def feature_activations(self) -> Optional[pulumi.Input['ChannelFeatureActivationsArgs']]:
        return pulumi.get(self, "feature_activations")

    @feature_activations.setter
    def feature_activations(self, value: Optional[pulumi.Input['ChannelFeatureActivationsArgs']]):
        pulumi.set(self, "feature_activations", value)

    @property
    @pulumi.getter(name="globalConfiguration")
    def global_configuration(self) -> Optional[pulumi.Input['ChannelGlobalConfigurationArgs']]:
        return pulumi.get(self, "global_configuration")

    @global_configuration.setter
    def global_configuration(self, value: Optional[pulumi.Input['ChannelGlobalConfigurationArgs']]):
        pulumi.set(self, "global_configuration", value)

    @property
    @pulumi.getter(name="motionGraphicsConfiguration")
    def motion_graphics_configuration(self) -> Optional[pulumi.Input['ChannelMotionGraphicsConfigurationArgs']]:
        return pulumi.get(self, "motion_graphics_configuration")

    @motion_graphics_configuration.setter
    def motion_graphics_configuration(self, value: Optional[pulumi.Input['ChannelMotionGraphicsConfigurationArgs']]):
        pulumi.set(self, "motion_graphics_configuration", value)

    @property
    @pulumi.getter(name="nielsenConfiguration")
    def nielsen_configuration(self) -> Optional[pulumi.Input['ChannelNielsenConfigurationArgs']]:
        return pulumi.get(self, "nielsen_configuration")

    @nielsen_configuration.setter
    def nielsen_configuration(self, value: Optional[pulumi.Input['ChannelNielsenConfigurationArgs']]):
        pulumi.set(self, "nielsen_configuration", value)

    @property
    @pulumi.getter(name="outputGroups")
    def output_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ChannelOutputGroupArgs']]]]:
        return pulumi.get(self, "output_groups")

    @output_groups.setter
    def output_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelOutputGroupArgs']]]]):
        pulumi.set(self, "output_groups", value)

    @property
    @pulumi.getter(name="timecodeConfig")
    def timecode_config(self) -> Optional[pulumi.Input['ChannelTimecodeConfigArgs']]:
        return pulumi.get(self, "timecode_config")

    @timecode_config.setter
    def timecode_config(self, value: Optional[pulumi.Input['ChannelTimecodeConfigArgs']]):
        pulumi.set(self, "timecode_config", value)

    @property
    @pulumi.getter(name="videoDescriptions")
    def video_descriptions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ChannelVideoDescriptionArgs']]]]:
        return pulumi.get(self, "video_descriptions")

    @video_descriptions.setter
    def video_descriptions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelVideoDescriptionArgs']]]]):
        pulumi.set(self, "video_descriptions", value)


@pulumi.input_type
class ChannelFailoverConditionSettingsArgs:
    def __init__(__self__, *,
                 audio_silence_settings: Optional[pulumi.Input['ChannelAudioSilenceFailoverSettingsArgs']] = None,
                 input_loss_settings: Optional[pulumi.Input['ChannelInputLossFailoverSettingsArgs']] = None,
                 video_black_settings: Optional[pulumi.Input['ChannelVideoBlackFailoverSettingsArgs']] = None):
        if audio_silence_settings is not None:
            pulumi.set(__self__, "audio_silence_settings", audio_silence_settings)
        if input_loss_settings is not None:
            pulumi.set(__self__, "input_loss_settings", input_loss_settings)
        if video_black_settings is not None:
            pulumi.set(__self__, "video_black_settings", video_black_settings)

    @property
    @pulumi.getter(name="audioSilenceSettings")
    def audio_silence_settings(self) -> Optional[pulumi.Input['ChannelAudioSilenceFailoverSettingsArgs']]:
        return pulumi.get(self, "audio_silence_settings")

    @audio_silence_settings.setter
    def audio_silence_settings(self, value: Optional[pulumi.Input['ChannelAudioSilenceFailoverSettingsArgs']]):
        pulumi.set(self, "audio_silence_settings", value)

    @property
    @pulumi.getter(name="inputLossSettings")
    def input_loss_settings(self) -> Optional[pulumi.Input['ChannelInputLossFailoverSettingsArgs']]:
        return pulumi.get(self, "input_loss_settings")

    @input_loss_settings.setter
    def input_loss_settings(self, value: Optional[pulumi.Input['ChannelInputLossFailoverSettingsArgs']]):
        pulumi.set(self, "input_loss_settings", value)

    @property
    @pulumi.getter(name="videoBlackSettings")
    def video_black_settings(self) -> Optional[pulumi.Input['ChannelVideoBlackFailoverSettingsArgs']]:
        return pulumi.get(self, "video_black_settings")

    @video_black_settings.setter
    def video_black_settings(self, value: Optional[pulumi.Input['ChannelVideoBlackFailoverSettingsArgs']]):
        pulumi.set(self, "video_black_settings", value)


@pulumi.input_type
class ChannelFailoverConditionArgs:
    def __init__(__self__, *,
                 failover_condition_settings: Optional[pulumi.Input['ChannelFailoverConditionSettingsArgs']] = None):
        if failover_condition_settings is not None:
            pulumi.set(__self__, "failover_condition_settings", failover_condition_settings)

    @property
    @pulumi.getter(name="failoverConditionSettings")
    def failover_condition_settings(self) -> Optional[pulumi.Input['ChannelFailoverConditionSettingsArgs']]:
        return pulumi.get(self, "failover_condition_settings")

    @failover_condition_settings.setter
    def failover_condition_settings(self, value: Optional[pulumi.Input['ChannelFailoverConditionSettingsArgs']]):
        pulumi.set(self, "failover_condition_settings", value)


@pulumi.input_type
class ChannelFeatureActivationsArgs:
    def __init__(__self__, *,
                 input_prepare_schedule_actions: Optional[pulumi.Input[str]] = None):
        if input_prepare_schedule_actions is not None:
            pulumi.set(__self__, "input_prepare_schedule_actions", input_prepare_schedule_actions)

    @property
    @pulumi.getter(name="inputPrepareScheduleActions")
    def input_prepare_schedule_actions(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "input_prepare_schedule_actions")

    @input_prepare_schedule_actions.setter
    def input_prepare_schedule_actions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "input_prepare_schedule_actions", value)


@pulumi.input_type
class ChannelFecOutputSettingsArgs:
    def __init__(__self__, *,
                 column_depth: Optional[pulumi.Input[int]] = None,
                 include_fec: Optional[pulumi.Input[str]] = None,
                 row_length: Optional[pulumi.Input[int]] = None):
        if column_depth is not None:
            pulumi.set(__self__, "column_depth", column_depth)
        if include_fec is not None:
            pulumi.set(__self__, "include_fec", include_fec)
        if row_length is not None:
            pulumi.set(__self__, "row_length", row_length)

    @property
    @pulumi.getter(name="columnDepth")
    def column_depth(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "column_depth")

    @column_depth.setter
    def column_depth(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "column_depth", value)

    @property
    @pulumi.getter(name="includeFec")
    def include_fec(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "include_fec")

    @include_fec.setter
    def include_fec(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "include_fec", value)

    @property
    @pulumi.getter(name="rowLength")
    def row_length(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "row_length")

    @row_length.setter
    def row_length(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "row_length", value)


@pulumi.input_type
class ChannelFmp4HlsSettingsArgs:
    def __init__(__self__, *,
                 audio_rendition_sets: Optional[pulumi.Input[str]] = None,
                 nielsen_id3_behavior: Optional[pulumi.Input[str]] = None,
                 timed_metadata_behavior: Optional[pulumi.Input[str]] = None):
        if audio_rendition_sets is not None:
            pulumi.set(__self__, "audio_rendition_sets", audio_rendition_sets)
        if nielsen_id3_behavior is not None:
            pulumi.set(__self__, "nielsen_id3_behavior", nielsen_id3_behavior)
        if timed_metadata_behavior is not None:
            pulumi.set(__self__, "timed_metadata_behavior", timed_metadata_behavior)

    @property
    @pulumi.getter(name="audioRenditionSets")
    def audio_rendition_sets(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "audio_rendition_sets")

    @audio_rendition_sets.setter
    def audio_rendition_sets(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "audio_rendition_sets", value)

    @property
    @pulumi.getter(name="nielsenId3Behavior")
    def nielsen_id3_behavior(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "nielsen_id3_behavior")

    @nielsen_id3_behavior.setter
    def nielsen_id3_behavior(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "nielsen_id3_behavior", value)

    @property
    @pulumi.getter(name="timedMetadataBehavior")
    def timed_metadata_behavior(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "timed_metadata_behavior")

    @timed_metadata_behavior.setter
    def timed_metadata_behavior(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "timed_metadata_behavior", value)


@pulumi.input_type
class ChannelFrameCaptureCdnSettingsArgs:
    def __init__(__self__, *,
                 frame_capture_s3_settings: Optional[pulumi.Input['ChannelFrameCaptureS3SettingsArgs']] = None):
        if frame_capture_s3_settings is not None:
            pulumi.set(__self__, "frame_capture_s3_settings", frame_capture_s3_settings)

    @property
    @pulumi.getter(name="frameCaptureS3Settings")
    def frame_capture_s3_settings(self) -> Optional[pulumi.Input['ChannelFrameCaptureS3SettingsArgs']]:
        return pulumi.get(self, "frame_capture_s3_settings")

    @frame_capture_s3_settings.setter
    def frame_capture_s3_settings(self, value: Optional[pulumi.Input['ChannelFrameCaptureS3SettingsArgs']]):
        pulumi.set(self, "frame_capture_s3_settings", value)


@pulumi.input_type
class ChannelFrameCaptureGroupSettingsArgs:
    def __init__(__self__, *,
                 destination: Optional[pulumi.Input['ChannelOutputLocationRefArgs']] = None,
                 frame_capture_cdn_settings: Optional[pulumi.Input['ChannelFrameCaptureCdnSettingsArgs']] = None):
        if destination is not None:
            pulumi.set(__self__, "destination", destination)
        if frame_capture_cdn_settings is not None:
            pulumi.set(__self__, "frame_capture_cdn_settings", frame_capture_cdn_settings)

    @property
    @pulumi.getter
    def destination(self) -> Optional[pulumi.Input['ChannelOutputLocationRefArgs']]:
        return pulumi.get(self, "destination")

    @destination.setter
    def destination(self, value: Optional[pulumi.Input['ChannelOutputLocationRefArgs']]):
        pulumi.set(self, "destination", value)

    @property
    @pulumi.getter(name="frameCaptureCdnSettings")
    def frame_capture_cdn_settings(self) -> Optional[pulumi.Input['ChannelFrameCaptureCdnSettingsArgs']]:
        return pulumi.get(self, "frame_capture_cdn_settings")

    @frame_capture_cdn_settings.setter
    def frame_capture_cdn_settings(self, value: Optional[pulumi.Input['ChannelFrameCaptureCdnSettingsArgs']]):
        pulumi.set(self, "frame_capture_cdn_settings", value)


@pulumi.input_type
class ChannelFrameCaptureHlsSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelFrameCaptureOutputSettingsArgs:
    def __init__(__self__, *,
                 name_modifier: Optional[pulumi.Input[str]] = None):
        if name_modifier is not None:
            pulumi.set(__self__, "name_modifier", name_modifier)

    @property
    @pulumi.getter(name="nameModifier")
    def name_modifier(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "name_modifier")

    @name_modifier.setter
    def name_modifier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name_modifier", value)


@pulumi.input_type
class ChannelFrameCaptureS3SettingsArgs:
    def __init__(__self__, *,
                 canned_acl: Optional[pulumi.Input[str]] = None):
        if canned_acl is not None:
            pulumi.set(__self__, "canned_acl", canned_acl)

    @property
    @pulumi.getter(name="cannedAcl")
    def canned_acl(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "canned_acl")

    @canned_acl.setter
    def canned_acl(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "canned_acl", value)


@pulumi.input_type
class ChannelFrameCaptureSettingsArgs:
    def __init__(__self__, *,
                 capture_interval: Optional[pulumi.Input[int]] = None,
                 capture_interval_units: Optional[pulumi.Input[str]] = None):
        if capture_interval is not None:
            pulumi.set(__self__, "capture_interval", capture_interval)
        if capture_interval_units is not None:
            pulumi.set(__self__, "capture_interval_units", capture_interval_units)

    @property
    @pulumi.getter(name="captureInterval")
    def capture_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "capture_interval")

    @capture_interval.setter
    def capture_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "capture_interval", value)

    @property
    @pulumi.getter(name="captureIntervalUnits")
    def capture_interval_units(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "capture_interval_units")

    @capture_interval_units.setter
    def capture_interval_units(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "capture_interval_units", value)


@pulumi.input_type
class ChannelGlobalConfigurationArgs:
    def __init__(__self__, *,
                 initial_audio_gain: Optional[pulumi.Input[int]] = None,
                 input_end_action: Optional[pulumi.Input[str]] = None,
                 input_loss_behavior: Optional[pulumi.Input['ChannelInputLossBehaviorArgs']] = None,
                 output_locking_mode: Optional[pulumi.Input[str]] = None,
                 output_timing_source: Optional[pulumi.Input[str]] = None,
                 support_low_framerate_inputs: Optional[pulumi.Input[str]] = None):
        if initial_audio_gain is not None:
            pulumi.set(__self__, "initial_audio_gain", initial_audio_gain)
        if input_end_action is not None:
            pulumi.set(__self__, "input_end_action", input_end_action)
        if input_loss_behavior is not None:
            pulumi.set(__self__, "input_loss_behavior", input_loss_behavior)
        if output_locking_mode is not None:
            pulumi.set(__self__, "output_locking_mode", output_locking_mode)
        if output_timing_source is not None:
            pulumi.set(__self__, "output_timing_source", output_timing_source)
        if support_low_framerate_inputs is not None:
            pulumi.set(__self__, "support_low_framerate_inputs", support_low_framerate_inputs)

    @property
    @pulumi.getter(name="initialAudioGain")
    def initial_audio_gain(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "initial_audio_gain")

    @initial_audio_gain.setter
    def initial_audio_gain(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "initial_audio_gain", value)

    @property
    @pulumi.getter(name="inputEndAction")
    def input_end_action(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "input_end_action")

    @input_end_action.setter
    def input_end_action(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "input_end_action", value)

    @property
    @pulumi.getter(name="inputLossBehavior")
    def input_loss_behavior(self) -> Optional[pulumi.Input['ChannelInputLossBehaviorArgs']]:
        return pulumi.get(self, "input_loss_behavior")

    @input_loss_behavior.setter
    def input_loss_behavior(self, value: Optional[pulumi.Input['ChannelInputLossBehaviorArgs']]):
        pulumi.set(self, "input_loss_behavior", value)

    @property
    @pulumi.getter(name="outputLockingMode")
    def output_locking_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "output_locking_mode")

    @output_locking_mode.setter
    def output_locking_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "output_locking_mode", value)

    @property
    @pulumi.getter(name="outputTimingSource")
    def output_timing_source(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "output_timing_source")

    @output_timing_source.setter
    def output_timing_source(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "output_timing_source", value)

    @property
    @pulumi.getter(name="supportLowFramerateInputs")
    def support_low_framerate_inputs(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "support_low_framerate_inputs")

    @support_low_framerate_inputs.setter
    def support_low_framerate_inputs(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "support_low_framerate_inputs", value)


@pulumi.input_type
class ChannelH264ColorSpaceSettingsArgs:
    def __init__(__self__, *,
                 color_space_passthrough_settings: Optional[pulumi.Input['ChannelColorSpacePassthroughSettingsArgs']] = None,
                 rec601_settings: Optional[pulumi.Input['ChannelRec601SettingsArgs']] = None,
                 rec709_settings: Optional[pulumi.Input['ChannelRec709SettingsArgs']] = None):
        if color_space_passthrough_settings is not None:
            pulumi.set(__self__, "color_space_passthrough_settings", color_space_passthrough_settings)
        if rec601_settings is not None:
            pulumi.set(__self__, "rec601_settings", rec601_settings)
        if rec709_settings is not None:
            pulumi.set(__self__, "rec709_settings", rec709_settings)

    @property
    @pulumi.getter(name="colorSpacePassthroughSettings")
    def color_space_passthrough_settings(self) -> Optional[pulumi.Input['ChannelColorSpacePassthroughSettingsArgs']]:
        return pulumi.get(self, "color_space_passthrough_settings")

    @color_space_passthrough_settings.setter
    def color_space_passthrough_settings(self, value: Optional[pulumi.Input['ChannelColorSpacePassthroughSettingsArgs']]):
        pulumi.set(self, "color_space_passthrough_settings", value)

    @property
    @pulumi.getter(name="rec601Settings")
    def rec601_settings(self) -> Optional[pulumi.Input['ChannelRec601SettingsArgs']]:
        return pulumi.get(self, "rec601_settings")

    @rec601_settings.setter
    def rec601_settings(self, value: Optional[pulumi.Input['ChannelRec601SettingsArgs']]):
        pulumi.set(self, "rec601_settings", value)

    @property
    @pulumi.getter(name="rec709Settings")
    def rec709_settings(self) -> Optional[pulumi.Input['ChannelRec709SettingsArgs']]:
        return pulumi.get(self, "rec709_settings")

    @rec709_settings.setter
    def rec709_settings(self, value: Optional[pulumi.Input['ChannelRec709SettingsArgs']]):
        pulumi.set(self, "rec709_settings", value)


@pulumi.input_type
class ChannelH264FilterSettingsArgs:
    def __init__(__self__, *,
                 temporal_filter_settings: Optional[pulumi.Input['ChannelTemporalFilterSettingsArgs']] = None):
        if temporal_filter_settings is not None:
            pulumi.set(__self__, "temporal_filter_settings", temporal_filter_settings)

    @property
    @pulumi.getter(name="temporalFilterSettings")
    def temporal_filter_settings(self) -> Optional[pulumi.Input['ChannelTemporalFilterSettingsArgs']]:
        return pulumi.get(self, "temporal_filter_settings")

    @temporal_filter_settings.setter
    def temporal_filter_settings(self, value: Optional[pulumi.Input['ChannelTemporalFilterSettingsArgs']]):
        pulumi.set(self, "temporal_filter_settings", value)


@pulumi.input_type
class ChannelH264SettingsArgs:
    def __init__(__self__, *,
                 adaptive_quantization: Optional[pulumi.Input[str]] = None,
                 afd_signaling: Optional[pulumi.Input[str]] = None,
                 bitrate: Optional[pulumi.Input[int]] = None,
                 buf_fill_pct: Optional[pulumi.Input[int]] = None,
                 buf_size: Optional[pulumi.Input[int]] = None,
                 color_metadata: Optional[pulumi.Input[str]] = None,
                 color_space_settings: Optional[pulumi.Input['ChannelH264ColorSpaceSettingsArgs']] = None,
                 entropy_encoding: Optional[pulumi.Input[str]] = None,
                 filter_settings: Optional[pulumi.Input['ChannelH264FilterSettingsArgs']] = None,
                 fixed_afd: Optional[pulumi.Input[str]] = None,
                 flicker_aq: Optional[pulumi.Input[str]] = None,
                 force_field_pictures: Optional[pulumi.Input[str]] = None,
                 framerate_control: Optional[pulumi.Input[str]] = None,
                 framerate_denominator: Optional[pulumi.Input[int]] = None,
                 framerate_numerator: Optional[pulumi.Input[int]] = None,
                 gop_b_reference: Optional[pulumi.Input[str]] = None,
                 gop_closed_cadence: Optional[pulumi.Input[int]] = None,
                 gop_num_b_frames: Optional[pulumi.Input[int]] = None,
                 gop_size: Optional[pulumi.Input[float]] = None,
                 gop_size_units: Optional[pulumi.Input[str]] = None,
                 level: Optional[pulumi.Input[str]] = None,
                 look_ahead_rate_control: Optional[pulumi.Input[str]] = None,
                 max_bitrate: Optional[pulumi.Input[int]] = None,
                 min_i_interval: Optional[pulumi.Input[int]] = None,
                 num_ref_frames: Optional[pulumi.Input[int]] = None,
                 par_control: Optional[pulumi.Input[str]] = None,
                 par_denominator: Optional[pulumi.Input[int]] = None,
                 par_numerator: Optional[pulumi.Input[int]] = None,
                 profile: Optional[pulumi.Input[str]] = None,
                 quality_level: Optional[pulumi.Input[str]] = None,
                 qvbr_quality_level: Optional[pulumi.Input[int]] = None,
                 rate_control_mode: Optional[pulumi.Input[str]] = None,
                 scan_type: Optional[pulumi.Input[str]] = None,
                 scene_change_detect: Optional[pulumi.Input[str]] = None,
                 slices: Optional[pulumi.Input[int]] = None,
                 softness: Optional[pulumi.Input[int]] = None,
                 spatial_aq: Optional[pulumi.Input[str]] = None,
                 subgop_length: Optional[pulumi.Input[str]] = None,
                 syntax: Optional[pulumi.Input[str]] = None,
                 temporal_aq: Optional[pulumi.Input[str]] = None,
                 timecode_insertion: Optional[pulumi.Input[str]] = None):
        if adaptive_quantization is not None:
            pulumi.set(__self__, "adaptive_quantization", adaptive_quantization)
        if afd_signaling is not None:
            pulumi.set(__self__, "afd_signaling", afd_signaling)
        if bitrate is not None:
            pulumi.set(__self__, "bitrate", bitrate)
        if buf_fill_pct is not None:
            pulumi.set(__self__, "buf_fill_pct", buf_fill_pct)
        if buf_size is not None:
            pulumi.set(__self__, "buf_size", buf_size)
        if color_metadata is not None:
            pulumi.set(__self__, "color_metadata", color_metadata)
        if color_space_settings is not None:
            pulumi.set(__self__, "color_space_settings", color_space_settings)
        if entropy_encoding is not None:
            pulumi.set(__self__, "entropy_encoding", entropy_encoding)
        if filter_settings is not None:
            pulumi.set(__self__, "filter_settings", filter_settings)
        if fixed_afd is not None:
            pulumi.set(__self__, "fixed_afd", fixed_afd)
        if flicker_aq is not None:
            pulumi.set(__self__, "flicker_aq", flicker_aq)
        if force_field_pictures is not None:
            pulumi.set(__self__, "force_field_pictures", force_field_pictures)
        if framerate_control is not None:
            pulumi.set(__self__, "framerate_control", framerate_control)
        if framerate_denominator is not None:
            pulumi.set(__self__, "framerate_denominator", framerate_denominator)
        if framerate_numerator is not None:
            pulumi.set(__self__, "framerate_numerator", framerate_numerator)
        if gop_b_reference is not None:
            pulumi.set(__self__, "gop_b_reference", gop_b_reference)
        if gop_closed_cadence is not None:
            pulumi.set(__self__, "gop_closed_cadence", gop_closed_cadence)
        if gop_num_b_frames is not None:
            pulumi.set(__self__, "gop_num_b_frames", gop_num_b_frames)
        if gop_size is not None:
            pulumi.set(__self__, "gop_size", gop_size)
        if gop_size_units is not None:
            pulumi.set(__self__, "gop_size_units", gop_size_units)
        if level is not None:
            pulumi.set(__self__, "level", level)
        if look_ahead_rate_control is not None:
            pulumi.set(__self__, "look_ahead_rate_control", look_ahead_rate_control)
        if max_bitrate is not None:
            pulumi.set(__self__, "max_bitrate", max_bitrate)
        if min_i_interval is not None:
            pulumi.set(__self__, "min_i_interval", min_i_interval)
        if num_ref_frames is not None:
            pulumi.set(__self__, "num_ref_frames", num_ref_frames)
        if par_control is not None:
            pulumi.set(__self__, "par_control", par_control)
        if par_denominator is not None:
            pulumi.set(__self__, "par_denominator", par_denominator)
        if par_numerator is not None:
            pulumi.set(__self__, "par_numerator", par_numerator)
        if profile is not None:
            pulumi.set(__self__, "profile", profile)
        if quality_level is not None:
            pulumi.set(__self__, "quality_level", quality_level)
        if qvbr_quality_level is not None:
            pulumi.set(__self__, "qvbr_quality_level", qvbr_quality_level)
        if rate_control_mode is not None:
            pulumi.set(__self__, "rate_control_mode", rate_control_mode)
        if scan_type is not None:
            pulumi.set(__self__, "scan_type", scan_type)
        if scene_change_detect is not None:
            pulumi.set(__self__, "scene_change_detect", scene_change_detect)
        if slices is not None:
            pulumi.set(__self__, "slices", slices)
        if softness is not None:
            pulumi.set(__self__, "softness", softness)
        if spatial_aq is not None:
            pulumi.set(__self__, "spatial_aq", spatial_aq)
        if subgop_length is not None:
            pulumi.set(__self__, "subgop_length", subgop_length)
        if syntax is not None:
            pulumi.set(__self__, "syntax", syntax)
        if temporal_aq is not None:
            pulumi.set(__self__, "temporal_aq", temporal_aq)
        if timecode_insertion is not None:
            pulumi.set(__self__, "timecode_insertion", timecode_insertion)

    @property
    @pulumi.getter(name="adaptiveQuantization")
    def adaptive_quantization(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "adaptive_quantization")

    @adaptive_quantization.setter
    def adaptive_quantization(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "adaptive_quantization", value)

    @property
    @pulumi.getter(name="afdSignaling")
    def afd_signaling(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "afd_signaling")

    @afd_signaling.setter
    def afd_signaling(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "afd_signaling", value)

    @property
    @pulumi.getter
    def bitrate(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "bitrate")

    @bitrate.setter
    def bitrate(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "bitrate", value)

    @property
    @pulumi.getter(name="bufFillPct")
    def buf_fill_pct(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "buf_fill_pct")

    @buf_fill_pct.setter
    def buf_fill_pct(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "buf_fill_pct", value)

    @property
    @pulumi.getter(name="bufSize")
    def buf_size(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "buf_size")

    @buf_size.setter
    def buf_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "buf_size", value)

    @property
    @pulumi.getter(name="colorMetadata")
    def color_metadata(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "color_metadata")

    @color_metadata.setter
    def color_metadata(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "color_metadata", value)

    @property
    @pulumi.getter(name="colorSpaceSettings")
    def color_space_settings(self) -> Optional[pulumi.Input['ChannelH264ColorSpaceSettingsArgs']]:
        return pulumi.get(self, "color_space_settings")

    @color_space_settings.setter
    def color_space_settings(self, value: Optional[pulumi.Input['ChannelH264ColorSpaceSettingsArgs']]):
        pulumi.set(self, "color_space_settings", value)

    @property
    @pulumi.getter(name="entropyEncoding")
    def entropy_encoding(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "entropy_encoding")

    @entropy_encoding.setter
    def entropy_encoding(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "entropy_encoding", value)

    @property
    @pulumi.getter(name="filterSettings")
    def filter_settings(self) -> Optional[pulumi.Input['ChannelH264FilterSettingsArgs']]:
        return pulumi.get(self, "filter_settings")

    @filter_settings.setter
    def filter_settings(self, value: Optional[pulumi.Input['ChannelH264FilterSettingsArgs']]):
        pulumi.set(self, "filter_settings", value)

    @property
    @pulumi.getter(name="fixedAfd")
    def fixed_afd(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "fixed_afd")

    @fixed_afd.setter
    def fixed_afd(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "fixed_afd", value)

    @property
    @pulumi.getter(name="flickerAq")
    def flicker_aq(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "flicker_aq")

    @flicker_aq.setter
    def flicker_aq(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "flicker_aq", value)

    @property
    @pulumi.getter(name="forceFieldPictures")
    def force_field_pictures(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "force_field_pictures")

    @force_field_pictures.setter
    def force_field_pictures(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "force_field_pictures", value)

    @property
    @pulumi.getter(name="framerateControl")
    def framerate_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "framerate_control")

    @framerate_control.setter
    def framerate_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "framerate_control", value)

    @property
    @pulumi.getter(name="framerateDenominator")
    def framerate_denominator(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "framerate_denominator")

    @framerate_denominator.setter
    def framerate_denominator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "framerate_denominator", value)

    @property
    @pulumi.getter(name="framerateNumerator")
    def framerate_numerator(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "framerate_numerator")

    @framerate_numerator.setter
    def framerate_numerator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "framerate_numerator", value)

    @property
    @pulumi.getter(name="gopBReference")
    def gop_b_reference(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "gop_b_reference")

    @gop_b_reference.setter
    def gop_b_reference(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "gop_b_reference", value)

    @property
    @pulumi.getter(name="gopClosedCadence")
    def gop_closed_cadence(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "gop_closed_cadence")

    @gop_closed_cadence.setter
    def gop_closed_cadence(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "gop_closed_cadence", value)

    @property
    @pulumi.getter(name="gopNumBFrames")
    def gop_num_b_frames(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "gop_num_b_frames")

    @gop_num_b_frames.setter
    def gop_num_b_frames(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "gop_num_b_frames", value)

    @property
    @pulumi.getter(name="gopSize")
    def gop_size(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "gop_size")

    @gop_size.setter
    def gop_size(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "gop_size", value)

    @property
    @pulumi.getter(name="gopSizeUnits")
    def gop_size_units(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "gop_size_units")

    @gop_size_units.setter
    def gop_size_units(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "gop_size_units", value)

    @property
    @pulumi.getter
    def level(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "level")

    @level.setter
    def level(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "level", value)

    @property
    @pulumi.getter(name="lookAheadRateControl")
    def look_ahead_rate_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "look_ahead_rate_control")

    @look_ahead_rate_control.setter
    def look_ahead_rate_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "look_ahead_rate_control", value)

    @property
    @pulumi.getter(name="maxBitrate")
    def max_bitrate(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "max_bitrate")

    @max_bitrate.setter
    def max_bitrate(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_bitrate", value)

    @property
    @pulumi.getter(name="minIInterval")
    def min_i_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "min_i_interval")

    @min_i_interval.setter
    def min_i_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_i_interval", value)

    @property
    @pulumi.getter(name="numRefFrames")
    def num_ref_frames(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "num_ref_frames")

    @num_ref_frames.setter
    def num_ref_frames(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "num_ref_frames", value)

    @property
    @pulumi.getter(name="parControl")
    def par_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "par_control")

    @par_control.setter
    def par_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "par_control", value)

    @property
    @pulumi.getter(name="parDenominator")
    def par_denominator(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "par_denominator")

    @par_denominator.setter
    def par_denominator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "par_denominator", value)

    @property
    @pulumi.getter(name="parNumerator")
    def par_numerator(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "par_numerator")

    @par_numerator.setter
    def par_numerator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "par_numerator", value)

    @property
    @pulumi.getter
    def profile(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "profile")

    @profile.setter
    def profile(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "profile", value)

    @property
    @pulumi.getter(name="qualityLevel")
    def quality_level(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "quality_level")

    @quality_level.setter
    def quality_level(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "quality_level", value)

    @property
    @pulumi.getter(name="qvbrQualityLevel")
    def qvbr_quality_level(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "qvbr_quality_level")

    @qvbr_quality_level.setter
    def qvbr_quality_level(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "qvbr_quality_level", value)

    @property
    @pulumi.getter(name="rateControlMode")
    def rate_control_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "rate_control_mode")

    @rate_control_mode.setter
    def rate_control_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "rate_control_mode", value)

    @property
    @pulumi.getter(name="scanType")
    def scan_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "scan_type")

    @scan_type.setter
    def scan_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scan_type", value)

    @property
    @pulumi.getter(name="sceneChangeDetect")
    def scene_change_detect(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "scene_change_detect")

    @scene_change_detect.setter
    def scene_change_detect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scene_change_detect", value)

    @property
    @pulumi.getter
    def slices(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "slices")

    @slices.setter
    def slices(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "slices", value)

    @property
    @pulumi.getter
    def softness(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "softness")

    @softness.setter
    def softness(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "softness", value)

    @property
    @pulumi.getter(name="spatialAq")
    def spatial_aq(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "spatial_aq")

    @spatial_aq.setter
    def spatial_aq(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "spatial_aq", value)

    @property
    @pulumi.getter(name="subgopLength")
    def subgop_length(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "subgop_length")

    @subgop_length.setter
    def subgop_length(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subgop_length", value)

    @property
    @pulumi.getter
    def syntax(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "syntax")

    @syntax.setter
    def syntax(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "syntax", value)

    @property
    @pulumi.getter(name="temporalAq")
    def temporal_aq(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "temporal_aq")

    @temporal_aq.setter
    def temporal_aq(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "temporal_aq", value)

    @property
    @pulumi.getter(name="timecodeInsertion")
    def timecode_insertion(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "timecode_insertion")

    @timecode_insertion.setter
    def timecode_insertion(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "timecode_insertion", value)


@pulumi.input_type
class ChannelH265ColorSpaceSettingsArgs:
    def __init__(__self__, *,
                 color_space_passthrough_settings: Optional[pulumi.Input['ChannelColorSpacePassthroughSettingsArgs']] = None,
                 hdr10_settings: Optional[pulumi.Input['ChannelHdr10SettingsArgs']] = None,
                 rec601_settings: Optional[pulumi.Input['ChannelRec601SettingsArgs']] = None,
                 rec709_settings: Optional[pulumi.Input['ChannelRec709SettingsArgs']] = None):
        if color_space_passthrough_settings is not None:
            pulumi.set(__self__, "color_space_passthrough_settings", color_space_passthrough_settings)
        if hdr10_settings is not None:
            pulumi.set(__self__, "hdr10_settings", hdr10_settings)
        if rec601_settings is not None:
            pulumi.set(__self__, "rec601_settings", rec601_settings)
        if rec709_settings is not None:
            pulumi.set(__self__, "rec709_settings", rec709_settings)

    @property
    @pulumi.getter(name="colorSpacePassthroughSettings")
    def color_space_passthrough_settings(self) -> Optional[pulumi.Input['ChannelColorSpacePassthroughSettingsArgs']]:
        return pulumi.get(self, "color_space_passthrough_settings")

    @color_space_passthrough_settings.setter
    def color_space_passthrough_settings(self, value: Optional[pulumi.Input['ChannelColorSpacePassthroughSettingsArgs']]):
        pulumi.set(self, "color_space_passthrough_settings", value)

    @property
    @pulumi.getter(name="hdr10Settings")
    def hdr10_settings(self) -> Optional[pulumi.Input['ChannelHdr10SettingsArgs']]:
        return pulumi.get(self, "hdr10_settings")

    @hdr10_settings.setter
    def hdr10_settings(self, value: Optional[pulumi.Input['ChannelHdr10SettingsArgs']]):
        pulumi.set(self, "hdr10_settings", value)

    @property
    @pulumi.getter(name="rec601Settings")
    def rec601_settings(self) -> Optional[pulumi.Input['ChannelRec601SettingsArgs']]:
        return pulumi.get(self, "rec601_settings")

    @rec601_settings.setter
    def rec601_settings(self, value: Optional[pulumi.Input['ChannelRec601SettingsArgs']]):
        pulumi.set(self, "rec601_settings", value)

    @property
    @pulumi.getter(name="rec709Settings")
    def rec709_settings(self) -> Optional[pulumi.Input['ChannelRec709SettingsArgs']]:
        return pulumi.get(self, "rec709_settings")

    @rec709_settings.setter
    def rec709_settings(self, value: Optional[pulumi.Input['ChannelRec709SettingsArgs']]):
        pulumi.set(self, "rec709_settings", value)


@pulumi.input_type
class ChannelH265FilterSettingsArgs:
    def __init__(__self__, *,
                 temporal_filter_settings: Optional[pulumi.Input['ChannelTemporalFilterSettingsArgs']] = None):
        if temporal_filter_settings is not None:
            pulumi.set(__self__, "temporal_filter_settings", temporal_filter_settings)

    @property
    @pulumi.getter(name="temporalFilterSettings")
    def temporal_filter_settings(self) -> Optional[pulumi.Input['ChannelTemporalFilterSettingsArgs']]:
        return pulumi.get(self, "temporal_filter_settings")

    @temporal_filter_settings.setter
    def temporal_filter_settings(self, value: Optional[pulumi.Input['ChannelTemporalFilterSettingsArgs']]):
        pulumi.set(self, "temporal_filter_settings", value)


@pulumi.input_type
class ChannelH265SettingsArgs:
    def __init__(__self__, *,
                 adaptive_quantization: Optional[pulumi.Input[str]] = None,
                 afd_signaling: Optional[pulumi.Input[str]] = None,
                 alternative_transfer_function: Optional[pulumi.Input[str]] = None,
                 bitrate: Optional[pulumi.Input[int]] = None,
                 buf_size: Optional[pulumi.Input[int]] = None,
                 color_metadata: Optional[pulumi.Input[str]] = None,
                 color_space_settings: Optional[pulumi.Input['ChannelH265ColorSpaceSettingsArgs']] = None,
                 filter_settings: Optional[pulumi.Input['ChannelH265FilterSettingsArgs']] = None,
                 fixed_afd: Optional[pulumi.Input[str]] = None,
                 flicker_aq: Optional[pulumi.Input[str]] = None,
                 framerate_denominator: Optional[pulumi.Input[int]] = None,
                 framerate_numerator: Optional[pulumi.Input[int]] = None,
                 gop_closed_cadence: Optional[pulumi.Input[int]] = None,
                 gop_size: Optional[pulumi.Input[float]] = None,
                 gop_size_units: Optional[pulumi.Input[str]] = None,
                 level: Optional[pulumi.Input[str]] = None,
                 look_ahead_rate_control: Optional[pulumi.Input[str]] = None,
                 max_bitrate: Optional[pulumi.Input[int]] = None,
                 min_i_interval: Optional[pulumi.Input[int]] = None,
                 par_denominator: Optional[pulumi.Input[int]] = None,
                 par_numerator: Optional[pulumi.Input[int]] = None,
                 profile: Optional[pulumi.Input[str]] = None,
                 qvbr_quality_level: Optional[pulumi.Input[int]] = None,
                 rate_control_mode: Optional[pulumi.Input[str]] = None,
                 scan_type: Optional[pulumi.Input[str]] = None,
                 scene_change_detect: Optional[pulumi.Input[str]] = None,
                 slices: Optional[pulumi.Input[int]] = None,
                 tier: Optional[pulumi.Input[str]] = None,
                 timecode_insertion: Optional[pulumi.Input[str]] = None):
        if adaptive_quantization is not None:
            pulumi.set(__self__, "adaptive_quantization", adaptive_quantization)
        if afd_signaling is not None:
            pulumi.set(__self__, "afd_signaling", afd_signaling)
        if alternative_transfer_function is not None:
            pulumi.set(__self__, "alternative_transfer_function", alternative_transfer_function)
        if bitrate is not None:
            pulumi.set(__self__, "bitrate", bitrate)
        if buf_size is not None:
            pulumi.set(__self__, "buf_size", buf_size)
        if color_metadata is not None:
            pulumi.set(__self__, "color_metadata", color_metadata)
        if color_space_settings is not None:
            pulumi.set(__self__, "color_space_settings", color_space_settings)
        if filter_settings is not None:
            pulumi.set(__self__, "filter_settings", filter_settings)
        if fixed_afd is not None:
            pulumi.set(__self__, "fixed_afd", fixed_afd)
        if flicker_aq is not None:
            pulumi.set(__self__, "flicker_aq", flicker_aq)
        if framerate_denominator is not None:
            pulumi.set(__self__, "framerate_denominator", framerate_denominator)
        if framerate_numerator is not None:
            pulumi.set(__self__, "framerate_numerator", framerate_numerator)
        if gop_closed_cadence is not None:
            pulumi.set(__self__, "gop_closed_cadence", gop_closed_cadence)
        if gop_size is not None:
            pulumi.set(__self__, "gop_size", gop_size)
        if gop_size_units is not None:
            pulumi.set(__self__, "gop_size_units", gop_size_units)
        if level is not None:
            pulumi.set(__self__, "level", level)
        if look_ahead_rate_control is not None:
            pulumi.set(__self__, "look_ahead_rate_control", look_ahead_rate_control)
        if max_bitrate is not None:
            pulumi.set(__self__, "max_bitrate", max_bitrate)
        if min_i_interval is not None:
            pulumi.set(__self__, "min_i_interval", min_i_interval)
        if par_denominator is not None:
            pulumi.set(__self__, "par_denominator", par_denominator)
        if par_numerator is not None:
            pulumi.set(__self__, "par_numerator", par_numerator)
        if profile is not None:
            pulumi.set(__self__, "profile", profile)
        if qvbr_quality_level is not None:
            pulumi.set(__self__, "qvbr_quality_level", qvbr_quality_level)
        if rate_control_mode is not None:
            pulumi.set(__self__, "rate_control_mode", rate_control_mode)
        if scan_type is not None:
            pulumi.set(__self__, "scan_type", scan_type)
        if scene_change_detect is not None:
            pulumi.set(__self__, "scene_change_detect", scene_change_detect)
        if slices is not None:
            pulumi.set(__self__, "slices", slices)
        if tier is not None:
            pulumi.set(__self__, "tier", tier)
        if timecode_insertion is not None:
            pulumi.set(__self__, "timecode_insertion", timecode_insertion)

    @property
    @pulumi.getter(name="adaptiveQuantization")
    def adaptive_quantization(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "adaptive_quantization")

    @adaptive_quantization.setter
    def adaptive_quantization(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "adaptive_quantization", value)

    @property
    @pulumi.getter(name="afdSignaling")
    def afd_signaling(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "afd_signaling")

    @afd_signaling.setter
    def afd_signaling(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "afd_signaling", value)

    @property
    @pulumi.getter(name="alternativeTransferFunction")
    def alternative_transfer_function(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "alternative_transfer_function")

    @alternative_transfer_function.setter
    def alternative_transfer_function(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "alternative_transfer_function", value)

    @property
    @pulumi.getter
    def bitrate(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "bitrate")

    @bitrate.setter
    def bitrate(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "bitrate", value)

    @property
    @pulumi.getter(name="bufSize")
    def buf_size(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "buf_size")

    @buf_size.setter
    def buf_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "buf_size", value)

    @property
    @pulumi.getter(name="colorMetadata")
    def color_metadata(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "color_metadata")

    @color_metadata.setter
    def color_metadata(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "color_metadata", value)

    @property
    @pulumi.getter(name="colorSpaceSettings")
    def color_space_settings(self) -> Optional[pulumi.Input['ChannelH265ColorSpaceSettingsArgs']]:
        return pulumi.get(self, "color_space_settings")

    @color_space_settings.setter
    def color_space_settings(self, value: Optional[pulumi.Input['ChannelH265ColorSpaceSettingsArgs']]):
        pulumi.set(self, "color_space_settings", value)

    @property
    @pulumi.getter(name="filterSettings")
    def filter_settings(self) -> Optional[pulumi.Input['ChannelH265FilterSettingsArgs']]:
        return pulumi.get(self, "filter_settings")

    @filter_settings.setter
    def filter_settings(self, value: Optional[pulumi.Input['ChannelH265FilterSettingsArgs']]):
        pulumi.set(self, "filter_settings", value)

    @property
    @pulumi.getter(name="fixedAfd")
    def fixed_afd(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "fixed_afd")

    @fixed_afd.setter
    def fixed_afd(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "fixed_afd", value)

    @property
    @pulumi.getter(name="flickerAq")
    def flicker_aq(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "flicker_aq")

    @flicker_aq.setter
    def flicker_aq(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "flicker_aq", value)

    @property
    @pulumi.getter(name="framerateDenominator")
    def framerate_denominator(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "framerate_denominator")

    @framerate_denominator.setter
    def framerate_denominator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "framerate_denominator", value)

    @property
    @pulumi.getter(name="framerateNumerator")
    def framerate_numerator(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "framerate_numerator")

    @framerate_numerator.setter
    def framerate_numerator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "framerate_numerator", value)

    @property
    @pulumi.getter(name="gopClosedCadence")
    def gop_closed_cadence(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "gop_closed_cadence")

    @gop_closed_cadence.setter
    def gop_closed_cadence(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "gop_closed_cadence", value)

    @property
    @pulumi.getter(name="gopSize")
    def gop_size(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "gop_size")

    @gop_size.setter
    def gop_size(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "gop_size", value)

    @property
    @pulumi.getter(name="gopSizeUnits")
    def gop_size_units(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "gop_size_units")

    @gop_size_units.setter
    def gop_size_units(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "gop_size_units", value)

    @property
    @pulumi.getter
    def level(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "level")

    @level.setter
    def level(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "level", value)

    @property
    @pulumi.getter(name="lookAheadRateControl")
    def look_ahead_rate_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "look_ahead_rate_control")

    @look_ahead_rate_control.setter
    def look_ahead_rate_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "look_ahead_rate_control", value)

    @property
    @pulumi.getter(name="maxBitrate")
    def max_bitrate(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "max_bitrate")

    @max_bitrate.setter
    def max_bitrate(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_bitrate", value)

    @property
    @pulumi.getter(name="minIInterval")
    def min_i_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "min_i_interval")

    @min_i_interval.setter
    def min_i_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_i_interval", value)

    @property
    @pulumi.getter(name="parDenominator")
    def par_denominator(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "par_denominator")

    @par_denominator.setter
    def par_denominator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "par_denominator", value)

    @property
    @pulumi.getter(name="parNumerator")
    def par_numerator(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "par_numerator")

    @par_numerator.setter
    def par_numerator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "par_numerator", value)

    @property
    @pulumi.getter
    def profile(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "profile")

    @profile.setter
    def profile(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "profile", value)

    @property
    @pulumi.getter(name="qvbrQualityLevel")
    def qvbr_quality_level(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "qvbr_quality_level")

    @qvbr_quality_level.setter
    def qvbr_quality_level(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "qvbr_quality_level", value)

    @property
    @pulumi.getter(name="rateControlMode")
    def rate_control_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "rate_control_mode")

    @rate_control_mode.setter
    def rate_control_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "rate_control_mode", value)

    @property
    @pulumi.getter(name="scanType")
    def scan_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "scan_type")

    @scan_type.setter
    def scan_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scan_type", value)

    @property
    @pulumi.getter(name="sceneChangeDetect")
    def scene_change_detect(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "scene_change_detect")

    @scene_change_detect.setter
    def scene_change_detect(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scene_change_detect", value)

    @property
    @pulumi.getter
    def slices(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "slices")

    @slices.setter
    def slices(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "slices", value)

    @property
    @pulumi.getter
    def tier(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "tier")

    @tier.setter
    def tier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "tier", value)

    @property
    @pulumi.getter(name="timecodeInsertion")
    def timecode_insertion(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "timecode_insertion")

    @timecode_insertion.setter
    def timecode_insertion(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "timecode_insertion", value)


@pulumi.input_type
class ChannelHdr10SettingsArgs:
    def __init__(__self__, *,
                 max_cll: Optional[pulumi.Input[int]] = None,
                 max_fall: Optional[pulumi.Input[int]] = None):
        if max_cll is not None:
            pulumi.set(__self__, "max_cll", max_cll)
        if max_fall is not None:
            pulumi.set(__self__, "max_fall", max_fall)

    @property
    @pulumi.getter(name="maxCll")
    def max_cll(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "max_cll")

    @max_cll.setter
    def max_cll(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_cll", value)

    @property
    @pulumi.getter(name="maxFall")
    def max_fall(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "max_fall")

    @max_fall.setter
    def max_fall(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_fall", value)


@pulumi.input_type
class ChannelHlsAkamaiSettingsArgs:
    def __init__(__self__, *,
                 connection_retry_interval: Optional[pulumi.Input[int]] = None,
                 filecache_duration: Optional[pulumi.Input[int]] = None,
                 http_transfer_mode: Optional[pulumi.Input[str]] = None,
                 num_retries: Optional[pulumi.Input[int]] = None,
                 restart_delay: Optional[pulumi.Input[int]] = None,
                 salt: Optional[pulumi.Input[str]] = None,
                 token: Optional[pulumi.Input[str]] = None):
        if connection_retry_interval is not None:
            pulumi.set(__self__, "connection_retry_interval", connection_retry_interval)
        if filecache_duration is not None:
            pulumi.set(__self__, "filecache_duration", filecache_duration)
        if http_transfer_mode is not None:
            pulumi.set(__self__, "http_transfer_mode", http_transfer_mode)
        if num_retries is not None:
            pulumi.set(__self__, "num_retries", num_retries)
        if restart_delay is not None:
            pulumi.set(__self__, "restart_delay", restart_delay)
        if salt is not None:
            pulumi.set(__self__, "salt", salt)
        if token is not None:
            pulumi.set(__self__, "token", token)

    @property
    @pulumi.getter(name="connectionRetryInterval")
    def connection_retry_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "connection_retry_interval")

    @connection_retry_interval.setter
    def connection_retry_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "connection_retry_interval", value)

    @property
    @pulumi.getter(name="filecacheDuration")
    def filecache_duration(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "filecache_duration")

    @filecache_duration.setter
    def filecache_duration(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "filecache_duration", value)

    @property
    @pulumi.getter(name="httpTransferMode")
    def http_transfer_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "http_transfer_mode")

    @http_transfer_mode.setter
    def http_transfer_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "http_transfer_mode", value)

    @property
    @pulumi.getter(name="numRetries")
    def num_retries(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "num_retries")

    @num_retries.setter
    def num_retries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "num_retries", value)

    @property
    @pulumi.getter(name="restartDelay")
    def restart_delay(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "restart_delay")

    @restart_delay.setter
    def restart_delay(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "restart_delay", value)

    @property
    @pulumi.getter
    def salt(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "salt")

    @salt.setter
    def salt(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "salt", value)

    @property
    @pulumi.getter
    def token(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "token")

    @token.setter
    def token(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "token", value)


@pulumi.input_type
class ChannelHlsBasicPutSettingsArgs:
    def __init__(__self__, *,
                 connection_retry_interval: Optional[pulumi.Input[int]] = None,
                 filecache_duration: Optional[pulumi.Input[int]] = None,
                 num_retries: Optional[pulumi.Input[int]] = None,
                 restart_delay: Optional[pulumi.Input[int]] = None):
        if connection_retry_interval is not None:
            pulumi.set(__self__, "connection_retry_interval", connection_retry_interval)
        if filecache_duration is not None:
            pulumi.set(__self__, "filecache_duration", filecache_duration)
        if num_retries is not None:
            pulumi.set(__self__, "num_retries", num_retries)
        if restart_delay is not None:
            pulumi.set(__self__, "restart_delay", restart_delay)

    @property
    @pulumi.getter(name="connectionRetryInterval")
    def connection_retry_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "connection_retry_interval")

    @connection_retry_interval.setter
    def connection_retry_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "connection_retry_interval", value)

    @property
    @pulumi.getter(name="filecacheDuration")
    def filecache_duration(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "filecache_duration")

    @filecache_duration.setter
    def filecache_duration(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "filecache_duration", value)

    @property
    @pulumi.getter(name="numRetries")
    def num_retries(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "num_retries")

    @num_retries.setter
    def num_retries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "num_retries", value)

    @property
    @pulumi.getter(name="restartDelay")
    def restart_delay(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "restart_delay")

    @restart_delay.setter
    def restart_delay(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "restart_delay", value)


@pulumi.input_type
class ChannelHlsCdnSettingsArgs:
    def __init__(__self__, *,
                 hls_akamai_settings: Optional[pulumi.Input['ChannelHlsAkamaiSettingsArgs']] = None,
                 hls_basic_put_settings: Optional[pulumi.Input['ChannelHlsBasicPutSettingsArgs']] = None,
                 hls_media_store_settings: Optional[pulumi.Input['ChannelHlsMediaStoreSettingsArgs']] = None,
                 hls_s3_settings: Optional[pulumi.Input['ChannelHlsS3SettingsArgs']] = None,
                 hls_webdav_settings: Optional[pulumi.Input['ChannelHlsWebdavSettingsArgs']] = None):
        if hls_akamai_settings is not None:
            pulumi.set(__self__, "hls_akamai_settings", hls_akamai_settings)
        if hls_basic_put_settings is not None:
            pulumi.set(__self__, "hls_basic_put_settings", hls_basic_put_settings)
        if hls_media_store_settings is not None:
            pulumi.set(__self__, "hls_media_store_settings", hls_media_store_settings)
        if hls_s3_settings is not None:
            pulumi.set(__self__, "hls_s3_settings", hls_s3_settings)
        if hls_webdav_settings is not None:
            pulumi.set(__self__, "hls_webdav_settings", hls_webdav_settings)

    @property
    @pulumi.getter(name="hlsAkamaiSettings")
    def hls_akamai_settings(self) -> Optional[pulumi.Input['ChannelHlsAkamaiSettingsArgs']]:
        return pulumi.get(self, "hls_akamai_settings")

    @hls_akamai_settings.setter
    def hls_akamai_settings(self, value: Optional[pulumi.Input['ChannelHlsAkamaiSettingsArgs']]):
        pulumi.set(self, "hls_akamai_settings", value)

    @property
    @pulumi.getter(name="hlsBasicPutSettings")
    def hls_basic_put_settings(self) -> Optional[pulumi.Input['ChannelHlsBasicPutSettingsArgs']]:
        return pulumi.get(self, "hls_basic_put_settings")

    @hls_basic_put_settings.setter
    def hls_basic_put_settings(self, value: Optional[pulumi.Input['ChannelHlsBasicPutSettingsArgs']]):
        pulumi.set(self, "hls_basic_put_settings", value)

    @property
    @pulumi.getter(name="hlsMediaStoreSettings")
    def hls_media_store_settings(self) -> Optional[pulumi.Input['ChannelHlsMediaStoreSettingsArgs']]:
        return pulumi.get(self, "hls_media_store_settings")

    @hls_media_store_settings.setter
    def hls_media_store_settings(self, value: Optional[pulumi.Input['ChannelHlsMediaStoreSettingsArgs']]):
        pulumi.set(self, "hls_media_store_settings", value)

    @property
    @pulumi.getter(name="hlsS3Settings")
    def hls_s3_settings(self) -> Optional[pulumi.Input['ChannelHlsS3SettingsArgs']]:
        return pulumi.get(self, "hls_s3_settings")

    @hls_s3_settings.setter
    def hls_s3_settings(self, value: Optional[pulumi.Input['ChannelHlsS3SettingsArgs']]):
        pulumi.set(self, "hls_s3_settings", value)

    @property
    @pulumi.getter(name="hlsWebdavSettings")
    def hls_webdav_settings(self) -> Optional[pulumi.Input['ChannelHlsWebdavSettingsArgs']]:
        return pulumi.get(self, "hls_webdav_settings")

    @hls_webdav_settings.setter
    def hls_webdav_settings(self, value: Optional[pulumi.Input['ChannelHlsWebdavSettingsArgs']]):
        pulumi.set(self, "hls_webdav_settings", value)


@pulumi.input_type
class ChannelHlsGroupSettingsArgs:
    def __init__(__self__, *,
                 ad_markers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 base_url_content: Optional[pulumi.Input[str]] = None,
                 base_url_content1: Optional[pulumi.Input[str]] = None,
                 base_url_manifest: Optional[pulumi.Input[str]] = None,
                 base_url_manifest1: Optional[pulumi.Input[str]] = None,
                 caption_language_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelCaptionLanguageMappingArgs']]]] = None,
                 caption_language_setting: Optional[pulumi.Input[str]] = None,
                 client_cache: Optional[pulumi.Input[str]] = None,
                 codec_specification: Optional[pulumi.Input[str]] = None,
                 constant_iv: Optional[pulumi.Input[str]] = None,
                 destination: Optional[pulumi.Input['ChannelOutputLocationRefArgs']] = None,
                 directory_structure: Optional[pulumi.Input[str]] = None,
                 discontinuity_tags: Optional[pulumi.Input[str]] = None,
                 encryption_type: Optional[pulumi.Input[str]] = None,
                 hls_cdn_settings: Optional[pulumi.Input['ChannelHlsCdnSettingsArgs']] = None,
                 hls_id3_segment_tagging: Optional[pulumi.Input[str]] = None,
                 i_frame_only_playlists: Optional[pulumi.Input[str]] = None,
                 incomplete_segment_behavior: Optional[pulumi.Input[str]] = None,
                 index_n_segments: Optional[pulumi.Input[int]] = None,
                 input_loss_action: Optional[pulumi.Input[str]] = None,
                 iv_in_manifest: Optional[pulumi.Input[str]] = None,
                 iv_source: Optional[pulumi.Input[str]] = None,
                 keep_segments: Optional[pulumi.Input[int]] = None,
                 key_format: Optional[pulumi.Input[str]] = None,
                 key_format_versions: Optional[pulumi.Input[str]] = None,
                 key_provider_settings: Optional[pulumi.Input['ChannelKeyProviderSettingsArgs']] = None,
                 manifest_compression: Optional[pulumi.Input[str]] = None,
                 manifest_duration_format: Optional[pulumi.Input[str]] = None,
                 min_segment_length: Optional[pulumi.Input[int]] = None,
                 mode: Optional[pulumi.Input[str]] = None,
                 output_selection: Optional[pulumi.Input[str]] = None,
                 program_date_time: Optional[pulumi.Input[str]] = None,
                 program_date_time_period: Optional[pulumi.Input[int]] = None,
                 redundant_manifest: Optional[pulumi.Input[str]] = None,
                 segment_length: Optional[pulumi.Input[int]] = None,
                 segmentation_mode: Optional[pulumi.Input[str]] = None,
                 segments_per_subdirectory: Optional[pulumi.Input[int]] = None,
                 stream_inf_resolution: Optional[pulumi.Input[str]] = None,
                 timed_metadata_id3_frame: Optional[pulumi.Input[str]] = None,
                 timed_metadata_id3_period: Optional[pulumi.Input[int]] = None,
                 timestamp_delta_milliseconds: Optional[pulumi.Input[int]] = None,
                 ts_file_mode: Optional[pulumi.Input[str]] = None):
        if ad_markers is not None:
            pulumi.set(__self__, "ad_markers", ad_markers)
        if base_url_content is not None:
            pulumi.set(__self__, "base_url_content", base_url_content)
        if base_url_content1 is not None:
            pulumi.set(__self__, "base_url_content1", base_url_content1)
        if base_url_manifest is not None:
            pulumi.set(__self__, "base_url_manifest", base_url_manifest)
        if base_url_manifest1 is not None:
            pulumi.set(__self__, "base_url_manifest1", base_url_manifest1)
        if caption_language_mappings is not None:
            pulumi.set(__self__, "caption_language_mappings", caption_language_mappings)
        if caption_language_setting is not None:
            pulumi.set(__self__, "caption_language_setting", caption_language_setting)
        if client_cache is not None:
            pulumi.set(__self__, "client_cache", client_cache)
        if codec_specification is not None:
            pulumi.set(__self__, "codec_specification", codec_specification)
        if constant_iv is not None:
            pulumi.set(__self__, "constant_iv", constant_iv)
        if destination is not None:
            pulumi.set(__self__, "destination", destination)
        if directory_structure is not None:
            pulumi.set(__self__, "directory_structure", directory_structure)
        if discontinuity_tags is not None:
            pulumi.set(__self__, "discontinuity_tags", discontinuity_tags)
        if encryption_type is not None:
            pulumi.set(__self__, "encryption_type", encryption_type)
        if hls_cdn_settings is not None:
            pulumi.set(__self__, "hls_cdn_settings", hls_cdn_settings)
        if hls_id3_segment_tagging is not None:
            pulumi.set(__self__, "hls_id3_segment_tagging", hls_id3_segment_tagging)
        if i_frame_only_playlists is not None:
            pulumi.set(__self__, "i_frame_only_playlists", i_frame_only_playlists)
        if incomplete_segment_behavior is not None:
            pulumi.set(__self__, "incomplete_segment_behavior", incomplete_segment_behavior)
        if index_n_segments is not None:
            pulumi.set(__self__, "index_n_segments", index_n_segments)
        if input_loss_action is not None:
            pulumi.set(__self__, "input_loss_action", input_loss_action)
        if iv_in_manifest is not None:
            pulumi.set(__self__, "iv_in_manifest", iv_in_manifest)
        if iv_source is not None:
            pulumi.set(__self__, "iv_source", iv_source)
        if keep_segments is not None:
            pulumi.set(__self__, "keep_segments", keep_segments)
        if key_format is not None:
            pulumi.set(__self__, "key_format", key_format)
        if key_format_versions is not None:
            pulumi.set(__self__, "key_format_versions", key_format_versions)
        if key_provider_settings is not None:
            pulumi.set(__self__, "key_provider_settings", key_provider_settings)
        if manifest_compression is not None:
            pulumi.set(__self__, "manifest_compression", manifest_compression)
        if manifest_duration_format is not None:
            pulumi.set(__self__, "manifest_duration_format", manifest_duration_format)
        if min_segment_length is not None:
            pulumi.set(__self__, "min_segment_length", min_segment_length)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if output_selection is not None:
            pulumi.set(__self__, "output_selection", output_selection)
        if program_date_time is not None:
            pulumi.set(__self__, "program_date_time", program_date_time)
        if program_date_time_period is not None:
            pulumi.set(__self__, "program_date_time_period", program_date_time_period)
        if redundant_manifest is not None:
            pulumi.set(__self__, "redundant_manifest", redundant_manifest)
        if segment_length is not None:
            pulumi.set(__self__, "segment_length", segment_length)
        if segmentation_mode is not None:
            pulumi.set(__self__, "segmentation_mode", segmentation_mode)
        if segments_per_subdirectory is not None:
            pulumi.set(__self__, "segments_per_subdirectory", segments_per_subdirectory)
        if stream_inf_resolution is not None:
            pulumi.set(__self__, "stream_inf_resolution", stream_inf_resolution)
        if timed_metadata_id3_frame is not None:
            pulumi.set(__self__, "timed_metadata_id3_frame", timed_metadata_id3_frame)
        if timed_metadata_id3_period is not None:
            pulumi.set(__self__, "timed_metadata_id3_period", timed_metadata_id3_period)
        if timestamp_delta_milliseconds is not None:
            pulumi.set(__self__, "timestamp_delta_milliseconds", timestamp_delta_milliseconds)
        if ts_file_mode is not None:
            pulumi.set(__self__, "ts_file_mode", ts_file_mode)

    @property
    @pulumi.getter(name="adMarkers")
    def ad_markers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "ad_markers")

    @ad_markers.setter
    def ad_markers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ad_markers", value)

    @property
    @pulumi.getter(name="baseUrlContent")
    def base_url_content(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "base_url_content")

    @base_url_content.setter
    def base_url_content(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "base_url_content", value)

    @property
    @pulumi.getter(name="baseUrlContent1")
    def base_url_content1(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "base_url_content1")

    @base_url_content1.setter
    def base_url_content1(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "base_url_content1", value)

    @property
    @pulumi.getter(name="baseUrlManifest")
    def base_url_manifest(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "base_url_manifest")

    @base_url_manifest.setter
    def base_url_manifest(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "base_url_manifest", value)

    @property
    @pulumi.getter(name="baseUrlManifest1")
    def base_url_manifest1(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "base_url_manifest1")

    @base_url_manifest1.setter
    def base_url_manifest1(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "base_url_manifest1", value)

    @property
    @pulumi.getter(name="captionLanguageMappings")
    def caption_language_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ChannelCaptionLanguageMappingArgs']]]]:
        return pulumi.get(self, "caption_language_mappings")

    @caption_language_mappings.setter
    def caption_language_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelCaptionLanguageMappingArgs']]]]):
        pulumi.set(self, "caption_language_mappings", value)

    @property
    @pulumi.getter(name="captionLanguageSetting")
    def caption_language_setting(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "caption_language_setting")

    @caption_language_setting.setter
    def caption_language_setting(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "caption_language_setting", value)

    @property
    @pulumi.getter(name="clientCache")
    def client_cache(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "client_cache")

    @client_cache.setter
    def client_cache(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "client_cache", value)

    @property
    @pulumi.getter(name="codecSpecification")
    def codec_specification(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "codec_specification")

    @codec_specification.setter
    def codec_specification(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "codec_specification", value)

    @property
    @pulumi.getter(name="constantIv")
    def constant_iv(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "constant_iv")

    @constant_iv.setter
    def constant_iv(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "constant_iv", value)

    @property
    @pulumi.getter
    def destination(self) -> Optional[pulumi.Input['ChannelOutputLocationRefArgs']]:
        return pulumi.get(self, "destination")

    @destination.setter
    def destination(self, value: Optional[pulumi.Input['ChannelOutputLocationRefArgs']]):
        pulumi.set(self, "destination", value)

    @property
    @pulumi.getter(name="directoryStructure")
    def directory_structure(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "directory_structure")

    @directory_structure.setter
    def directory_structure(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "directory_structure", value)

    @property
    @pulumi.getter(name="discontinuityTags")
    def discontinuity_tags(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "discontinuity_tags")

    @discontinuity_tags.setter
    def discontinuity_tags(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "discontinuity_tags", value)

    @property
    @pulumi.getter(name="encryptionType")
    def encryption_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "encryption_type")

    @encryption_type.setter
    def encryption_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "encryption_type", value)

    @property
    @pulumi.getter(name="hlsCdnSettings")
    def hls_cdn_settings(self) -> Optional[pulumi.Input['ChannelHlsCdnSettingsArgs']]:
        return pulumi.get(self, "hls_cdn_settings")

    @hls_cdn_settings.setter
    def hls_cdn_settings(self, value: Optional[pulumi.Input['ChannelHlsCdnSettingsArgs']]):
        pulumi.set(self, "hls_cdn_settings", value)

    @property
    @pulumi.getter(name="hlsId3SegmentTagging")
    def hls_id3_segment_tagging(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "hls_id3_segment_tagging")

    @hls_id3_segment_tagging.setter
    def hls_id3_segment_tagging(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "hls_id3_segment_tagging", value)

    @property
    @pulumi.getter(name="iFrameOnlyPlaylists")
    def i_frame_only_playlists(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "i_frame_only_playlists")

    @i_frame_only_playlists.setter
    def i_frame_only_playlists(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "i_frame_only_playlists", value)

    @property
    @pulumi.getter(name="incompleteSegmentBehavior")
    def incomplete_segment_behavior(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "incomplete_segment_behavior")

    @incomplete_segment_behavior.setter
    def incomplete_segment_behavior(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "incomplete_segment_behavior", value)

    @property
    @pulumi.getter(name="indexNSegments")
    def index_n_segments(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "index_n_segments")

    @index_n_segments.setter
    def index_n_segments(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "index_n_segments", value)

    @property
    @pulumi.getter(name="inputLossAction")
    def input_loss_action(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "input_loss_action")

    @input_loss_action.setter
    def input_loss_action(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "input_loss_action", value)

    @property
    @pulumi.getter(name="ivInManifest")
    def iv_in_manifest(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "iv_in_manifest")

    @iv_in_manifest.setter
    def iv_in_manifest(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "iv_in_manifest", value)

    @property
    @pulumi.getter(name="ivSource")
    def iv_source(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "iv_source")

    @iv_source.setter
    def iv_source(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "iv_source", value)

    @property
    @pulumi.getter(name="keepSegments")
    def keep_segments(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "keep_segments")

    @keep_segments.setter
    def keep_segments(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "keep_segments", value)

    @property
    @pulumi.getter(name="keyFormat")
    def key_format(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key_format")

    @key_format.setter
    def key_format(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key_format", value)

    @property
    @pulumi.getter(name="keyFormatVersions")
    def key_format_versions(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key_format_versions")

    @key_format_versions.setter
    def key_format_versions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key_format_versions", value)

    @property
    @pulumi.getter(name="keyProviderSettings")
    def key_provider_settings(self) -> Optional[pulumi.Input['ChannelKeyProviderSettingsArgs']]:
        return pulumi.get(self, "key_provider_settings")

    @key_provider_settings.setter
    def key_provider_settings(self, value: Optional[pulumi.Input['ChannelKeyProviderSettingsArgs']]):
        pulumi.set(self, "key_provider_settings", value)

    @property
    @pulumi.getter(name="manifestCompression")
    def manifest_compression(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "manifest_compression")

    @manifest_compression.setter
    def manifest_compression(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "manifest_compression", value)

    @property
    @pulumi.getter(name="manifestDurationFormat")
    def manifest_duration_format(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "manifest_duration_format")

    @manifest_duration_format.setter
    def manifest_duration_format(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "manifest_duration_format", value)

    @property
    @pulumi.getter(name="minSegmentLength")
    def min_segment_length(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "min_segment_length")

    @min_segment_length.setter
    def min_segment_length(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_segment_length", value)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mode", value)

    @property
    @pulumi.getter(name="outputSelection")
    def output_selection(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "output_selection")

    @output_selection.setter
    def output_selection(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "output_selection", value)

    @property
    @pulumi.getter(name="programDateTime")
    def program_date_time(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "program_date_time")

    @program_date_time.setter
    def program_date_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "program_date_time", value)

    @property
    @pulumi.getter(name="programDateTimePeriod")
    def program_date_time_period(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "program_date_time_period")

    @program_date_time_period.setter
    def program_date_time_period(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "program_date_time_period", value)

    @property
    @pulumi.getter(name="redundantManifest")
    def redundant_manifest(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "redundant_manifest")

    @redundant_manifest.setter
    def redundant_manifest(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "redundant_manifest", value)

    @property
    @pulumi.getter(name="segmentLength")
    def segment_length(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "segment_length")

    @segment_length.setter
    def segment_length(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "segment_length", value)

    @property
    @pulumi.getter(name="segmentationMode")
    def segmentation_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "segmentation_mode")

    @segmentation_mode.setter
    def segmentation_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "segmentation_mode", value)

    @property
    @pulumi.getter(name="segmentsPerSubdirectory")
    def segments_per_subdirectory(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "segments_per_subdirectory")

    @segments_per_subdirectory.setter
    def segments_per_subdirectory(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "segments_per_subdirectory", value)

    @property
    @pulumi.getter(name="streamInfResolution")
    def stream_inf_resolution(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "stream_inf_resolution")

    @stream_inf_resolution.setter
    def stream_inf_resolution(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "stream_inf_resolution", value)

    @property
    @pulumi.getter(name="timedMetadataId3Frame")
    def timed_metadata_id3_frame(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "timed_metadata_id3_frame")

    @timed_metadata_id3_frame.setter
    def timed_metadata_id3_frame(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "timed_metadata_id3_frame", value)

    @property
    @pulumi.getter(name="timedMetadataId3Period")
    def timed_metadata_id3_period(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "timed_metadata_id3_period")

    @timed_metadata_id3_period.setter
    def timed_metadata_id3_period(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "timed_metadata_id3_period", value)

    @property
    @pulumi.getter(name="timestampDeltaMilliseconds")
    def timestamp_delta_milliseconds(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "timestamp_delta_milliseconds")

    @timestamp_delta_milliseconds.setter
    def timestamp_delta_milliseconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "timestamp_delta_milliseconds", value)

    @property
    @pulumi.getter(name="tsFileMode")
    def ts_file_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ts_file_mode")

    @ts_file_mode.setter
    def ts_file_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ts_file_mode", value)


@pulumi.input_type
class ChannelHlsInputSettingsArgs:
    def __init__(__self__, *,
                 bandwidth: Optional[pulumi.Input[int]] = None,
                 buffer_segments: Optional[pulumi.Input[int]] = None,
                 retries: Optional[pulumi.Input[int]] = None,
                 retry_interval: Optional[pulumi.Input[int]] = None):
        if bandwidth is not None:
            pulumi.set(__self__, "bandwidth", bandwidth)
        if buffer_segments is not None:
            pulumi.set(__self__, "buffer_segments", buffer_segments)
        if retries is not None:
            pulumi.set(__self__, "retries", retries)
        if retry_interval is not None:
            pulumi.set(__self__, "retry_interval", retry_interval)

    @property
    @pulumi.getter
    def bandwidth(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "bandwidth")

    @bandwidth.setter
    def bandwidth(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "bandwidth", value)

    @property
    @pulumi.getter(name="bufferSegments")
    def buffer_segments(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "buffer_segments")

    @buffer_segments.setter
    def buffer_segments(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "buffer_segments", value)

    @property
    @pulumi.getter
    def retries(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "retries")

    @retries.setter
    def retries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "retries", value)

    @property
    @pulumi.getter(name="retryInterval")
    def retry_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "retry_interval")

    @retry_interval.setter
    def retry_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "retry_interval", value)


@pulumi.input_type
class ChannelHlsMediaStoreSettingsArgs:
    def __init__(__self__, *,
                 connection_retry_interval: Optional[pulumi.Input[int]] = None,
                 filecache_duration: Optional[pulumi.Input[int]] = None,
                 media_store_storage_class: Optional[pulumi.Input[str]] = None,
                 num_retries: Optional[pulumi.Input[int]] = None,
                 restart_delay: Optional[pulumi.Input[int]] = None):
        if connection_retry_interval is not None:
            pulumi.set(__self__, "connection_retry_interval", connection_retry_interval)
        if filecache_duration is not None:
            pulumi.set(__self__, "filecache_duration", filecache_duration)
        if media_store_storage_class is not None:
            pulumi.set(__self__, "media_store_storage_class", media_store_storage_class)
        if num_retries is not None:
            pulumi.set(__self__, "num_retries", num_retries)
        if restart_delay is not None:
            pulumi.set(__self__, "restart_delay", restart_delay)

    @property
    @pulumi.getter(name="connectionRetryInterval")
    def connection_retry_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "connection_retry_interval")

    @connection_retry_interval.setter
    def connection_retry_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "connection_retry_interval", value)

    @property
    @pulumi.getter(name="filecacheDuration")
    def filecache_duration(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "filecache_duration")

    @filecache_duration.setter
    def filecache_duration(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "filecache_duration", value)

    @property
    @pulumi.getter(name="mediaStoreStorageClass")
    def media_store_storage_class(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "media_store_storage_class")

    @media_store_storage_class.setter
    def media_store_storage_class(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "media_store_storage_class", value)

    @property
    @pulumi.getter(name="numRetries")
    def num_retries(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "num_retries")

    @num_retries.setter
    def num_retries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "num_retries", value)

    @property
    @pulumi.getter(name="restartDelay")
    def restart_delay(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "restart_delay")

    @restart_delay.setter
    def restart_delay(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "restart_delay", value)


@pulumi.input_type
class ChannelHlsOutputSettingsArgs:
    def __init__(__self__, *,
                 h265_packaging_type: Optional[pulumi.Input[str]] = None,
                 hls_settings: Optional[pulumi.Input['ChannelHlsSettingsArgs']] = None,
                 name_modifier: Optional[pulumi.Input[str]] = None,
                 segment_modifier: Optional[pulumi.Input[str]] = None):
        if h265_packaging_type is not None:
            pulumi.set(__self__, "h265_packaging_type", h265_packaging_type)
        if hls_settings is not None:
            pulumi.set(__self__, "hls_settings", hls_settings)
        if name_modifier is not None:
            pulumi.set(__self__, "name_modifier", name_modifier)
        if segment_modifier is not None:
            pulumi.set(__self__, "segment_modifier", segment_modifier)

    @property
    @pulumi.getter(name="h265PackagingType")
    def h265_packaging_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "h265_packaging_type")

    @h265_packaging_type.setter
    def h265_packaging_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "h265_packaging_type", value)

    @property
    @pulumi.getter(name="hlsSettings")
    def hls_settings(self) -> Optional[pulumi.Input['ChannelHlsSettingsArgs']]:
        return pulumi.get(self, "hls_settings")

    @hls_settings.setter
    def hls_settings(self, value: Optional[pulumi.Input['ChannelHlsSettingsArgs']]):
        pulumi.set(self, "hls_settings", value)

    @property
    @pulumi.getter(name="nameModifier")
    def name_modifier(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "name_modifier")

    @name_modifier.setter
    def name_modifier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name_modifier", value)

    @property
    @pulumi.getter(name="segmentModifier")
    def segment_modifier(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "segment_modifier")

    @segment_modifier.setter
    def segment_modifier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "segment_modifier", value)


@pulumi.input_type
class ChannelHlsS3SettingsArgs:
    def __init__(__self__, *,
                 canned_acl: Optional[pulumi.Input[str]] = None):
        if canned_acl is not None:
            pulumi.set(__self__, "canned_acl", canned_acl)

    @property
    @pulumi.getter(name="cannedAcl")
    def canned_acl(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "canned_acl")

    @canned_acl.setter
    def canned_acl(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "canned_acl", value)


@pulumi.input_type
class ChannelHlsSettingsArgs:
    def __init__(__self__, *,
                 audio_only_hls_settings: Optional[pulumi.Input['ChannelAudioOnlyHlsSettingsArgs']] = None,
                 fmp4_hls_settings: Optional[pulumi.Input['ChannelFmp4HlsSettingsArgs']] = None,
                 frame_capture_hls_settings: Optional[pulumi.Input['ChannelFrameCaptureHlsSettingsArgs']] = None,
                 standard_hls_settings: Optional[pulumi.Input['ChannelStandardHlsSettingsArgs']] = None):
        if audio_only_hls_settings is not None:
            pulumi.set(__self__, "audio_only_hls_settings", audio_only_hls_settings)
        if fmp4_hls_settings is not None:
            pulumi.set(__self__, "fmp4_hls_settings", fmp4_hls_settings)
        if frame_capture_hls_settings is not None:
            pulumi.set(__self__, "frame_capture_hls_settings", frame_capture_hls_settings)
        if standard_hls_settings is not None:
            pulumi.set(__self__, "standard_hls_settings", standard_hls_settings)

    @property
    @pulumi.getter(name="audioOnlyHlsSettings")
    def audio_only_hls_settings(self) -> Optional[pulumi.Input['ChannelAudioOnlyHlsSettingsArgs']]:
        return pulumi.get(self, "audio_only_hls_settings")

    @audio_only_hls_settings.setter
    def audio_only_hls_settings(self, value: Optional[pulumi.Input['ChannelAudioOnlyHlsSettingsArgs']]):
        pulumi.set(self, "audio_only_hls_settings", value)

    @property
    @pulumi.getter(name="fmp4HlsSettings")
    def fmp4_hls_settings(self) -> Optional[pulumi.Input['ChannelFmp4HlsSettingsArgs']]:
        return pulumi.get(self, "fmp4_hls_settings")

    @fmp4_hls_settings.setter
    def fmp4_hls_settings(self, value: Optional[pulumi.Input['ChannelFmp4HlsSettingsArgs']]):
        pulumi.set(self, "fmp4_hls_settings", value)

    @property
    @pulumi.getter(name="frameCaptureHlsSettings")
    def frame_capture_hls_settings(self) -> Optional[pulumi.Input['ChannelFrameCaptureHlsSettingsArgs']]:
        return pulumi.get(self, "frame_capture_hls_settings")

    @frame_capture_hls_settings.setter
    def frame_capture_hls_settings(self, value: Optional[pulumi.Input['ChannelFrameCaptureHlsSettingsArgs']]):
        pulumi.set(self, "frame_capture_hls_settings", value)

    @property
    @pulumi.getter(name="standardHlsSettings")
    def standard_hls_settings(self) -> Optional[pulumi.Input['ChannelStandardHlsSettingsArgs']]:
        return pulumi.get(self, "standard_hls_settings")

    @standard_hls_settings.setter
    def standard_hls_settings(self, value: Optional[pulumi.Input['ChannelStandardHlsSettingsArgs']]):
        pulumi.set(self, "standard_hls_settings", value)


@pulumi.input_type
class ChannelHlsWebdavSettingsArgs:
    def __init__(__self__, *,
                 connection_retry_interval: Optional[pulumi.Input[int]] = None,
                 filecache_duration: Optional[pulumi.Input[int]] = None,
                 http_transfer_mode: Optional[pulumi.Input[str]] = None,
                 num_retries: Optional[pulumi.Input[int]] = None,
                 restart_delay: Optional[pulumi.Input[int]] = None):
        if connection_retry_interval is not None:
            pulumi.set(__self__, "connection_retry_interval", connection_retry_interval)
        if filecache_duration is not None:
            pulumi.set(__self__, "filecache_duration", filecache_duration)
        if http_transfer_mode is not None:
            pulumi.set(__self__, "http_transfer_mode", http_transfer_mode)
        if num_retries is not None:
            pulumi.set(__self__, "num_retries", num_retries)
        if restart_delay is not None:
            pulumi.set(__self__, "restart_delay", restart_delay)

    @property
    @pulumi.getter(name="connectionRetryInterval")
    def connection_retry_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "connection_retry_interval")

    @connection_retry_interval.setter
    def connection_retry_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "connection_retry_interval", value)

    @property
    @pulumi.getter(name="filecacheDuration")
    def filecache_duration(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "filecache_duration")

    @filecache_duration.setter
    def filecache_duration(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "filecache_duration", value)

    @property
    @pulumi.getter(name="httpTransferMode")
    def http_transfer_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "http_transfer_mode")

    @http_transfer_mode.setter
    def http_transfer_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "http_transfer_mode", value)

    @property
    @pulumi.getter(name="numRetries")
    def num_retries(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "num_retries")

    @num_retries.setter
    def num_retries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "num_retries", value)

    @property
    @pulumi.getter(name="restartDelay")
    def restart_delay(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "restart_delay")

    @restart_delay.setter
    def restart_delay(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "restart_delay", value)


@pulumi.input_type
class ChannelHtmlMotionGraphicsSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelInputAttachmentArgs:
    def __init__(__self__, *,
                 automatic_input_failover_settings: Optional[pulumi.Input['ChannelAutomaticInputFailoverSettingsArgs']] = None,
                 input_attachment_name: Optional[pulumi.Input[str]] = None,
                 input_id: Optional[pulumi.Input[str]] = None,
                 input_settings: Optional[pulumi.Input['ChannelInputSettingsArgs']] = None):
        if automatic_input_failover_settings is not None:
            pulumi.set(__self__, "automatic_input_failover_settings", automatic_input_failover_settings)
        if input_attachment_name is not None:
            pulumi.set(__self__, "input_attachment_name", input_attachment_name)
        if input_id is not None:
            pulumi.set(__self__, "input_id", input_id)
        if input_settings is not None:
            pulumi.set(__self__, "input_settings", input_settings)

    @property
    @pulumi.getter(name="automaticInputFailoverSettings")
    def automatic_input_failover_settings(self) -> Optional[pulumi.Input['ChannelAutomaticInputFailoverSettingsArgs']]:
        return pulumi.get(self, "automatic_input_failover_settings")

    @automatic_input_failover_settings.setter
    def automatic_input_failover_settings(self, value: Optional[pulumi.Input['ChannelAutomaticInputFailoverSettingsArgs']]):
        pulumi.set(self, "automatic_input_failover_settings", value)

    @property
    @pulumi.getter(name="inputAttachmentName")
    def input_attachment_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "input_attachment_name")

    @input_attachment_name.setter
    def input_attachment_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "input_attachment_name", value)

    @property
    @pulumi.getter(name="inputId")
    def input_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "input_id")

    @input_id.setter
    def input_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "input_id", value)

    @property
    @pulumi.getter(name="inputSettings")
    def input_settings(self) -> Optional[pulumi.Input['ChannelInputSettingsArgs']]:
        return pulumi.get(self, "input_settings")

    @input_settings.setter
    def input_settings(self, value: Optional[pulumi.Input['ChannelInputSettingsArgs']]):
        pulumi.set(self, "input_settings", value)


@pulumi.input_type
class ChannelInputChannelLevelArgs:
    def __init__(__self__, *,
                 gain: Optional[pulumi.Input[int]] = None,
                 input_channel: Optional[pulumi.Input[int]] = None):
        if gain is not None:
            pulumi.set(__self__, "gain", gain)
        if input_channel is not None:
            pulumi.set(__self__, "input_channel", input_channel)

    @property
    @pulumi.getter
    def gain(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "gain")

    @gain.setter
    def gain(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "gain", value)

    @property
    @pulumi.getter(name="inputChannel")
    def input_channel(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "input_channel")

    @input_channel.setter
    def input_channel(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "input_channel", value)


@pulumi.input_type
class ChannelInputLocationArgs:
    def __init__(__self__, *,
                 password_param: Optional[pulumi.Input[str]] = None,
                 uri: Optional[pulumi.Input[str]] = None,
                 username: Optional[pulumi.Input[str]] = None):
        if password_param is not None:
            pulumi.set(__self__, "password_param", password_param)
        if uri is not None:
            pulumi.set(__self__, "uri", uri)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="passwordParam")
    def password_param(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "password_param")

    @password_param.setter
    def password_param(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password_param", value)

    @property
    @pulumi.getter
    def uri(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "uri")

    @uri.setter
    def uri(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "uri", value)

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)


@pulumi.input_type
class ChannelInputLossBehaviorArgs:
    def __init__(__self__, *,
                 black_frame_msec: Optional[pulumi.Input[int]] = None,
                 input_loss_image_color: Optional[pulumi.Input[str]] = None,
                 input_loss_image_slate: Optional[pulumi.Input['ChannelInputLocationArgs']] = None,
                 input_loss_image_type: Optional[pulumi.Input[str]] = None,
                 repeat_frame_msec: Optional[pulumi.Input[int]] = None):
        if black_frame_msec is not None:
            pulumi.set(__self__, "black_frame_msec", black_frame_msec)
        if input_loss_image_color is not None:
            pulumi.set(__self__, "input_loss_image_color", input_loss_image_color)
        if input_loss_image_slate is not None:
            pulumi.set(__self__, "input_loss_image_slate", input_loss_image_slate)
        if input_loss_image_type is not None:
            pulumi.set(__self__, "input_loss_image_type", input_loss_image_type)
        if repeat_frame_msec is not None:
            pulumi.set(__self__, "repeat_frame_msec", repeat_frame_msec)

    @property
    @pulumi.getter(name="blackFrameMsec")
    def black_frame_msec(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "black_frame_msec")

    @black_frame_msec.setter
    def black_frame_msec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "black_frame_msec", value)

    @property
    @pulumi.getter(name="inputLossImageColor")
    def input_loss_image_color(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "input_loss_image_color")

    @input_loss_image_color.setter
    def input_loss_image_color(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "input_loss_image_color", value)

    @property
    @pulumi.getter(name="inputLossImageSlate")
    def input_loss_image_slate(self) -> Optional[pulumi.Input['ChannelInputLocationArgs']]:
        return pulumi.get(self, "input_loss_image_slate")

    @input_loss_image_slate.setter
    def input_loss_image_slate(self, value: Optional[pulumi.Input['ChannelInputLocationArgs']]):
        pulumi.set(self, "input_loss_image_slate", value)

    @property
    @pulumi.getter(name="inputLossImageType")
    def input_loss_image_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "input_loss_image_type")

    @input_loss_image_type.setter
    def input_loss_image_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "input_loss_image_type", value)

    @property
    @pulumi.getter(name="repeatFrameMsec")
    def repeat_frame_msec(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "repeat_frame_msec")

    @repeat_frame_msec.setter
    def repeat_frame_msec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "repeat_frame_msec", value)


@pulumi.input_type
class ChannelInputLossFailoverSettingsArgs:
    def __init__(__self__, *,
                 input_loss_threshold_msec: Optional[pulumi.Input[int]] = None):
        if input_loss_threshold_msec is not None:
            pulumi.set(__self__, "input_loss_threshold_msec", input_loss_threshold_msec)

    @property
    @pulumi.getter(name="inputLossThresholdMsec")
    def input_loss_threshold_msec(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "input_loss_threshold_msec")

    @input_loss_threshold_msec.setter
    def input_loss_threshold_msec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "input_loss_threshold_msec", value)


@pulumi.input_type
class ChannelInputSettingsArgs:
    def __init__(__self__, *,
                 audio_selectors: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelAudioSelectorArgs']]]] = None,
                 caption_selectors: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelCaptionSelectorArgs']]]] = None,
                 deblock_filter: Optional[pulumi.Input[str]] = None,
                 denoise_filter: Optional[pulumi.Input[str]] = None,
                 filter_strength: Optional[pulumi.Input[int]] = None,
                 input_filter: Optional[pulumi.Input[str]] = None,
                 network_input_settings: Optional[pulumi.Input['ChannelNetworkInputSettingsArgs']] = None,
                 smpte2038_data_preference: Optional[pulumi.Input[str]] = None,
                 source_end_behavior: Optional[pulumi.Input[str]] = None,
                 video_selector: Optional[pulumi.Input['ChannelVideoSelectorArgs']] = None):
        if audio_selectors is not None:
            pulumi.set(__self__, "audio_selectors", audio_selectors)
        if caption_selectors is not None:
            pulumi.set(__self__, "caption_selectors", caption_selectors)
        if deblock_filter is not None:
            pulumi.set(__self__, "deblock_filter", deblock_filter)
        if denoise_filter is not None:
            pulumi.set(__self__, "denoise_filter", denoise_filter)
        if filter_strength is not None:
            pulumi.set(__self__, "filter_strength", filter_strength)
        if input_filter is not None:
            pulumi.set(__self__, "input_filter", input_filter)
        if network_input_settings is not None:
            pulumi.set(__self__, "network_input_settings", network_input_settings)
        if smpte2038_data_preference is not None:
            pulumi.set(__self__, "smpte2038_data_preference", smpte2038_data_preference)
        if source_end_behavior is not None:
            pulumi.set(__self__, "source_end_behavior", source_end_behavior)
        if video_selector is not None:
            pulumi.set(__self__, "video_selector", video_selector)

    @property
    @pulumi.getter(name="audioSelectors")
    def audio_selectors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ChannelAudioSelectorArgs']]]]:
        return pulumi.get(self, "audio_selectors")

    @audio_selectors.setter
    def audio_selectors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelAudioSelectorArgs']]]]):
        pulumi.set(self, "audio_selectors", value)

    @property
    @pulumi.getter(name="captionSelectors")
    def caption_selectors(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ChannelCaptionSelectorArgs']]]]:
        return pulumi.get(self, "caption_selectors")

    @caption_selectors.setter
    def caption_selectors(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelCaptionSelectorArgs']]]]):
        pulumi.set(self, "caption_selectors", value)

    @property
    @pulumi.getter(name="deblockFilter")
    def deblock_filter(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "deblock_filter")

    @deblock_filter.setter
    def deblock_filter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "deblock_filter", value)

    @property
    @pulumi.getter(name="denoiseFilter")
    def denoise_filter(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "denoise_filter")

    @denoise_filter.setter
    def denoise_filter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "denoise_filter", value)

    @property
    @pulumi.getter(name="filterStrength")
    def filter_strength(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "filter_strength")

    @filter_strength.setter
    def filter_strength(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "filter_strength", value)

    @property
    @pulumi.getter(name="inputFilter")
    def input_filter(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "input_filter")

    @input_filter.setter
    def input_filter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "input_filter", value)

    @property
    @pulumi.getter(name="networkInputSettings")
    def network_input_settings(self) -> Optional[pulumi.Input['ChannelNetworkInputSettingsArgs']]:
        return pulumi.get(self, "network_input_settings")

    @network_input_settings.setter
    def network_input_settings(self, value: Optional[pulumi.Input['ChannelNetworkInputSettingsArgs']]):
        pulumi.set(self, "network_input_settings", value)

    @property
    @pulumi.getter(name="smpte2038DataPreference")
    def smpte2038_data_preference(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "smpte2038_data_preference")

    @smpte2038_data_preference.setter
    def smpte2038_data_preference(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "smpte2038_data_preference", value)

    @property
    @pulumi.getter(name="sourceEndBehavior")
    def source_end_behavior(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "source_end_behavior")

    @source_end_behavior.setter
    def source_end_behavior(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "source_end_behavior", value)

    @property
    @pulumi.getter(name="videoSelector")
    def video_selector(self) -> Optional[pulumi.Input['ChannelVideoSelectorArgs']]:
        return pulumi.get(self, "video_selector")

    @video_selector.setter
    def video_selector(self, value: Optional[pulumi.Input['ChannelVideoSelectorArgs']]):
        pulumi.set(self, "video_selector", value)


@pulumi.input_type
class ChannelInputSpecificationArgs:
    def __init__(__self__, *,
                 codec: Optional[pulumi.Input[str]] = None,
                 maximum_bitrate: Optional[pulumi.Input[str]] = None,
                 resolution: Optional[pulumi.Input[str]] = None):
        if codec is not None:
            pulumi.set(__self__, "codec", codec)
        if maximum_bitrate is not None:
            pulumi.set(__self__, "maximum_bitrate", maximum_bitrate)
        if resolution is not None:
            pulumi.set(__self__, "resolution", resolution)

    @property
    @pulumi.getter
    def codec(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "codec")

    @codec.setter
    def codec(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "codec", value)

    @property
    @pulumi.getter(name="maximumBitrate")
    def maximum_bitrate(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "maximum_bitrate")

    @maximum_bitrate.setter
    def maximum_bitrate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "maximum_bitrate", value)

    @property
    @pulumi.getter
    def resolution(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "resolution")

    @resolution.setter
    def resolution(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resolution", value)


@pulumi.input_type
class ChannelKeyProviderSettingsArgs:
    def __init__(__self__, *,
                 static_key_settings: Optional[pulumi.Input['ChannelStaticKeySettingsArgs']] = None):
        if static_key_settings is not None:
            pulumi.set(__self__, "static_key_settings", static_key_settings)

    @property
    @pulumi.getter(name="staticKeySettings")
    def static_key_settings(self) -> Optional[pulumi.Input['ChannelStaticKeySettingsArgs']]:
        return pulumi.get(self, "static_key_settings")

    @static_key_settings.setter
    def static_key_settings(self, value: Optional[pulumi.Input['ChannelStaticKeySettingsArgs']]):
        pulumi.set(self, "static_key_settings", value)


@pulumi.input_type
class ChannelM2tsSettingsArgs:
    def __init__(__self__, *,
                 absent_input_audio_behavior: Optional[pulumi.Input[str]] = None,
                 arib: Optional[pulumi.Input[str]] = None,
                 arib_captions_pid: Optional[pulumi.Input[str]] = None,
                 arib_captions_pid_control: Optional[pulumi.Input[str]] = None,
                 audio_buffer_model: Optional[pulumi.Input[str]] = None,
                 audio_frames_per_pes: Optional[pulumi.Input[int]] = None,
                 audio_pids: Optional[pulumi.Input[str]] = None,
                 audio_stream_type: Optional[pulumi.Input[str]] = None,
                 bitrate: Optional[pulumi.Input[int]] = None,
                 buffer_model: Optional[pulumi.Input[str]] = None,
                 cc_descriptor: Optional[pulumi.Input[str]] = None,
                 dvb_nit_settings: Optional[pulumi.Input['ChannelDvbNitSettingsArgs']] = None,
                 dvb_sdt_settings: Optional[pulumi.Input['ChannelDvbSdtSettingsArgs']] = None,
                 dvb_sub_pids: Optional[pulumi.Input[str]] = None,
                 dvb_tdt_settings: Optional[pulumi.Input['ChannelDvbTdtSettingsArgs']] = None,
                 dvb_teletext_pid: Optional[pulumi.Input[str]] = None,
                 ebif: Optional[pulumi.Input[str]] = None,
                 ebp_audio_interval: Optional[pulumi.Input[str]] = None,
                 ebp_lookahead_ms: Optional[pulumi.Input[int]] = None,
                 ebp_placement: Optional[pulumi.Input[str]] = None,
                 ecm_pid: Optional[pulumi.Input[str]] = None,
                 es_rate_in_pes: Optional[pulumi.Input[str]] = None,
                 etv_platform_pid: Optional[pulumi.Input[str]] = None,
                 etv_signal_pid: Optional[pulumi.Input[str]] = None,
                 fragment_time: Optional[pulumi.Input[float]] = None,
                 klv: Optional[pulumi.Input[str]] = None,
                 klv_data_pids: Optional[pulumi.Input[str]] = None,
                 nielsen_id3_behavior: Optional[pulumi.Input[str]] = None,
                 null_packet_bitrate: Optional[pulumi.Input[float]] = None,
                 pat_interval: Optional[pulumi.Input[int]] = None,
                 pcr_control: Optional[pulumi.Input[str]] = None,
                 pcr_period: Optional[pulumi.Input[int]] = None,
                 pcr_pid: Optional[pulumi.Input[str]] = None,
                 pmt_interval: Optional[pulumi.Input[int]] = None,
                 pmt_pid: Optional[pulumi.Input[str]] = None,
                 program_num: Optional[pulumi.Input[int]] = None,
                 rate_mode: Optional[pulumi.Input[str]] = None,
                 scte27_pids: Optional[pulumi.Input[str]] = None,
                 scte35_control: Optional[pulumi.Input[str]] = None,
                 scte35_pid: Optional[pulumi.Input[str]] = None,
                 segmentation_markers: Optional[pulumi.Input[str]] = None,
                 segmentation_style: Optional[pulumi.Input[str]] = None,
                 segmentation_time: Optional[pulumi.Input[float]] = None,
                 timed_metadata_behavior: Optional[pulumi.Input[str]] = None,
                 timed_metadata_pid: Optional[pulumi.Input[str]] = None,
                 transport_stream_id: Optional[pulumi.Input[int]] = None,
                 video_pid: Optional[pulumi.Input[str]] = None):
        if absent_input_audio_behavior is not None:
            pulumi.set(__self__, "absent_input_audio_behavior", absent_input_audio_behavior)
        if arib is not None:
            pulumi.set(__self__, "arib", arib)
        if arib_captions_pid is not None:
            pulumi.set(__self__, "arib_captions_pid", arib_captions_pid)
        if arib_captions_pid_control is not None:
            pulumi.set(__self__, "arib_captions_pid_control", arib_captions_pid_control)
        if audio_buffer_model is not None:
            pulumi.set(__self__, "audio_buffer_model", audio_buffer_model)
        if audio_frames_per_pes is not None:
            pulumi.set(__self__, "audio_frames_per_pes", audio_frames_per_pes)
        if audio_pids is not None:
            pulumi.set(__self__, "audio_pids", audio_pids)
        if audio_stream_type is not None:
            pulumi.set(__self__, "audio_stream_type", audio_stream_type)
        if bitrate is not None:
            pulumi.set(__self__, "bitrate", bitrate)
        if buffer_model is not None:
            pulumi.set(__self__, "buffer_model", buffer_model)
        if cc_descriptor is not None:
            pulumi.set(__self__, "cc_descriptor", cc_descriptor)
        if dvb_nit_settings is not None:
            pulumi.set(__self__, "dvb_nit_settings", dvb_nit_settings)
        if dvb_sdt_settings is not None:
            pulumi.set(__self__, "dvb_sdt_settings", dvb_sdt_settings)
        if dvb_sub_pids is not None:
            pulumi.set(__self__, "dvb_sub_pids", dvb_sub_pids)
        if dvb_tdt_settings is not None:
            pulumi.set(__self__, "dvb_tdt_settings", dvb_tdt_settings)
        if dvb_teletext_pid is not None:
            pulumi.set(__self__, "dvb_teletext_pid", dvb_teletext_pid)
        if ebif is not None:
            pulumi.set(__self__, "ebif", ebif)
        if ebp_audio_interval is not None:
            pulumi.set(__self__, "ebp_audio_interval", ebp_audio_interval)
        if ebp_lookahead_ms is not None:
            pulumi.set(__self__, "ebp_lookahead_ms", ebp_lookahead_ms)
        if ebp_placement is not None:
            pulumi.set(__self__, "ebp_placement", ebp_placement)
        if ecm_pid is not None:
            pulumi.set(__self__, "ecm_pid", ecm_pid)
        if es_rate_in_pes is not None:
            pulumi.set(__self__, "es_rate_in_pes", es_rate_in_pes)
        if etv_platform_pid is not None:
            pulumi.set(__self__, "etv_platform_pid", etv_platform_pid)
        if etv_signal_pid is not None:
            pulumi.set(__self__, "etv_signal_pid", etv_signal_pid)
        if fragment_time is not None:
            pulumi.set(__self__, "fragment_time", fragment_time)
        if klv is not None:
            pulumi.set(__self__, "klv", klv)
        if klv_data_pids is not None:
            pulumi.set(__self__, "klv_data_pids", klv_data_pids)
        if nielsen_id3_behavior is not None:
            pulumi.set(__self__, "nielsen_id3_behavior", nielsen_id3_behavior)
        if null_packet_bitrate is not None:
            pulumi.set(__self__, "null_packet_bitrate", null_packet_bitrate)
        if pat_interval is not None:
            pulumi.set(__self__, "pat_interval", pat_interval)
        if pcr_control is not None:
            pulumi.set(__self__, "pcr_control", pcr_control)
        if pcr_period is not None:
            pulumi.set(__self__, "pcr_period", pcr_period)
        if pcr_pid is not None:
            pulumi.set(__self__, "pcr_pid", pcr_pid)
        if pmt_interval is not None:
            pulumi.set(__self__, "pmt_interval", pmt_interval)
        if pmt_pid is not None:
            pulumi.set(__self__, "pmt_pid", pmt_pid)
        if program_num is not None:
            pulumi.set(__self__, "program_num", program_num)
        if rate_mode is not None:
            pulumi.set(__self__, "rate_mode", rate_mode)
        if scte27_pids is not None:
            pulumi.set(__self__, "scte27_pids", scte27_pids)
        if scte35_control is not None:
            pulumi.set(__self__, "scte35_control", scte35_control)
        if scte35_pid is not None:
            pulumi.set(__self__, "scte35_pid", scte35_pid)
        if segmentation_markers is not None:
            pulumi.set(__self__, "segmentation_markers", segmentation_markers)
        if segmentation_style is not None:
            pulumi.set(__self__, "segmentation_style", segmentation_style)
        if segmentation_time is not None:
            pulumi.set(__self__, "segmentation_time", segmentation_time)
        if timed_metadata_behavior is not None:
            pulumi.set(__self__, "timed_metadata_behavior", timed_metadata_behavior)
        if timed_metadata_pid is not None:
            pulumi.set(__self__, "timed_metadata_pid", timed_metadata_pid)
        if transport_stream_id is not None:
            pulumi.set(__self__, "transport_stream_id", transport_stream_id)
        if video_pid is not None:
            pulumi.set(__self__, "video_pid", video_pid)

    @property
    @pulumi.getter(name="absentInputAudioBehavior")
    def absent_input_audio_behavior(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "absent_input_audio_behavior")

    @absent_input_audio_behavior.setter
    def absent_input_audio_behavior(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "absent_input_audio_behavior", value)

    @property
    @pulumi.getter
    def arib(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "arib")

    @arib.setter
    def arib(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "arib", value)

    @property
    @pulumi.getter(name="aribCaptionsPid")
    def arib_captions_pid(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "arib_captions_pid")

    @arib_captions_pid.setter
    def arib_captions_pid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "arib_captions_pid", value)

    @property
    @pulumi.getter(name="aribCaptionsPidControl")
    def arib_captions_pid_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "arib_captions_pid_control")

    @arib_captions_pid_control.setter
    def arib_captions_pid_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "arib_captions_pid_control", value)

    @property
    @pulumi.getter(name="audioBufferModel")
    def audio_buffer_model(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "audio_buffer_model")

    @audio_buffer_model.setter
    def audio_buffer_model(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "audio_buffer_model", value)

    @property
    @pulumi.getter(name="audioFramesPerPes")
    def audio_frames_per_pes(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "audio_frames_per_pes")

    @audio_frames_per_pes.setter
    def audio_frames_per_pes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "audio_frames_per_pes", value)

    @property
    @pulumi.getter(name="audioPids")
    def audio_pids(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "audio_pids")

    @audio_pids.setter
    def audio_pids(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "audio_pids", value)

    @property
    @pulumi.getter(name="audioStreamType")
    def audio_stream_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "audio_stream_type")

    @audio_stream_type.setter
    def audio_stream_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "audio_stream_type", value)

    @property
    @pulumi.getter
    def bitrate(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "bitrate")

    @bitrate.setter
    def bitrate(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "bitrate", value)

    @property
    @pulumi.getter(name="bufferModel")
    def buffer_model(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "buffer_model")

    @buffer_model.setter
    def buffer_model(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "buffer_model", value)

    @property
    @pulumi.getter(name="ccDescriptor")
    def cc_descriptor(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cc_descriptor")

    @cc_descriptor.setter
    def cc_descriptor(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cc_descriptor", value)

    @property
    @pulumi.getter(name="dvbNitSettings")
    def dvb_nit_settings(self) -> Optional[pulumi.Input['ChannelDvbNitSettingsArgs']]:
        return pulumi.get(self, "dvb_nit_settings")

    @dvb_nit_settings.setter
    def dvb_nit_settings(self, value: Optional[pulumi.Input['ChannelDvbNitSettingsArgs']]):
        pulumi.set(self, "dvb_nit_settings", value)

    @property
    @pulumi.getter(name="dvbSdtSettings")
    def dvb_sdt_settings(self) -> Optional[pulumi.Input['ChannelDvbSdtSettingsArgs']]:
        return pulumi.get(self, "dvb_sdt_settings")

    @dvb_sdt_settings.setter
    def dvb_sdt_settings(self, value: Optional[pulumi.Input['ChannelDvbSdtSettingsArgs']]):
        pulumi.set(self, "dvb_sdt_settings", value)

    @property
    @pulumi.getter(name="dvbSubPids")
    def dvb_sub_pids(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "dvb_sub_pids")

    @dvb_sub_pids.setter
    def dvb_sub_pids(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dvb_sub_pids", value)

    @property
    @pulumi.getter(name="dvbTdtSettings")
    def dvb_tdt_settings(self) -> Optional[pulumi.Input['ChannelDvbTdtSettingsArgs']]:
        return pulumi.get(self, "dvb_tdt_settings")

    @dvb_tdt_settings.setter
    def dvb_tdt_settings(self, value: Optional[pulumi.Input['ChannelDvbTdtSettingsArgs']]):
        pulumi.set(self, "dvb_tdt_settings", value)

    @property
    @pulumi.getter(name="dvbTeletextPid")
    def dvb_teletext_pid(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "dvb_teletext_pid")

    @dvb_teletext_pid.setter
    def dvb_teletext_pid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dvb_teletext_pid", value)

    @property
    @pulumi.getter
    def ebif(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ebif")

    @ebif.setter
    def ebif(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ebif", value)

    @property
    @pulumi.getter(name="ebpAudioInterval")
    def ebp_audio_interval(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ebp_audio_interval")

    @ebp_audio_interval.setter
    def ebp_audio_interval(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ebp_audio_interval", value)

    @property
    @pulumi.getter(name="ebpLookaheadMs")
    def ebp_lookahead_ms(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "ebp_lookahead_ms")

    @ebp_lookahead_ms.setter
    def ebp_lookahead_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "ebp_lookahead_ms", value)

    @property
    @pulumi.getter(name="ebpPlacement")
    def ebp_placement(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ebp_placement")

    @ebp_placement.setter
    def ebp_placement(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ebp_placement", value)

    @property
    @pulumi.getter(name="ecmPid")
    def ecm_pid(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ecm_pid")

    @ecm_pid.setter
    def ecm_pid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ecm_pid", value)

    @property
    @pulumi.getter(name="esRateInPes")
    def es_rate_in_pes(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "es_rate_in_pes")

    @es_rate_in_pes.setter
    def es_rate_in_pes(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "es_rate_in_pes", value)

    @property
    @pulumi.getter(name="etvPlatformPid")
    def etv_platform_pid(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "etv_platform_pid")

    @etv_platform_pid.setter
    def etv_platform_pid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "etv_platform_pid", value)

    @property
    @pulumi.getter(name="etvSignalPid")
    def etv_signal_pid(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "etv_signal_pid")

    @etv_signal_pid.setter
    def etv_signal_pid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "etv_signal_pid", value)

    @property
    @pulumi.getter(name="fragmentTime")
    def fragment_time(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "fragment_time")

    @fragment_time.setter
    def fragment_time(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "fragment_time", value)

    @property
    @pulumi.getter
    def klv(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "klv")

    @klv.setter
    def klv(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "klv", value)

    @property
    @pulumi.getter(name="klvDataPids")
    def klv_data_pids(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "klv_data_pids")

    @klv_data_pids.setter
    def klv_data_pids(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "klv_data_pids", value)

    @property
    @pulumi.getter(name="nielsenId3Behavior")
    def nielsen_id3_behavior(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "nielsen_id3_behavior")

    @nielsen_id3_behavior.setter
    def nielsen_id3_behavior(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "nielsen_id3_behavior", value)

    @property
    @pulumi.getter(name="nullPacketBitrate")
    def null_packet_bitrate(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "null_packet_bitrate")

    @null_packet_bitrate.setter
    def null_packet_bitrate(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "null_packet_bitrate", value)

    @property
    @pulumi.getter(name="patInterval")
    def pat_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "pat_interval")

    @pat_interval.setter
    def pat_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "pat_interval", value)

    @property
    @pulumi.getter(name="pcrControl")
    def pcr_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "pcr_control")

    @pcr_control.setter
    def pcr_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pcr_control", value)

    @property
    @pulumi.getter(name="pcrPeriod")
    def pcr_period(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "pcr_period")

    @pcr_period.setter
    def pcr_period(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "pcr_period", value)

    @property
    @pulumi.getter(name="pcrPid")
    def pcr_pid(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "pcr_pid")

    @pcr_pid.setter
    def pcr_pid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pcr_pid", value)

    @property
    @pulumi.getter(name="pmtInterval")
    def pmt_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "pmt_interval")

    @pmt_interval.setter
    def pmt_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "pmt_interval", value)

    @property
    @pulumi.getter(name="pmtPid")
    def pmt_pid(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "pmt_pid")

    @pmt_pid.setter
    def pmt_pid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pmt_pid", value)

    @property
    @pulumi.getter(name="programNum")
    def program_num(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "program_num")

    @program_num.setter
    def program_num(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "program_num", value)

    @property
    @pulumi.getter(name="rateMode")
    def rate_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "rate_mode")

    @rate_mode.setter
    def rate_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "rate_mode", value)

    @property
    @pulumi.getter(name="scte27Pids")
    def scte27_pids(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "scte27_pids")

    @scte27_pids.setter
    def scte27_pids(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scte27_pids", value)

    @property
    @pulumi.getter(name="scte35Control")
    def scte35_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "scte35_control")

    @scte35_control.setter
    def scte35_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scte35_control", value)

    @property
    @pulumi.getter(name="scte35Pid")
    def scte35_pid(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "scte35_pid")

    @scte35_pid.setter
    def scte35_pid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scte35_pid", value)

    @property
    @pulumi.getter(name="segmentationMarkers")
    def segmentation_markers(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "segmentation_markers")

    @segmentation_markers.setter
    def segmentation_markers(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "segmentation_markers", value)

    @property
    @pulumi.getter(name="segmentationStyle")
    def segmentation_style(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "segmentation_style")

    @segmentation_style.setter
    def segmentation_style(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "segmentation_style", value)

    @property
    @pulumi.getter(name="segmentationTime")
    def segmentation_time(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "segmentation_time")

    @segmentation_time.setter
    def segmentation_time(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "segmentation_time", value)

    @property
    @pulumi.getter(name="timedMetadataBehavior")
    def timed_metadata_behavior(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "timed_metadata_behavior")

    @timed_metadata_behavior.setter
    def timed_metadata_behavior(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "timed_metadata_behavior", value)

    @property
    @pulumi.getter(name="timedMetadataPid")
    def timed_metadata_pid(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "timed_metadata_pid")

    @timed_metadata_pid.setter
    def timed_metadata_pid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "timed_metadata_pid", value)

    @property
    @pulumi.getter(name="transportStreamId")
    def transport_stream_id(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "transport_stream_id")

    @transport_stream_id.setter
    def transport_stream_id(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "transport_stream_id", value)

    @property
    @pulumi.getter(name="videoPid")
    def video_pid(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "video_pid")

    @video_pid.setter
    def video_pid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "video_pid", value)


@pulumi.input_type
class ChannelM3u8SettingsArgs:
    def __init__(__self__, *,
                 audio_frames_per_pes: Optional[pulumi.Input[int]] = None,
                 audio_pids: Optional[pulumi.Input[str]] = None,
                 ecm_pid: Optional[pulumi.Input[str]] = None,
                 nielsen_id3_behavior: Optional[pulumi.Input[str]] = None,
                 pat_interval: Optional[pulumi.Input[int]] = None,
                 pcr_control: Optional[pulumi.Input[str]] = None,
                 pcr_period: Optional[pulumi.Input[int]] = None,
                 pcr_pid: Optional[pulumi.Input[str]] = None,
                 pmt_interval: Optional[pulumi.Input[int]] = None,
                 pmt_pid: Optional[pulumi.Input[str]] = None,
                 program_num: Optional[pulumi.Input[int]] = None,
                 scte35_behavior: Optional[pulumi.Input[str]] = None,
                 scte35_pid: Optional[pulumi.Input[str]] = None,
                 timed_metadata_behavior: Optional[pulumi.Input[str]] = None,
                 timed_metadata_pid: Optional[pulumi.Input[str]] = None,
                 transport_stream_id: Optional[pulumi.Input[int]] = None,
                 video_pid: Optional[pulumi.Input[str]] = None):
        if audio_frames_per_pes is not None:
            pulumi.set(__self__, "audio_frames_per_pes", audio_frames_per_pes)
        if audio_pids is not None:
            pulumi.set(__self__, "audio_pids", audio_pids)
        if ecm_pid is not None:
            pulumi.set(__self__, "ecm_pid", ecm_pid)
        if nielsen_id3_behavior is not None:
            pulumi.set(__self__, "nielsen_id3_behavior", nielsen_id3_behavior)
        if pat_interval is not None:
            pulumi.set(__self__, "pat_interval", pat_interval)
        if pcr_control is not None:
            pulumi.set(__self__, "pcr_control", pcr_control)
        if pcr_period is not None:
            pulumi.set(__self__, "pcr_period", pcr_period)
        if pcr_pid is not None:
            pulumi.set(__self__, "pcr_pid", pcr_pid)
        if pmt_interval is not None:
            pulumi.set(__self__, "pmt_interval", pmt_interval)
        if pmt_pid is not None:
            pulumi.set(__self__, "pmt_pid", pmt_pid)
        if program_num is not None:
            pulumi.set(__self__, "program_num", program_num)
        if scte35_behavior is not None:
            pulumi.set(__self__, "scte35_behavior", scte35_behavior)
        if scte35_pid is not None:
            pulumi.set(__self__, "scte35_pid", scte35_pid)
        if timed_metadata_behavior is not None:
            pulumi.set(__self__, "timed_metadata_behavior", timed_metadata_behavior)
        if timed_metadata_pid is not None:
            pulumi.set(__self__, "timed_metadata_pid", timed_metadata_pid)
        if transport_stream_id is not None:
            pulumi.set(__self__, "transport_stream_id", transport_stream_id)
        if video_pid is not None:
            pulumi.set(__self__, "video_pid", video_pid)

    @property
    @pulumi.getter(name="audioFramesPerPes")
    def audio_frames_per_pes(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "audio_frames_per_pes")

    @audio_frames_per_pes.setter
    def audio_frames_per_pes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "audio_frames_per_pes", value)

    @property
    @pulumi.getter(name="audioPids")
    def audio_pids(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "audio_pids")

    @audio_pids.setter
    def audio_pids(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "audio_pids", value)

    @property
    @pulumi.getter(name="ecmPid")
    def ecm_pid(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "ecm_pid")

    @ecm_pid.setter
    def ecm_pid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ecm_pid", value)

    @property
    @pulumi.getter(name="nielsenId3Behavior")
    def nielsen_id3_behavior(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "nielsen_id3_behavior")

    @nielsen_id3_behavior.setter
    def nielsen_id3_behavior(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "nielsen_id3_behavior", value)

    @property
    @pulumi.getter(name="patInterval")
    def pat_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "pat_interval")

    @pat_interval.setter
    def pat_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "pat_interval", value)

    @property
    @pulumi.getter(name="pcrControl")
    def pcr_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "pcr_control")

    @pcr_control.setter
    def pcr_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pcr_control", value)

    @property
    @pulumi.getter(name="pcrPeriod")
    def pcr_period(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "pcr_period")

    @pcr_period.setter
    def pcr_period(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "pcr_period", value)

    @property
    @pulumi.getter(name="pcrPid")
    def pcr_pid(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "pcr_pid")

    @pcr_pid.setter
    def pcr_pid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pcr_pid", value)

    @property
    @pulumi.getter(name="pmtInterval")
    def pmt_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "pmt_interval")

    @pmt_interval.setter
    def pmt_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "pmt_interval", value)

    @property
    @pulumi.getter(name="pmtPid")
    def pmt_pid(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "pmt_pid")

    @pmt_pid.setter
    def pmt_pid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pmt_pid", value)

    @property
    @pulumi.getter(name="programNum")
    def program_num(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "program_num")

    @program_num.setter
    def program_num(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "program_num", value)

    @property
    @pulumi.getter(name="scte35Behavior")
    def scte35_behavior(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "scte35_behavior")

    @scte35_behavior.setter
    def scte35_behavior(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scte35_behavior", value)

    @property
    @pulumi.getter(name="scte35Pid")
    def scte35_pid(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "scte35_pid")

    @scte35_pid.setter
    def scte35_pid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scte35_pid", value)

    @property
    @pulumi.getter(name="timedMetadataBehavior")
    def timed_metadata_behavior(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "timed_metadata_behavior")

    @timed_metadata_behavior.setter
    def timed_metadata_behavior(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "timed_metadata_behavior", value)

    @property
    @pulumi.getter(name="timedMetadataPid")
    def timed_metadata_pid(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "timed_metadata_pid")

    @timed_metadata_pid.setter
    def timed_metadata_pid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "timed_metadata_pid", value)

    @property
    @pulumi.getter(name="transportStreamId")
    def transport_stream_id(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "transport_stream_id")

    @transport_stream_id.setter
    def transport_stream_id(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "transport_stream_id", value)

    @property
    @pulumi.getter(name="videoPid")
    def video_pid(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "video_pid")

    @video_pid.setter
    def video_pid(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "video_pid", value)


@pulumi.input_type
class ChannelMediaPackageGroupSettingsArgs:
    def __init__(__self__, *,
                 destination: Optional[pulumi.Input['ChannelOutputLocationRefArgs']] = None):
        if destination is not None:
            pulumi.set(__self__, "destination", destination)

    @property
    @pulumi.getter
    def destination(self) -> Optional[pulumi.Input['ChannelOutputLocationRefArgs']]:
        return pulumi.get(self, "destination")

    @destination.setter
    def destination(self, value: Optional[pulumi.Input['ChannelOutputLocationRefArgs']]):
        pulumi.set(self, "destination", value)


@pulumi.input_type
class ChannelMediaPackageOutputDestinationSettingsArgs:
    def __init__(__self__, *,
                 channel_id: Optional[pulumi.Input[str]] = None):
        if channel_id is not None:
            pulumi.set(__self__, "channel_id", channel_id)

    @property
    @pulumi.getter(name="channelId")
    def channel_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "channel_id")

    @channel_id.setter
    def channel_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "channel_id", value)


@pulumi.input_type
class ChannelMediaPackageOutputSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelMotionGraphicsConfigurationArgs:
    def __init__(__self__, *,
                 motion_graphics_insertion: Optional[pulumi.Input[str]] = None,
                 motion_graphics_settings: Optional[pulumi.Input['ChannelMotionGraphicsSettingsArgs']] = None):
        if motion_graphics_insertion is not None:
            pulumi.set(__self__, "motion_graphics_insertion", motion_graphics_insertion)
        if motion_graphics_settings is not None:
            pulumi.set(__self__, "motion_graphics_settings", motion_graphics_settings)

    @property
    @pulumi.getter(name="motionGraphicsInsertion")
    def motion_graphics_insertion(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "motion_graphics_insertion")

    @motion_graphics_insertion.setter
    def motion_graphics_insertion(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "motion_graphics_insertion", value)

    @property
    @pulumi.getter(name="motionGraphicsSettings")
    def motion_graphics_settings(self) -> Optional[pulumi.Input['ChannelMotionGraphicsSettingsArgs']]:
        return pulumi.get(self, "motion_graphics_settings")

    @motion_graphics_settings.setter
    def motion_graphics_settings(self, value: Optional[pulumi.Input['ChannelMotionGraphicsSettingsArgs']]):
        pulumi.set(self, "motion_graphics_settings", value)


@pulumi.input_type
class ChannelMotionGraphicsSettingsArgs:
    def __init__(__self__, *,
                 html_motion_graphics_settings: Optional[pulumi.Input['ChannelHtmlMotionGraphicsSettingsArgs']] = None):
        if html_motion_graphics_settings is not None:
            pulumi.set(__self__, "html_motion_graphics_settings", html_motion_graphics_settings)

    @property
    @pulumi.getter(name="htmlMotionGraphicsSettings")
    def html_motion_graphics_settings(self) -> Optional[pulumi.Input['ChannelHtmlMotionGraphicsSettingsArgs']]:
        return pulumi.get(self, "html_motion_graphics_settings")

    @html_motion_graphics_settings.setter
    def html_motion_graphics_settings(self, value: Optional[pulumi.Input['ChannelHtmlMotionGraphicsSettingsArgs']]):
        pulumi.set(self, "html_motion_graphics_settings", value)


@pulumi.input_type
class ChannelMp2SettingsArgs:
    def __init__(__self__, *,
                 bitrate: Optional[pulumi.Input[float]] = None,
                 coding_mode: Optional[pulumi.Input[str]] = None,
                 sample_rate: Optional[pulumi.Input[float]] = None):
        if bitrate is not None:
            pulumi.set(__self__, "bitrate", bitrate)
        if coding_mode is not None:
            pulumi.set(__self__, "coding_mode", coding_mode)
        if sample_rate is not None:
            pulumi.set(__self__, "sample_rate", sample_rate)

    @property
    @pulumi.getter
    def bitrate(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "bitrate")

    @bitrate.setter
    def bitrate(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "bitrate", value)

    @property
    @pulumi.getter(name="codingMode")
    def coding_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "coding_mode")

    @coding_mode.setter
    def coding_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "coding_mode", value)

    @property
    @pulumi.getter(name="sampleRate")
    def sample_rate(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "sample_rate")

    @sample_rate.setter
    def sample_rate(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "sample_rate", value)


@pulumi.input_type
class ChannelMpeg2FilterSettingsArgs:
    def __init__(__self__, *,
                 temporal_filter_settings: Optional[pulumi.Input['ChannelTemporalFilterSettingsArgs']] = None):
        if temporal_filter_settings is not None:
            pulumi.set(__self__, "temporal_filter_settings", temporal_filter_settings)

    @property
    @pulumi.getter(name="temporalFilterSettings")
    def temporal_filter_settings(self) -> Optional[pulumi.Input['ChannelTemporalFilterSettingsArgs']]:
        return pulumi.get(self, "temporal_filter_settings")

    @temporal_filter_settings.setter
    def temporal_filter_settings(self, value: Optional[pulumi.Input['ChannelTemporalFilterSettingsArgs']]):
        pulumi.set(self, "temporal_filter_settings", value)


@pulumi.input_type
class ChannelMpeg2SettingsArgs:
    def __init__(__self__, *,
                 adaptive_quantization: Optional[pulumi.Input[str]] = None,
                 afd_signaling: Optional[pulumi.Input[str]] = None,
                 color_metadata: Optional[pulumi.Input[str]] = None,
                 color_space: Optional[pulumi.Input[str]] = None,
                 display_aspect_ratio: Optional[pulumi.Input[str]] = None,
                 filter_settings: Optional[pulumi.Input['ChannelMpeg2FilterSettingsArgs']] = None,
                 fixed_afd: Optional[pulumi.Input[str]] = None,
                 framerate_denominator: Optional[pulumi.Input[int]] = None,
                 framerate_numerator: Optional[pulumi.Input[int]] = None,
                 gop_closed_cadence: Optional[pulumi.Input[int]] = None,
                 gop_num_b_frames: Optional[pulumi.Input[int]] = None,
                 gop_size: Optional[pulumi.Input[float]] = None,
                 gop_size_units: Optional[pulumi.Input[str]] = None,
                 scan_type: Optional[pulumi.Input[str]] = None,
                 subgop_length: Optional[pulumi.Input[str]] = None,
                 timecode_insertion: Optional[pulumi.Input[str]] = None):
        if adaptive_quantization is not None:
            pulumi.set(__self__, "adaptive_quantization", adaptive_quantization)
        if afd_signaling is not None:
            pulumi.set(__self__, "afd_signaling", afd_signaling)
        if color_metadata is not None:
            pulumi.set(__self__, "color_metadata", color_metadata)
        if color_space is not None:
            pulumi.set(__self__, "color_space", color_space)
        if display_aspect_ratio is not None:
            pulumi.set(__self__, "display_aspect_ratio", display_aspect_ratio)
        if filter_settings is not None:
            pulumi.set(__self__, "filter_settings", filter_settings)
        if fixed_afd is not None:
            pulumi.set(__self__, "fixed_afd", fixed_afd)
        if framerate_denominator is not None:
            pulumi.set(__self__, "framerate_denominator", framerate_denominator)
        if framerate_numerator is not None:
            pulumi.set(__self__, "framerate_numerator", framerate_numerator)
        if gop_closed_cadence is not None:
            pulumi.set(__self__, "gop_closed_cadence", gop_closed_cadence)
        if gop_num_b_frames is not None:
            pulumi.set(__self__, "gop_num_b_frames", gop_num_b_frames)
        if gop_size is not None:
            pulumi.set(__self__, "gop_size", gop_size)
        if gop_size_units is not None:
            pulumi.set(__self__, "gop_size_units", gop_size_units)
        if scan_type is not None:
            pulumi.set(__self__, "scan_type", scan_type)
        if subgop_length is not None:
            pulumi.set(__self__, "subgop_length", subgop_length)
        if timecode_insertion is not None:
            pulumi.set(__self__, "timecode_insertion", timecode_insertion)

    @property
    @pulumi.getter(name="adaptiveQuantization")
    def adaptive_quantization(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "adaptive_quantization")

    @adaptive_quantization.setter
    def adaptive_quantization(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "adaptive_quantization", value)

    @property
    @pulumi.getter(name="afdSignaling")
    def afd_signaling(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "afd_signaling")

    @afd_signaling.setter
    def afd_signaling(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "afd_signaling", value)

    @property
    @pulumi.getter(name="colorMetadata")
    def color_metadata(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "color_metadata")

    @color_metadata.setter
    def color_metadata(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "color_metadata", value)

    @property
    @pulumi.getter(name="colorSpace")
    def color_space(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "color_space")

    @color_space.setter
    def color_space(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "color_space", value)

    @property
    @pulumi.getter(name="displayAspectRatio")
    def display_aspect_ratio(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "display_aspect_ratio")

    @display_aspect_ratio.setter
    def display_aspect_ratio(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "display_aspect_ratio", value)

    @property
    @pulumi.getter(name="filterSettings")
    def filter_settings(self) -> Optional[pulumi.Input['ChannelMpeg2FilterSettingsArgs']]:
        return pulumi.get(self, "filter_settings")

    @filter_settings.setter
    def filter_settings(self, value: Optional[pulumi.Input['ChannelMpeg2FilterSettingsArgs']]):
        pulumi.set(self, "filter_settings", value)

    @property
    @pulumi.getter(name="fixedAfd")
    def fixed_afd(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "fixed_afd")

    @fixed_afd.setter
    def fixed_afd(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "fixed_afd", value)

    @property
    @pulumi.getter(name="framerateDenominator")
    def framerate_denominator(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "framerate_denominator")

    @framerate_denominator.setter
    def framerate_denominator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "framerate_denominator", value)

    @property
    @pulumi.getter(name="framerateNumerator")
    def framerate_numerator(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "framerate_numerator")

    @framerate_numerator.setter
    def framerate_numerator(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "framerate_numerator", value)

    @property
    @pulumi.getter(name="gopClosedCadence")
    def gop_closed_cadence(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "gop_closed_cadence")

    @gop_closed_cadence.setter
    def gop_closed_cadence(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "gop_closed_cadence", value)

    @property
    @pulumi.getter(name="gopNumBFrames")
    def gop_num_b_frames(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "gop_num_b_frames")

    @gop_num_b_frames.setter
    def gop_num_b_frames(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "gop_num_b_frames", value)

    @property
    @pulumi.getter(name="gopSize")
    def gop_size(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "gop_size")

    @gop_size.setter
    def gop_size(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "gop_size", value)

    @property
    @pulumi.getter(name="gopSizeUnits")
    def gop_size_units(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "gop_size_units")

    @gop_size_units.setter
    def gop_size_units(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "gop_size_units", value)

    @property
    @pulumi.getter(name="scanType")
    def scan_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "scan_type")

    @scan_type.setter
    def scan_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scan_type", value)

    @property
    @pulumi.getter(name="subgopLength")
    def subgop_length(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "subgop_length")

    @subgop_length.setter
    def subgop_length(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subgop_length", value)

    @property
    @pulumi.getter(name="timecodeInsertion")
    def timecode_insertion(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "timecode_insertion")

    @timecode_insertion.setter
    def timecode_insertion(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "timecode_insertion", value)


@pulumi.input_type
class ChannelMsSmoothGroupSettingsArgs:
    def __init__(__self__, *,
                 acquisition_point_id: Optional[pulumi.Input[str]] = None,
                 audio_only_timecode_control: Optional[pulumi.Input[str]] = None,
                 certificate_mode: Optional[pulumi.Input[str]] = None,
                 connection_retry_interval: Optional[pulumi.Input[int]] = None,
                 destination: Optional[pulumi.Input['ChannelOutputLocationRefArgs']] = None,
                 event_id: Optional[pulumi.Input[str]] = None,
                 event_id_mode: Optional[pulumi.Input[str]] = None,
                 event_stop_behavior: Optional[pulumi.Input[str]] = None,
                 filecache_duration: Optional[pulumi.Input[int]] = None,
                 fragment_length: Optional[pulumi.Input[int]] = None,
                 input_loss_action: Optional[pulumi.Input[str]] = None,
                 num_retries: Optional[pulumi.Input[int]] = None,
                 restart_delay: Optional[pulumi.Input[int]] = None,
                 segmentation_mode: Optional[pulumi.Input[str]] = None,
                 send_delay_ms: Optional[pulumi.Input[int]] = None,
                 sparse_track_type: Optional[pulumi.Input[str]] = None,
                 stream_manifest_behavior: Optional[pulumi.Input[str]] = None,
                 timestamp_offset: Optional[pulumi.Input[str]] = None,
                 timestamp_offset_mode: Optional[pulumi.Input[str]] = None):
        if acquisition_point_id is not None:
            pulumi.set(__self__, "acquisition_point_id", acquisition_point_id)
        if audio_only_timecode_control is not None:
            pulumi.set(__self__, "audio_only_timecode_control", audio_only_timecode_control)
        if certificate_mode is not None:
            pulumi.set(__self__, "certificate_mode", certificate_mode)
        if connection_retry_interval is not None:
            pulumi.set(__self__, "connection_retry_interval", connection_retry_interval)
        if destination is not None:
            pulumi.set(__self__, "destination", destination)
        if event_id is not None:
            pulumi.set(__self__, "event_id", event_id)
        if event_id_mode is not None:
            pulumi.set(__self__, "event_id_mode", event_id_mode)
        if event_stop_behavior is not None:
            pulumi.set(__self__, "event_stop_behavior", event_stop_behavior)
        if filecache_duration is not None:
            pulumi.set(__self__, "filecache_duration", filecache_duration)
        if fragment_length is not None:
            pulumi.set(__self__, "fragment_length", fragment_length)
        if input_loss_action is not None:
            pulumi.set(__self__, "input_loss_action", input_loss_action)
        if num_retries is not None:
            pulumi.set(__self__, "num_retries", num_retries)
        if restart_delay is not None:
            pulumi.set(__self__, "restart_delay", restart_delay)
        if segmentation_mode is not None:
            pulumi.set(__self__, "segmentation_mode", segmentation_mode)
        if send_delay_ms is not None:
            pulumi.set(__self__, "send_delay_ms", send_delay_ms)
        if sparse_track_type is not None:
            pulumi.set(__self__, "sparse_track_type", sparse_track_type)
        if stream_manifest_behavior is not None:
            pulumi.set(__self__, "stream_manifest_behavior", stream_manifest_behavior)
        if timestamp_offset is not None:
            pulumi.set(__self__, "timestamp_offset", timestamp_offset)
        if timestamp_offset_mode is not None:
            pulumi.set(__self__, "timestamp_offset_mode", timestamp_offset_mode)

    @property
    @pulumi.getter(name="acquisitionPointId")
    def acquisition_point_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "acquisition_point_id")

    @acquisition_point_id.setter
    def acquisition_point_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "acquisition_point_id", value)

    @property
    @pulumi.getter(name="audioOnlyTimecodeControl")
    def audio_only_timecode_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "audio_only_timecode_control")

    @audio_only_timecode_control.setter
    def audio_only_timecode_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "audio_only_timecode_control", value)

    @property
    @pulumi.getter(name="certificateMode")
    def certificate_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "certificate_mode")

    @certificate_mode.setter
    def certificate_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate_mode", value)

    @property
    @pulumi.getter(name="connectionRetryInterval")
    def connection_retry_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "connection_retry_interval")

    @connection_retry_interval.setter
    def connection_retry_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "connection_retry_interval", value)

    @property
    @pulumi.getter
    def destination(self) -> Optional[pulumi.Input['ChannelOutputLocationRefArgs']]:
        return pulumi.get(self, "destination")

    @destination.setter
    def destination(self, value: Optional[pulumi.Input['ChannelOutputLocationRefArgs']]):
        pulumi.set(self, "destination", value)

    @property
    @pulumi.getter(name="eventId")
    def event_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "event_id")

    @event_id.setter
    def event_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "event_id", value)

    @property
    @pulumi.getter(name="eventIdMode")
    def event_id_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "event_id_mode")

    @event_id_mode.setter
    def event_id_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "event_id_mode", value)

    @property
    @pulumi.getter(name="eventStopBehavior")
    def event_stop_behavior(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "event_stop_behavior")

    @event_stop_behavior.setter
    def event_stop_behavior(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "event_stop_behavior", value)

    @property
    @pulumi.getter(name="filecacheDuration")
    def filecache_duration(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "filecache_duration")

    @filecache_duration.setter
    def filecache_duration(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "filecache_duration", value)

    @property
    @pulumi.getter(name="fragmentLength")
    def fragment_length(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "fragment_length")

    @fragment_length.setter
    def fragment_length(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "fragment_length", value)

    @property
    @pulumi.getter(name="inputLossAction")
    def input_loss_action(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "input_loss_action")

    @input_loss_action.setter
    def input_loss_action(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "input_loss_action", value)

    @property
    @pulumi.getter(name="numRetries")
    def num_retries(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "num_retries")

    @num_retries.setter
    def num_retries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "num_retries", value)

    @property
    @pulumi.getter(name="restartDelay")
    def restart_delay(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "restart_delay")

    @restart_delay.setter
    def restart_delay(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "restart_delay", value)

    @property
    @pulumi.getter(name="segmentationMode")
    def segmentation_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "segmentation_mode")

    @segmentation_mode.setter
    def segmentation_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "segmentation_mode", value)

    @property
    @pulumi.getter(name="sendDelayMs")
    def send_delay_ms(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "send_delay_ms")

    @send_delay_ms.setter
    def send_delay_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "send_delay_ms", value)

    @property
    @pulumi.getter(name="sparseTrackType")
    def sparse_track_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "sparse_track_type")

    @sparse_track_type.setter
    def sparse_track_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sparse_track_type", value)

    @property
    @pulumi.getter(name="streamManifestBehavior")
    def stream_manifest_behavior(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "stream_manifest_behavior")

    @stream_manifest_behavior.setter
    def stream_manifest_behavior(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "stream_manifest_behavior", value)

    @property
    @pulumi.getter(name="timestampOffset")
    def timestamp_offset(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "timestamp_offset")

    @timestamp_offset.setter
    def timestamp_offset(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "timestamp_offset", value)

    @property
    @pulumi.getter(name="timestampOffsetMode")
    def timestamp_offset_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "timestamp_offset_mode")

    @timestamp_offset_mode.setter
    def timestamp_offset_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "timestamp_offset_mode", value)


@pulumi.input_type
class ChannelMsSmoothOutputSettingsArgs:
    def __init__(__self__, *,
                 h265_packaging_type: Optional[pulumi.Input[str]] = None,
                 name_modifier: Optional[pulumi.Input[str]] = None):
        if h265_packaging_type is not None:
            pulumi.set(__self__, "h265_packaging_type", h265_packaging_type)
        if name_modifier is not None:
            pulumi.set(__self__, "name_modifier", name_modifier)

    @property
    @pulumi.getter(name="h265PackagingType")
    def h265_packaging_type(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "h265_packaging_type")

    @h265_packaging_type.setter
    def h265_packaging_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "h265_packaging_type", value)

    @property
    @pulumi.getter(name="nameModifier")
    def name_modifier(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "name_modifier")

    @name_modifier.setter
    def name_modifier(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name_modifier", value)


@pulumi.input_type
class ChannelMultiplexGroupSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelMultiplexOutputSettingsArgs:
    def __init__(__self__, *,
                 destination: Optional[pulumi.Input['ChannelOutputLocationRefArgs']] = None):
        if destination is not None:
            pulumi.set(__self__, "destination", destination)

    @property
    @pulumi.getter
    def destination(self) -> Optional[pulumi.Input['ChannelOutputLocationRefArgs']]:
        return pulumi.get(self, "destination")

    @destination.setter
    def destination(self, value: Optional[pulumi.Input['ChannelOutputLocationRefArgs']]):
        pulumi.set(self, "destination", value)


@pulumi.input_type
class ChannelMultiplexProgramChannelDestinationSettingsArgs:
    def __init__(__self__, *,
                 multiplex_id: Optional[pulumi.Input[str]] = None,
                 program_name: Optional[pulumi.Input[str]] = None):
        if multiplex_id is not None:
            pulumi.set(__self__, "multiplex_id", multiplex_id)
        if program_name is not None:
            pulumi.set(__self__, "program_name", program_name)

    @property
    @pulumi.getter(name="multiplexId")
    def multiplex_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "multiplex_id")

    @multiplex_id.setter
    def multiplex_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "multiplex_id", value)

    @property
    @pulumi.getter(name="programName")
    def program_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "program_name")

    @program_name.setter
    def program_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "program_name", value)


@pulumi.input_type
class ChannelNetworkInputSettingsArgs:
    def __init__(__self__, *,
                 hls_input_settings: Optional[pulumi.Input['ChannelHlsInputSettingsArgs']] = None,
                 server_validation: Optional[pulumi.Input[str]] = None):
        if hls_input_settings is not None:
            pulumi.set(__self__, "hls_input_settings", hls_input_settings)
        if server_validation is not None:
            pulumi.set(__self__, "server_validation", server_validation)

    @property
    @pulumi.getter(name="hlsInputSettings")
    def hls_input_settings(self) -> Optional[pulumi.Input['ChannelHlsInputSettingsArgs']]:
        return pulumi.get(self, "hls_input_settings")

    @hls_input_settings.setter
    def hls_input_settings(self, value: Optional[pulumi.Input['ChannelHlsInputSettingsArgs']]):
        pulumi.set(self, "hls_input_settings", value)

    @property
    @pulumi.getter(name="serverValidation")
    def server_validation(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "server_validation")

    @server_validation.setter
    def server_validation(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "server_validation", value)


@pulumi.input_type
class ChannelNielsenConfigurationArgs:
    def __init__(__self__, *,
                 distributor_id: Optional[pulumi.Input[str]] = None,
                 nielsen_pcm_to_id3_tagging: Optional[pulumi.Input[str]] = None):
        if distributor_id is not None:
            pulumi.set(__self__, "distributor_id", distributor_id)
        if nielsen_pcm_to_id3_tagging is not None:
            pulumi.set(__self__, "nielsen_pcm_to_id3_tagging", nielsen_pcm_to_id3_tagging)

    @property
    @pulumi.getter(name="distributorId")
    def distributor_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "distributor_id")

    @distributor_id.setter
    def distributor_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "distributor_id", value)

    @property
    @pulumi.getter(name="nielsenPcmToId3Tagging")
    def nielsen_pcm_to_id3_tagging(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "nielsen_pcm_to_id3_tagging")

    @nielsen_pcm_to_id3_tagging.setter
    def nielsen_pcm_to_id3_tagging(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "nielsen_pcm_to_id3_tagging", value)


@pulumi.input_type
class ChannelOutputDestinationSettingsArgs:
    def __init__(__self__, *,
                 password_param: Optional[pulumi.Input[str]] = None,
                 stream_name: Optional[pulumi.Input[str]] = None,
                 url: Optional[pulumi.Input[str]] = None,
                 username: Optional[pulumi.Input[str]] = None):
        if password_param is not None:
            pulumi.set(__self__, "password_param", password_param)
        if stream_name is not None:
            pulumi.set(__self__, "stream_name", stream_name)
        if url is not None:
            pulumi.set(__self__, "url", url)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="passwordParam")
    def password_param(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "password_param")

    @password_param.setter
    def password_param(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password_param", value)

    @property
    @pulumi.getter(name="streamName")
    def stream_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "stream_name")

    @stream_name.setter
    def stream_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "stream_name", value)

    @property
    @pulumi.getter
    def url(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "url", value)

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)


@pulumi.input_type
class ChannelOutputDestinationArgs:
    def __init__(__self__, *,
                 id: Optional[pulumi.Input[str]] = None,
                 media_package_settings: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelMediaPackageOutputDestinationSettingsArgs']]]] = None,
                 multiplex_settings: Optional[pulumi.Input['ChannelMultiplexProgramChannelDestinationSettingsArgs']] = None,
                 settings: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelOutputDestinationSettingsArgs']]]] = None):
        if id is not None:
            pulumi.set(__self__, "id", id)
        if media_package_settings is not None:
            pulumi.set(__self__, "media_package_settings", media_package_settings)
        if multiplex_settings is not None:
            pulumi.set(__self__, "multiplex_settings", multiplex_settings)
        if settings is not None:
            pulumi.set(__self__, "settings", settings)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter(name="mediaPackageSettings")
    def media_package_settings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ChannelMediaPackageOutputDestinationSettingsArgs']]]]:
        return pulumi.get(self, "media_package_settings")

    @media_package_settings.setter
    def media_package_settings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelMediaPackageOutputDestinationSettingsArgs']]]]):
        pulumi.set(self, "media_package_settings", value)

    @property
    @pulumi.getter(name="multiplexSettings")
    def multiplex_settings(self) -> Optional[pulumi.Input['ChannelMultiplexProgramChannelDestinationSettingsArgs']]:
        return pulumi.get(self, "multiplex_settings")

    @multiplex_settings.setter
    def multiplex_settings(self, value: Optional[pulumi.Input['ChannelMultiplexProgramChannelDestinationSettingsArgs']]):
        pulumi.set(self, "multiplex_settings", value)

    @property
    @pulumi.getter
    def settings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ChannelOutputDestinationSettingsArgs']]]]:
        return pulumi.get(self, "settings")

    @settings.setter
    def settings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelOutputDestinationSettingsArgs']]]]):
        pulumi.set(self, "settings", value)


@pulumi.input_type
class ChannelOutputGroupSettingsArgs:
    def __init__(__self__, *,
                 archive_group_settings: Optional[pulumi.Input['ChannelArchiveGroupSettingsArgs']] = None,
                 frame_capture_group_settings: Optional[pulumi.Input['ChannelFrameCaptureGroupSettingsArgs']] = None,
                 hls_group_settings: Optional[pulumi.Input['ChannelHlsGroupSettingsArgs']] = None,
                 media_package_group_settings: Optional[pulumi.Input['ChannelMediaPackageGroupSettingsArgs']] = None,
                 ms_smooth_group_settings: Optional[pulumi.Input['ChannelMsSmoothGroupSettingsArgs']] = None,
                 multiplex_group_settings: Optional[pulumi.Input['ChannelMultiplexGroupSettingsArgs']] = None,
                 rtmp_group_settings: Optional[pulumi.Input['ChannelRtmpGroupSettingsArgs']] = None,
                 udp_group_settings: Optional[pulumi.Input['ChannelUdpGroupSettingsArgs']] = None):
        if archive_group_settings is not None:
            pulumi.set(__self__, "archive_group_settings", archive_group_settings)
        if frame_capture_group_settings is not None:
            pulumi.set(__self__, "frame_capture_group_settings", frame_capture_group_settings)
        if hls_group_settings is not None:
            pulumi.set(__self__, "hls_group_settings", hls_group_settings)
        if media_package_group_settings is not None:
            pulumi.set(__self__, "media_package_group_settings", media_package_group_settings)
        if ms_smooth_group_settings is not None:
            pulumi.set(__self__, "ms_smooth_group_settings", ms_smooth_group_settings)
        if multiplex_group_settings is not None:
            pulumi.set(__self__, "multiplex_group_settings", multiplex_group_settings)
        if rtmp_group_settings is not None:
            pulumi.set(__self__, "rtmp_group_settings", rtmp_group_settings)
        if udp_group_settings is not None:
            pulumi.set(__self__, "udp_group_settings", udp_group_settings)

    @property
    @pulumi.getter(name="archiveGroupSettings")
    def archive_group_settings(self) -> Optional[pulumi.Input['ChannelArchiveGroupSettingsArgs']]:
        return pulumi.get(self, "archive_group_settings")

    @archive_group_settings.setter
    def archive_group_settings(self, value: Optional[pulumi.Input['ChannelArchiveGroupSettingsArgs']]):
        pulumi.set(self, "archive_group_settings", value)

    @property
    @pulumi.getter(name="frameCaptureGroupSettings")
    def frame_capture_group_settings(self) -> Optional[pulumi.Input['ChannelFrameCaptureGroupSettingsArgs']]:
        return pulumi.get(self, "frame_capture_group_settings")

    @frame_capture_group_settings.setter
    def frame_capture_group_settings(self, value: Optional[pulumi.Input['ChannelFrameCaptureGroupSettingsArgs']]):
        pulumi.set(self, "frame_capture_group_settings", value)

    @property
    @pulumi.getter(name="hlsGroupSettings")
    def hls_group_settings(self) -> Optional[pulumi.Input['ChannelHlsGroupSettingsArgs']]:
        return pulumi.get(self, "hls_group_settings")

    @hls_group_settings.setter
    def hls_group_settings(self, value: Optional[pulumi.Input['ChannelHlsGroupSettingsArgs']]):
        pulumi.set(self, "hls_group_settings", value)

    @property
    @pulumi.getter(name="mediaPackageGroupSettings")
    def media_package_group_settings(self) -> Optional[pulumi.Input['ChannelMediaPackageGroupSettingsArgs']]:
        return pulumi.get(self, "media_package_group_settings")

    @media_package_group_settings.setter
    def media_package_group_settings(self, value: Optional[pulumi.Input['ChannelMediaPackageGroupSettingsArgs']]):
        pulumi.set(self, "media_package_group_settings", value)

    @property
    @pulumi.getter(name="msSmoothGroupSettings")
    def ms_smooth_group_settings(self) -> Optional[pulumi.Input['ChannelMsSmoothGroupSettingsArgs']]:
        return pulumi.get(self, "ms_smooth_group_settings")

    @ms_smooth_group_settings.setter
    def ms_smooth_group_settings(self, value: Optional[pulumi.Input['ChannelMsSmoothGroupSettingsArgs']]):
        pulumi.set(self, "ms_smooth_group_settings", value)

    @property
    @pulumi.getter(name="multiplexGroupSettings")
    def multiplex_group_settings(self) -> Optional[pulumi.Input['ChannelMultiplexGroupSettingsArgs']]:
        return pulumi.get(self, "multiplex_group_settings")

    @multiplex_group_settings.setter
    def multiplex_group_settings(self, value: Optional[pulumi.Input['ChannelMultiplexGroupSettingsArgs']]):
        pulumi.set(self, "multiplex_group_settings", value)

    @property
    @pulumi.getter(name="rtmpGroupSettings")
    def rtmp_group_settings(self) -> Optional[pulumi.Input['ChannelRtmpGroupSettingsArgs']]:
        return pulumi.get(self, "rtmp_group_settings")

    @rtmp_group_settings.setter
    def rtmp_group_settings(self, value: Optional[pulumi.Input['ChannelRtmpGroupSettingsArgs']]):
        pulumi.set(self, "rtmp_group_settings", value)

    @property
    @pulumi.getter(name="udpGroupSettings")
    def udp_group_settings(self) -> Optional[pulumi.Input['ChannelUdpGroupSettingsArgs']]:
        return pulumi.get(self, "udp_group_settings")

    @udp_group_settings.setter
    def udp_group_settings(self, value: Optional[pulumi.Input['ChannelUdpGroupSettingsArgs']]):
        pulumi.set(self, "udp_group_settings", value)


@pulumi.input_type
class ChannelOutputGroupArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 output_group_settings: Optional[pulumi.Input['ChannelOutputGroupSettingsArgs']] = None,
                 outputs: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelOutputArgs']]]] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if output_group_settings is not None:
            pulumi.set(__self__, "output_group_settings", output_group_settings)
        if outputs is not None:
            pulumi.set(__self__, "outputs", outputs)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="outputGroupSettings")
    def output_group_settings(self) -> Optional[pulumi.Input['ChannelOutputGroupSettingsArgs']]:
        return pulumi.get(self, "output_group_settings")

    @output_group_settings.setter
    def output_group_settings(self, value: Optional[pulumi.Input['ChannelOutputGroupSettingsArgs']]):
        pulumi.set(self, "output_group_settings", value)

    @property
    @pulumi.getter
    def outputs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ChannelOutputArgs']]]]:
        return pulumi.get(self, "outputs")

    @outputs.setter
    def outputs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelOutputArgs']]]]):
        pulumi.set(self, "outputs", value)


@pulumi.input_type
class ChannelOutputLocationRefArgs:
    def __init__(__self__, *,
                 destination_ref_id: Optional[pulumi.Input[str]] = None):
        if destination_ref_id is not None:
            pulumi.set(__self__, "destination_ref_id", destination_ref_id)

    @property
    @pulumi.getter(name="destinationRefId")
    def destination_ref_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "destination_ref_id")

    @destination_ref_id.setter
    def destination_ref_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "destination_ref_id", value)


@pulumi.input_type
class ChannelOutputSettingsArgs:
    def __init__(__self__, *,
                 archive_output_settings: Optional[pulumi.Input['ChannelArchiveOutputSettingsArgs']] = None,
                 frame_capture_output_settings: Optional[pulumi.Input['ChannelFrameCaptureOutputSettingsArgs']] = None,
                 hls_output_settings: Optional[pulumi.Input['ChannelHlsOutputSettingsArgs']] = None,
                 media_package_output_settings: Optional[pulumi.Input['ChannelMediaPackageOutputSettingsArgs']] = None,
                 ms_smooth_output_settings: Optional[pulumi.Input['ChannelMsSmoothOutputSettingsArgs']] = None,
                 multiplex_output_settings: Optional[pulumi.Input['ChannelMultiplexOutputSettingsArgs']] = None,
                 rtmp_output_settings: Optional[pulumi.Input['ChannelRtmpOutputSettingsArgs']] = None,
                 udp_output_settings: Optional[pulumi.Input['ChannelUdpOutputSettingsArgs']] = None):
        if archive_output_settings is not None:
            pulumi.set(__self__, "archive_output_settings", archive_output_settings)
        if frame_capture_output_settings is not None:
            pulumi.set(__self__, "frame_capture_output_settings", frame_capture_output_settings)
        if hls_output_settings is not None:
            pulumi.set(__self__, "hls_output_settings", hls_output_settings)
        if media_package_output_settings is not None:
            pulumi.set(__self__, "media_package_output_settings", media_package_output_settings)
        if ms_smooth_output_settings is not None:
            pulumi.set(__self__, "ms_smooth_output_settings", ms_smooth_output_settings)
        if multiplex_output_settings is not None:
            pulumi.set(__self__, "multiplex_output_settings", multiplex_output_settings)
        if rtmp_output_settings is not None:
            pulumi.set(__self__, "rtmp_output_settings", rtmp_output_settings)
        if udp_output_settings is not None:
            pulumi.set(__self__, "udp_output_settings", udp_output_settings)

    @property
    @pulumi.getter(name="archiveOutputSettings")
    def archive_output_settings(self) -> Optional[pulumi.Input['ChannelArchiveOutputSettingsArgs']]:
        return pulumi.get(self, "archive_output_settings")

    @archive_output_settings.setter
    def archive_output_settings(self, value: Optional[pulumi.Input['ChannelArchiveOutputSettingsArgs']]):
        pulumi.set(self, "archive_output_settings", value)

    @property
    @pulumi.getter(name="frameCaptureOutputSettings")
    def frame_capture_output_settings(self) -> Optional[pulumi.Input['ChannelFrameCaptureOutputSettingsArgs']]:
        return pulumi.get(self, "frame_capture_output_settings")

    @frame_capture_output_settings.setter
    def frame_capture_output_settings(self, value: Optional[pulumi.Input['ChannelFrameCaptureOutputSettingsArgs']]):
        pulumi.set(self, "frame_capture_output_settings", value)

    @property
    @pulumi.getter(name="hlsOutputSettings")
    def hls_output_settings(self) -> Optional[pulumi.Input['ChannelHlsOutputSettingsArgs']]:
        return pulumi.get(self, "hls_output_settings")

    @hls_output_settings.setter
    def hls_output_settings(self, value: Optional[pulumi.Input['ChannelHlsOutputSettingsArgs']]):
        pulumi.set(self, "hls_output_settings", value)

    @property
    @pulumi.getter(name="mediaPackageOutputSettings")
    def media_package_output_settings(self) -> Optional[pulumi.Input['ChannelMediaPackageOutputSettingsArgs']]:
        return pulumi.get(self, "media_package_output_settings")

    @media_package_output_settings.setter
    def media_package_output_settings(self, value: Optional[pulumi.Input['ChannelMediaPackageOutputSettingsArgs']]):
        pulumi.set(self, "media_package_output_settings", value)

    @property
    @pulumi.getter(name="msSmoothOutputSettings")
    def ms_smooth_output_settings(self) -> Optional[pulumi.Input['ChannelMsSmoothOutputSettingsArgs']]:
        return pulumi.get(self, "ms_smooth_output_settings")

    @ms_smooth_output_settings.setter
    def ms_smooth_output_settings(self, value: Optional[pulumi.Input['ChannelMsSmoothOutputSettingsArgs']]):
        pulumi.set(self, "ms_smooth_output_settings", value)

    @property
    @pulumi.getter(name="multiplexOutputSettings")
    def multiplex_output_settings(self) -> Optional[pulumi.Input['ChannelMultiplexOutputSettingsArgs']]:
        return pulumi.get(self, "multiplex_output_settings")

    @multiplex_output_settings.setter
    def multiplex_output_settings(self, value: Optional[pulumi.Input['ChannelMultiplexOutputSettingsArgs']]):
        pulumi.set(self, "multiplex_output_settings", value)

    @property
    @pulumi.getter(name="rtmpOutputSettings")
    def rtmp_output_settings(self) -> Optional[pulumi.Input['ChannelRtmpOutputSettingsArgs']]:
        return pulumi.get(self, "rtmp_output_settings")

    @rtmp_output_settings.setter
    def rtmp_output_settings(self, value: Optional[pulumi.Input['ChannelRtmpOutputSettingsArgs']]):
        pulumi.set(self, "rtmp_output_settings", value)

    @property
    @pulumi.getter(name="udpOutputSettings")
    def udp_output_settings(self) -> Optional[pulumi.Input['ChannelUdpOutputSettingsArgs']]:
        return pulumi.get(self, "udp_output_settings")

    @udp_output_settings.setter
    def udp_output_settings(self, value: Optional[pulumi.Input['ChannelUdpOutputSettingsArgs']]):
        pulumi.set(self, "udp_output_settings", value)


@pulumi.input_type
class ChannelOutputArgs:
    def __init__(__self__, *,
                 audio_description_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 caption_description_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 output_name: Optional[pulumi.Input[str]] = None,
                 output_settings: Optional[pulumi.Input['ChannelOutputSettingsArgs']] = None,
                 video_description_name: Optional[pulumi.Input[str]] = None):
        if audio_description_names is not None:
            pulumi.set(__self__, "audio_description_names", audio_description_names)
        if caption_description_names is not None:
            pulumi.set(__self__, "caption_description_names", caption_description_names)
        if output_name is not None:
            pulumi.set(__self__, "output_name", output_name)
        if output_settings is not None:
            pulumi.set(__self__, "output_settings", output_settings)
        if video_description_name is not None:
            pulumi.set(__self__, "video_description_name", video_description_name)

    @property
    @pulumi.getter(name="audioDescriptionNames")
    def audio_description_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "audio_description_names")

    @audio_description_names.setter
    def audio_description_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "audio_description_names", value)

    @property
    @pulumi.getter(name="captionDescriptionNames")
    def caption_description_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "caption_description_names")

    @caption_description_names.setter
    def caption_description_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "caption_description_names", value)

    @property
    @pulumi.getter(name="outputName")
    def output_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "output_name")

    @output_name.setter
    def output_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "output_name", value)

    @property
    @pulumi.getter(name="outputSettings")
    def output_settings(self) -> Optional[pulumi.Input['ChannelOutputSettingsArgs']]:
        return pulumi.get(self, "output_settings")

    @output_settings.setter
    def output_settings(self, value: Optional[pulumi.Input['ChannelOutputSettingsArgs']]):
        pulumi.set(self, "output_settings", value)

    @property
    @pulumi.getter(name="videoDescriptionName")
    def video_description_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "video_description_name")

    @video_description_name.setter
    def video_description_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "video_description_name", value)


@pulumi.input_type
class ChannelPassThroughSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelRawSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelRec601SettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelRec709SettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelRemixSettingsArgs:
    def __init__(__self__, *,
                 channel_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelAudioChannelMappingArgs']]]] = None,
                 channels_in: Optional[pulumi.Input[int]] = None,
                 channels_out: Optional[pulumi.Input[int]] = None):
        if channel_mappings is not None:
            pulumi.set(__self__, "channel_mappings", channel_mappings)
        if channels_in is not None:
            pulumi.set(__self__, "channels_in", channels_in)
        if channels_out is not None:
            pulumi.set(__self__, "channels_out", channels_out)

    @property
    @pulumi.getter(name="channelMappings")
    def channel_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ChannelAudioChannelMappingArgs']]]]:
        return pulumi.get(self, "channel_mappings")

    @channel_mappings.setter
    def channel_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ChannelAudioChannelMappingArgs']]]]):
        pulumi.set(self, "channel_mappings", value)

    @property
    @pulumi.getter(name="channelsIn")
    def channels_in(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "channels_in")

    @channels_in.setter
    def channels_in(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "channels_in", value)

    @property
    @pulumi.getter(name="channelsOut")
    def channels_out(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "channels_out")

    @channels_out.setter
    def channels_out(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "channels_out", value)


@pulumi.input_type
class ChannelRtmpCaptionInfoDestinationSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelRtmpGroupSettingsArgs:
    def __init__(__self__, *,
                 ad_markers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 authentication_scheme: Optional[pulumi.Input[str]] = None,
                 cache_full_behavior: Optional[pulumi.Input[str]] = None,
                 cache_length: Optional[pulumi.Input[int]] = None,
                 caption_data: Optional[pulumi.Input[str]] = None,
                 input_loss_action: Optional[pulumi.Input[str]] = None,
                 restart_delay: Optional[pulumi.Input[int]] = None):
        if ad_markers is not None:
            pulumi.set(__self__, "ad_markers", ad_markers)
        if authentication_scheme is not None:
            pulumi.set(__self__, "authentication_scheme", authentication_scheme)
        if cache_full_behavior is not None:
            pulumi.set(__self__, "cache_full_behavior", cache_full_behavior)
        if cache_length is not None:
            pulumi.set(__self__, "cache_length", cache_length)
        if caption_data is not None:
            pulumi.set(__self__, "caption_data", caption_data)
        if input_loss_action is not None:
            pulumi.set(__self__, "input_loss_action", input_loss_action)
        if restart_delay is not None:
            pulumi.set(__self__, "restart_delay", restart_delay)

    @property
    @pulumi.getter(name="adMarkers")
    def ad_markers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "ad_markers")

    @ad_markers.setter
    def ad_markers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ad_markers", value)

    @property
    @pulumi.getter(name="authenticationScheme")
    def authentication_scheme(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "authentication_scheme")

    @authentication_scheme.setter
    def authentication_scheme(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "authentication_scheme", value)

    @property
    @pulumi.getter(name="cacheFullBehavior")
    def cache_full_behavior(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cache_full_behavior")

    @cache_full_behavior.setter
    def cache_full_behavior(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cache_full_behavior", value)

    @property
    @pulumi.getter(name="cacheLength")
    def cache_length(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "cache_length")

    @cache_length.setter
    def cache_length(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "cache_length", value)

    @property
    @pulumi.getter(name="captionData")
    def caption_data(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "caption_data")

    @caption_data.setter
    def caption_data(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "caption_data", value)

    @property
    @pulumi.getter(name="inputLossAction")
    def input_loss_action(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "input_loss_action")

    @input_loss_action.setter
    def input_loss_action(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "input_loss_action", value)

    @property
    @pulumi.getter(name="restartDelay")
    def restart_delay(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "restart_delay")

    @restart_delay.setter
    def restart_delay(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "restart_delay", value)


@pulumi.input_type
class ChannelRtmpOutputSettingsArgs:
    def __init__(__self__, *,
                 certificate_mode: Optional[pulumi.Input[str]] = None,
                 connection_retry_interval: Optional[pulumi.Input[int]] = None,
                 destination: Optional[pulumi.Input['ChannelOutputLocationRefArgs']] = None,
                 num_retries: Optional[pulumi.Input[int]] = None):
        if certificate_mode is not None:
            pulumi.set(__self__, "certificate_mode", certificate_mode)
        if connection_retry_interval is not None:
            pulumi.set(__self__, "connection_retry_interval", connection_retry_interval)
        if destination is not None:
            pulumi.set(__self__, "destination", destination)
        if num_retries is not None:
            pulumi.set(__self__, "num_retries", num_retries)

    @property
    @pulumi.getter(name="certificateMode")
    def certificate_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "certificate_mode")

    @certificate_mode.setter
    def certificate_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "certificate_mode", value)

    @property
    @pulumi.getter(name="connectionRetryInterval")
    def connection_retry_interval(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "connection_retry_interval")

    @connection_retry_interval.setter
    def connection_retry_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "connection_retry_interval", value)

    @property
    @pulumi.getter
    def destination(self) -> Optional[pulumi.Input['ChannelOutputLocationRefArgs']]:
        return pulumi.get(self, "destination")

    @destination.setter
    def destination(self, value: Optional[pulumi.Input['ChannelOutputLocationRefArgs']]):
        pulumi.set(self, "destination", value)

    @property
    @pulumi.getter(name="numRetries")
    def num_retries(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "num_retries")

    @num_retries.setter
    def num_retries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "num_retries", value)


@pulumi.input_type
class ChannelScte20PlusEmbeddedDestinationSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelScte20SourceSettingsArgs:
    def __init__(__self__, *,
                 convert608_to708: Optional[pulumi.Input[str]] = None,
                 source608_channel_number: Optional[pulumi.Input[int]] = None):
        if convert608_to708 is not None:
            pulumi.set(__self__, "convert608_to708", convert608_to708)
        if source608_channel_number is not None:
            pulumi.set(__self__, "source608_channel_number", source608_channel_number)

    @property
    @pulumi.getter(name="convert608To708")
    def convert608_to708(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "convert608_to708")

    @convert608_to708.setter
    def convert608_to708(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "convert608_to708", value)

    @property
    @pulumi.getter(name="source608ChannelNumber")
    def source608_channel_number(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "source608_channel_number")

    @source608_channel_number.setter
    def source608_channel_number(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "source608_channel_number", value)


@pulumi.input_type
class ChannelScte27DestinationSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelScte27SourceSettingsArgs:
    def __init__(__self__, *,
                 pid: Optional[pulumi.Input[int]] = None):
        if pid is not None:
            pulumi.set(__self__, "pid", pid)

    @property
    @pulumi.getter
    def pid(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "pid")

    @pid.setter
    def pid(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "pid", value)


@pulumi.input_type
class ChannelScte35SpliceInsertArgs:
    def __init__(__self__, *,
                 ad_avail_offset: Optional[pulumi.Input[int]] = None,
                 no_regional_blackout_flag: Optional[pulumi.Input[str]] = None,
                 web_delivery_allowed_flag: Optional[pulumi.Input[str]] = None):
        if ad_avail_offset is not None:
            pulumi.set(__self__, "ad_avail_offset", ad_avail_offset)
        if no_regional_blackout_flag is not None:
            pulumi.set(__self__, "no_regional_blackout_flag", no_regional_blackout_flag)
        if web_delivery_allowed_flag is not None:
            pulumi.set(__self__, "web_delivery_allowed_flag", web_delivery_allowed_flag)

    @property
    @pulumi.getter(name="adAvailOffset")
    def ad_avail_offset(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "ad_avail_offset")

    @ad_avail_offset.setter
    def ad_avail_offset(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "ad_avail_offset", value)

    @property
    @pulumi.getter(name="noRegionalBlackoutFlag")
    def no_regional_blackout_flag(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "no_regional_blackout_flag")

    @no_regional_blackout_flag.setter
    def no_regional_blackout_flag(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "no_regional_blackout_flag", value)

    @property
    @pulumi.getter(name="webDeliveryAllowedFlag")
    def web_delivery_allowed_flag(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "web_delivery_allowed_flag")

    @web_delivery_allowed_flag.setter
    def web_delivery_allowed_flag(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "web_delivery_allowed_flag", value)


@pulumi.input_type
class ChannelScte35TimeSignalAposArgs:
    def __init__(__self__, *,
                 ad_avail_offset: Optional[pulumi.Input[int]] = None,
                 no_regional_blackout_flag: Optional[pulumi.Input[str]] = None,
                 web_delivery_allowed_flag: Optional[pulumi.Input[str]] = None):
        if ad_avail_offset is not None:
            pulumi.set(__self__, "ad_avail_offset", ad_avail_offset)
        if no_regional_blackout_flag is not None:
            pulumi.set(__self__, "no_regional_blackout_flag", no_regional_blackout_flag)
        if web_delivery_allowed_flag is not None:
            pulumi.set(__self__, "web_delivery_allowed_flag", web_delivery_allowed_flag)

    @property
    @pulumi.getter(name="adAvailOffset")
    def ad_avail_offset(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "ad_avail_offset")

    @ad_avail_offset.setter
    def ad_avail_offset(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "ad_avail_offset", value)

    @property
    @pulumi.getter(name="noRegionalBlackoutFlag")
    def no_regional_blackout_flag(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "no_regional_blackout_flag")

    @no_regional_blackout_flag.setter
    def no_regional_blackout_flag(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "no_regional_blackout_flag", value)

    @property
    @pulumi.getter(name="webDeliveryAllowedFlag")
    def web_delivery_allowed_flag(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "web_delivery_allowed_flag")

    @web_delivery_allowed_flag.setter
    def web_delivery_allowed_flag(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "web_delivery_allowed_flag", value)


@pulumi.input_type
class ChannelSmpteTtDestinationSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelStandardHlsSettingsArgs:
    def __init__(__self__, *,
                 audio_rendition_sets: Optional[pulumi.Input[str]] = None,
                 m3u8_settings: Optional[pulumi.Input['ChannelM3u8SettingsArgs']] = None):
        if audio_rendition_sets is not None:
            pulumi.set(__self__, "audio_rendition_sets", audio_rendition_sets)
        if m3u8_settings is not None:
            pulumi.set(__self__, "m3u8_settings", m3u8_settings)

    @property
    @pulumi.getter(name="audioRenditionSets")
    def audio_rendition_sets(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "audio_rendition_sets")

    @audio_rendition_sets.setter
    def audio_rendition_sets(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "audio_rendition_sets", value)

    @property
    @pulumi.getter(name="m3u8Settings")
    def m3u8_settings(self) -> Optional[pulumi.Input['ChannelM3u8SettingsArgs']]:
        return pulumi.get(self, "m3u8_settings")

    @m3u8_settings.setter
    def m3u8_settings(self, value: Optional[pulumi.Input['ChannelM3u8SettingsArgs']]):
        pulumi.set(self, "m3u8_settings", value)


@pulumi.input_type
class ChannelStaticKeySettingsArgs:
    def __init__(__self__, *,
                 key_provider_server: Optional[pulumi.Input['ChannelInputLocationArgs']] = None,
                 static_key_value: Optional[pulumi.Input[str]] = None):
        if key_provider_server is not None:
            pulumi.set(__self__, "key_provider_server", key_provider_server)
        if static_key_value is not None:
            pulumi.set(__self__, "static_key_value", static_key_value)

    @property
    @pulumi.getter(name="keyProviderServer")
    def key_provider_server(self) -> Optional[pulumi.Input['ChannelInputLocationArgs']]:
        return pulumi.get(self, "key_provider_server")

    @key_provider_server.setter
    def key_provider_server(self, value: Optional[pulumi.Input['ChannelInputLocationArgs']]):
        pulumi.set(self, "key_provider_server", value)

    @property
    @pulumi.getter(name="staticKeyValue")
    def static_key_value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "static_key_value")

    @static_key_value.setter
    def static_key_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "static_key_value", value)


@pulumi.input_type
class ChannelTeletextDestinationSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ChannelTeletextSourceSettingsArgs:
    def __init__(__self__, *,
                 output_rectangle: Optional[pulumi.Input['ChannelCaptionRectangleArgs']] = None,
                 page_number: Optional[pulumi.Input[str]] = None):
        if output_rectangle is not None:
            pulumi.set(__self__, "output_rectangle", output_rectangle)
        if page_number is not None:
            pulumi.set(__self__, "page_number", page_number)

    @property
    @pulumi.getter(name="outputRectangle")
    def output_rectangle(self) -> Optional[pulumi.Input['ChannelCaptionRectangleArgs']]:
        return pulumi.get(self, "output_rectangle")

    @output_rectangle.setter
    def output_rectangle(self, value: Optional[pulumi.Input['ChannelCaptionRectangleArgs']]):
        pulumi.set(self, "output_rectangle", value)

    @property
    @pulumi.getter(name="pageNumber")
    def page_number(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "page_number")

    @page_number.setter
    def page_number(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "page_number", value)


@pulumi.input_type
class ChannelTemporalFilterSettingsArgs:
    def __init__(__self__, *,
                 post_filter_sharpening: Optional[pulumi.Input[str]] = None,
                 strength: Optional[pulumi.Input[str]] = None):
        if post_filter_sharpening is not None:
            pulumi.set(__self__, "post_filter_sharpening", post_filter_sharpening)
        if strength is not None:
            pulumi.set(__self__, "strength", strength)

    @property
    @pulumi.getter(name="postFilterSharpening")
    def post_filter_sharpening(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "post_filter_sharpening")

    @post_filter_sharpening.setter
    def post_filter_sharpening(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "post_filter_sharpening", value)

    @property
    @pulumi.getter
    def strength(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "strength")

    @strength.setter
    def strength(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "strength", value)


@pulumi.input_type
class ChannelTimecodeConfigArgs:
    def __init__(__self__, *,
                 source: Optional[pulumi.Input[str]] = None,
                 sync_threshold: Optional[pulumi.Input[int]] = None):
        if source is not None:
            pulumi.set(__self__, "source", source)
        if sync_threshold is not None:
            pulumi.set(__self__, "sync_threshold", sync_threshold)

    @property
    @pulumi.getter
    def source(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "source")

    @source.setter
    def source(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "source", value)

    @property
    @pulumi.getter(name="syncThreshold")
    def sync_threshold(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "sync_threshold")

    @sync_threshold.setter
    def sync_threshold(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "sync_threshold", value)


@pulumi.input_type
class ChannelTtmlDestinationSettingsArgs:
    def __init__(__self__, *,
                 style_control: Optional[pulumi.Input[str]] = None):
        if style_control is not None:
            pulumi.set(__self__, "style_control", style_control)

    @property
    @pulumi.getter(name="styleControl")
    def style_control(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "style_control")

    @style_control.setter
    def style_control(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "style_control", value)


@pulumi.input_type
class ChannelUdpContainerSettingsArgs:
    def __init__(__self__, *,
                 m2ts_settings: Optional[pulumi.Input['ChannelM2tsSettingsArgs']] = None):
        if m2ts_settings is not None:
            pulumi.set(__self__, "m2ts_settings", m2ts_settings)

    @property
    @pulumi.getter(name="m2tsSettings")
    def m2ts_settings(self) -> Optional[pulumi.Input['ChannelM2tsSettingsArgs']]:
        return pulumi.get(self, "m2ts_settings")

    @m2ts_settings.setter
    def m2ts_settings(self, value: Optional[pulumi.Input['ChannelM2tsSettingsArgs']]):
        pulumi.set(self, "m2ts_settings", value)


@pulumi.input_type
class ChannelUdpGroupSettingsArgs:
    def __init__(__self__, *,
                 input_loss_action: Optional[pulumi.Input[str]] = None,
                 timed_metadata_id3_frame: Optional[pulumi.Input[str]] = None,
                 timed_metadata_id3_period: Optional[pulumi.Input[int]] = None):
        if input_loss_action is not None:
            pulumi.set(__self__, "input_loss_action", input_loss_action)
        if timed_metadata_id3_frame is not None:
            pulumi.set(__self__, "timed_metadata_id3_frame", timed_metadata_id3_frame)
        if timed_metadata_id3_period is not None:
            pulumi.set(__self__, "timed_metadata_id3_period", timed_metadata_id3_period)

    @property
    @pulumi.getter(name="inputLossAction")
    def input_loss_action(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "input_loss_action")

    @input_loss_action.setter
    def input_loss_action(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "input_loss_action", value)

    @property
    @pulumi.getter(name="timedMetadataId3Frame")
    def timed_metadata_id3_frame(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "timed_metadata_id3_frame")

    @timed_metadata_id3_frame.setter
    def timed_metadata_id3_frame(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "timed_metadata_id3_frame", value)

    @property
    @pulumi.getter(name="timedMetadataId3Period")
    def timed_metadata_id3_period(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "timed_metadata_id3_period")

    @timed_metadata_id3_period.setter
    def timed_metadata_id3_period(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "timed_metadata_id3_period", value)


@pulumi.input_type
class ChannelUdpOutputSettingsArgs:
    def __init__(__self__, *,
                 buffer_msec: Optional[pulumi.Input[int]] = None,
                 container_settings: Optional[pulumi.Input['ChannelUdpContainerSettingsArgs']] = None,
                 destination: Optional[pulumi.Input['ChannelOutputLocationRefArgs']] = None,
                 fec_output_settings: Optional[pulumi.Input['ChannelFecOutputSettingsArgs']] = None):
        if buffer_msec is not None:
            pulumi.set(__self__, "buffer_msec", buffer_msec)
        if container_settings is not None:
            pulumi.set(__self__, "container_settings", container_settings)
        if destination is not None:
            pulumi.set(__self__, "destination", destination)
        if fec_output_settings is not None:
            pulumi.set(__self__, "fec_output_settings", fec_output_settings)

    @property
    @pulumi.getter(name="bufferMsec")
    def buffer_msec(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "buffer_msec")

    @buffer_msec.setter
    def buffer_msec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "buffer_msec", value)

    @property
    @pulumi.getter(name="containerSettings")
    def container_settings(self) -> Optional[pulumi.Input['ChannelUdpContainerSettingsArgs']]:
        return pulumi.get(self, "container_settings")

    @container_settings.setter
    def container_settings(self, value: Optional[pulumi.Input['ChannelUdpContainerSettingsArgs']]):
        pulumi.set(self, "container_settings", value)

    @property
    @pulumi.getter
    def destination(self) -> Optional[pulumi.Input['ChannelOutputLocationRefArgs']]:
        return pulumi.get(self, "destination")

    @destination.setter
    def destination(self, value: Optional[pulumi.Input['ChannelOutputLocationRefArgs']]):
        pulumi.set(self, "destination", value)

    @property
    @pulumi.getter(name="fecOutputSettings")
    def fec_output_settings(self) -> Optional[pulumi.Input['ChannelFecOutputSettingsArgs']]:
        return pulumi.get(self, "fec_output_settings")

    @fec_output_settings.setter
    def fec_output_settings(self, value: Optional[pulumi.Input['ChannelFecOutputSettingsArgs']]):
        pulumi.set(self, "fec_output_settings", value)


@pulumi.input_type
class ChannelVideoBlackFailoverSettingsArgs:
    def __init__(__self__, *,
                 black_detect_threshold: Optional[pulumi.Input[float]] = None,
                 video_black_threshold_msec: Optional[pulumi.Input[int]] = None):
        if black_detect_threshold is not None:
            pulumi.set(__self__, "black_detect_threshold", black_detect_threshold)
        if video_black_threshold_msec is not None:
            pulumi.set(__self__, "video_black_threshold_msec", video_black_threshold_msec)

    @property
    @pulumi.getter(name="blackDetectThreshold")
    def black_detect_threshold(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "black_detect_threshold")

    @black_detect_threshold.setter
    def black_detect_threshold(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "black_detect_threshold", value)

    @property
    @pulumi.getter(name="videoBlackThresholdMsec")
    def video_black_threshold_msec(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "video_black_threshold_msec")

    @video_black_threshold_msec.setter
    def video_black_threshold_msec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "video_black_threshold_msec", value)


@pulumi.input_type
class ChannelVideoCodecSettingsArgs:
    def __init__(__self__, *,
                 frame_capture_settings: Optional[pulumi.Input['ChannelFrameCaptureSettingsArgs']] = None,
                 h264_settings: Optional[pulumi.Input['ChannelH264SettingsArgs']] = None,
                 h265_settings: Optional[pulumi.Input['ChannelH265SettingsArgs']] = None,
                 mpeg2_settings: Optional[pulumi.Input['ChannelMpeg2SettingsArgs']] = None):
        if frame_capture_settings is not None:
            pulumi.set(__self__, "frame_capture_settings", frame_capture_settings)
        if h264_settings is not None:
            pulumi.set(__self__, "h264_settings", h264_settings)
        if h265_settings is not None:
            pulumi.set(__self__, "h265_settings", h265_settings)
        if mpeg2_settings is not None:
            pulumi.set(__self__, "mpeg2_settings", mpeg2_settings)

    @property
    @pulumi.getter(name="frameCaptureSettings")
    def frame_capture_settings(self) -> Optional[pulumi.Input['ChannelFrameCaptureSettingsArgs']]:
        return pulumi.get(self, "frame_capture_settings")

    @frame_capture_settings.setter
    def frame_capture_settings(self, value: Optional[pulumi.Input['ChannelFrameCaptureSettingsArgs']]):
        pulumi.set(self, "frame_capture_settings", value)

    @property
    @pulumi.getter(name="h264Settings")
    def h264_settings(self) -> Optional[pulumi.Input['ChannelH264SettingsArgs']]:
        return pulumi.get(self, "h264_settings")

    @h264_settings.setter
    def h264_settings(self, value: Optional[pulumi.Input['ChannelH264SettingsArgs']]):
        pulumi.set(self, "h264_settings", value)

    @property
    @pulumi.getter(name="h265Settings")
    def h265_settings(self) -> Optional[pulumi.Input['ChannelH265SettingsArgs']]:
        return pulumi.get(self, "h265_settings")

    @h265_settings.setter
    def h265_settings(self, value: Optional[pulumi.Input['ChannelH265SettingsArgs']]):
        pulumi.set(self, "h265_settings", value)

    @property
    @pulumi.getter(name="mpeg2Settings")
    def mpeg2_settings(self) -> Optional[pulumi.Input['ChannelMpeg2SettingsArgs']]:
        return pulumi.get(self, "mpeg2_settings")

    @mpeg2_settings.setter
    def mpeg2_settings(self, value: Optional[pulumi.Input['ChannelMpeg2SettingsArgs']]):
        pulumi.set(self, "mpeg2_settings", value)


@pulumi.input_type
class ChannelVideoDescriptionArgs:
    def __init__(__self__, *,
                 codec_settings: Optional[pulumi.Input['ChannelVideoCodecSettingsArgs']] = None,
                 height: Optional[pulumi.Input[int]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 respond_to_afd: Optional[pulumi.Input[str]] = None,
                 scaling_behavior: Optional[pulumi.Input[str]] = None,
                 sharpness: Optional[pulumi.Input[int]] = None,
                 width: Optional[pulumi.Input[int]] = None):
        if codec_settings is not None:
            pulumi.set(__self__, "codec_settings", codec_settings)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if respond_to_afd is not None:
            pulumi.set(__self__, "respond_to_afd", respond_to_afd)
        if scaling_behavior is not None:
            pulumi.set(__self__, "scaling_behavior", scaling_behavior)
        if sharpness is not None:
            pulumi.set(__self__, "sharpness", sharpness)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter(name="codecSettings")
    def codec_settings(self) -> Optional[pulumi.Input['ChannelVideoCodecSettingsArgs']]:
        return pulumi.get(self, "codec_settings")

    @codec_settings.setter
    def codec_settings(self, value: Optional[pulumi.Input['ChannelVideoCodecSettingsArgs']]):
        pulumi.set(self, "codec_settings", value)

    @property
    @pulumi.getter
    def height(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "height")

    @height.setter
    def height(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "height", value)

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="respondToAfd")
    def respond_to_afd(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "respond_to_afd")

    @respond_to_afd.setter
    def respond_to_afd(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "respond_to_afd", value)

    @property
    @pulumi.getter(name="scalingBehavior")
    def scaling_behavior(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "scaling_behavior")

    @scaling_behavior.setter
    def scaling_behavior(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scaling_behavior", value)

    @property
    @pulumi.getter
    def sharpness(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "sharpness")

    @sharpness.setter
    def sharpness(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "sharpness", value)

    @property
    @pulumi.getter
    def width(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "width")

    @width.setter
    def width(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "width", value)


@pulumi.input_type
class ChannelVideoSelectorColorSpaceSettingsArgs:
    def __init__(__self__, *,
                 hdr10_settings: Optional[pulumi.Input['ChannelHdr10SettingsArgs']] = None):
        if hdr10_settings is not None:
            pulumi.set(__self__, "hdr10_settings", hdr10_settings)

    @property
    @pulumi.getter(name="hdr10Settings")
    def hdr10_settings(self) -> Optional[pulumi.Input['ChannelHdr10SettingsArgs']]:
        return pulumi.get(self, "hdr10_settings")

    @hdr10_settings.setter
    def hdr10_settings(self, value: Optional[pulumi.Input['ChannelHdr10SettingsArgs']]):
        pulumi.set(self, "hdr10_settings", value)


@pulumi.input_type
class ChannelVideoSelectorPidArgs:
    def __init__(__self__, *,
                 pid: Optional[pulumi.Input[int]] = None):
        if pid is not None:
            pulumi.set(__self__, "pid", pid)

    @property
    @pulumi.getter
    def pid(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "pid")

    @pid.setter
    def pid(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "pid", value)


@pulumi.input_type
class ChannelVideoSelectorProgramIdArgs:
    def __init__(__self__, *,
                 program_id: Optional[pulumi.Input[int]] = None):
        if program_id is not None:
            pulumi.set(__self__, "program_id", program_id)

    @property
    @pulumi.getter(name="programId")
    def program_id(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "program_id")

    @program_id.setter
    def program_id(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "program_id", value)


@pulumi.input_type
class ChannelVideoSelectorSettingsArgs:
    def __init__(__self__, *,
                 video_selector_pid: Optional[pulumi.Input['ChannelVideoSelectorPidArgs']] = None,
                 video_selector_program_id: Optional[pulumi.Input['ChannelVideoSelectorProgramIdArgs']] = None):
        if video_selector_pid is not None:
            pulumi.set(__self__, "video_selector_pid", video_selector_pid)
        if video_selector_program_id is not None:
            pulumi.set(__self__, "video_selector_program_id", video_selector_program_id)

    @property
    @pulumi.getter(name="videoSelectorPid")
    def video_selector_pid(self) -> Optional[pulumi.Input['ChannelVideoSelectorPidArgs']]:
        return pulumi.get(self, "video_selector_pid")

    @video_selector_pid.setter
    def video_selector_pid(self, value: Optional[pulumi.Input['ChannelVideoSelectorPidArgs']]):
        pulumi.set(self, "video_selector_pid", value)

    @property
    @pulumi.getter(name="videoSelectorProgramId")
    def video_selector_program_id(self) -> Optional[pulumi.Input['ChannelVideoSelectorProgramIdArgs']]:
        return pulumi.get(self, "video_selector_program_id")

    @video_selector_program_id.setter
    def video_selector_program_id(self, value: Optional[pulumi.Input['ChannelVideoSelectorProgramIdArgs']]):
        pulumi.set(self, "video_selector_program_id", value)


@pulumi.input_type
class ChannelVideoSelectorArgs:
    def __init__(__self__, *,
                 color_space: Optional[pulumi.Input[str]] = None,
                 color_space_settings: Optional[pulumi.Input['ChannelVideoSelectorColorSpaceSettingsArgs']] = None,
                 color_space_usage: Optional[pulumi.Input[str]] = None,
                 selector_settings: Optional[pulumi.Input['ChannelVideoSelectorSettingsArgs']] = None):
        if color_space is not None:
            pulumi.set(__self__, "color_space", color_space)
        if color_space_settings is not None:
            pulumi.set(__self__, "color_space_settings", color_space_settings)
        if color_space_usage is not None:
            pulumi.set(__self__, "color_space_usage", color_space_usage)
        if selector_settings is not None:
            pulumi.set(__self__, "selector_settings", selector_settings)

    @property
    @pulumi.getter(name="colorSpace")
    def color_space(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "color_space")

    @color_space.setter
    def color_space(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "color_space", value)

    @property
    @pulumi.getter(name="colorSpaceSettings")
    def color_space_settings(self) -> Optional[pulumi.Input['ChannelVideoSelectorColorSpaceSettingsArgs']]:
        return pulumi.get(self, "color_space_settings")

    @color_space_settings.setter
    def color_space_settings(self, value: Optional[pulumi.Input['ChannelVideoSelectorColorSpaceSettingsArgs']]):
        pulumi.set(self, "color_space_settings", value)

    @property
    @pulumi.getter(name="colorSpaceUsage")
    def color_space_usage(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "color_space_usage")

    @color_space_usage.setter
    def color_space_usage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "color_space_usage", value)

    @property
    @pulumi.getter(name="selectorSettings")
    def selector_settings(self) -> Optional[pulumi.Input['ChannelVideoSelectorSettingsArgs']]:
        return pulumi.get(self, "selector_settings")

    @selector_settings.setter
    def selector_settings(self, value: Optional[pulumi.Input['ChannelVideoSelectorSettingsArgs']]):
        pulumi.set(self, "selector_settings", value)


@pulumi.input_type
class ChannelVpcOutputSettingsArgs:
    def __init__(__self__, *,
                 public_address_allocation_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        if public_address_allocation_ids is not None:
            pulumi.set(__self__, "public_address_allocation_ids", public_address_allocation_ids)
        if security_group_ids is not None:
            pulumi.set(__self__, "security_group_ids", security_group_ids)
        if subnet_ids is not None:
            pulumi.set(__self__, "subnet_ids", subnet_ids)

    @property
    @pulumi.getter(name="publicAddressAllocationIds")
    def public_address_allocation_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "public_address_allocation_ids")

    @public_address_allocation_ids.setter
    def public_address_allocation_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "public_address_allocation_ids", value)

    @property
    @pulumi.getter(name="securityGroupIds")
    def security_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "security_group_ids")

    @security_group_ids.setter
    def security_group_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "security_group_ids", value)

    @property
    @pulumi.getter(name="subnetIds")
    def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "subnet_ids")

    @subnet_ids.setter
    def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "subnet_ids", value)


@pulumi.input_type
class ChannelWavSettingsArgs:
    def __init__(__self__, *,
                 bit_depth: Optional[pulumi.Input[float]] = None,
                 coding_mode: Optional[pulumi.Input[str]] = None,
                 sample_rate: Optional[pulumi.Input[float]] = None):
        if bit_depth is not None:
            pulumi.set(__self__, "bit_depth", bit_depth)
        if coding_mode is not None:
            pulumi.set(__self__, "coding_mode", coding_mode)
        if sample_rate is not None:
            pulumi.set(__self__, "sample_rate", sample_rate)

    @property
    @pulumi.getter(name="bitDepth")
    def bit_depth(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "bit_depth")

    @bit_depth.setter
    def bit_depth(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "bit_depth", value)

    @property
    @pulumi.getter(name="codingMode")
    def coding_mode(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "coding_mode")

    @coding_mode.setter
    def coding_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "coding_mode", value)

    @property
    @pulumi.getter(name="sampleRate")
    def sample_rate(self) -> Optional[pulumi.Input[float]]:
        return pulumi.get(self, "sample_rate")

    @sample_rate.setter
    def sample_rate(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "sample_rate", value)


@pulumi.input_type
class ChannelWebvttDestinationSettingsArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class InputInputDestinationRequestArgs:
    def __init__(__self__, *,
                 stream_name: Optional[pulumi.Input[str]] = None):
        if stream_name is not None:
            pulumi.set(__self__, "stream_name", stream_name)

    @property
    @pulumi.getter(name="streamName")
    def stream_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "stream_name")

    @stream_name.setter
    def stream_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "stream_name", value)


@pulumi.input_type
class InputInputDeviceSettingsArgs:
    def __init__(__self__, *,
                 id: Optional[pulumi.Input[str]] = None):
        if id is not None:
            pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "id", value)


@pulumi.input_type
class InputInputSourceRequestArgs:
    def __init__(__self__, *,
                 password_param: Optional[pulumi.Input[str]] = None,
                 url: Optional[pulumi.Input[str]] = None,
                 username: Optional[pulumi.Input[str]] = None):
        if password_param is not None:
            pulumi.set(__self__, "password_param", password_param)
        if url is not None:
            pulumi.set(__self__, "url", url)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="passwordParam")
    def password_param(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "password_param")

    @password_param.setter
    def password_param(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password_param", value)

    @property
    @pulumi.getter
    def url(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "url", value)

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)


@pulumi.input_type
class InputInputVpcRequestArgs:
    def __init__(__self__, *,
                 security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        if security_group_ids is not None:
            pulumi.set(__self__, "security_group_ids", security_group_ids)
        if subnet_ids is not None:
            pulumi.set(__self__, "subnet_ids", subnet_ids)

    @property
    @pulumi.getter(name="securityGroupIds")
    def security_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "security_group_ids")

    @security_group_ids.setter
    def security_group_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "security_group_ids", value)

    @property
    @pulumi.getter(name="subnetIds")
    def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "subnet_ids")

    @subnet_ids.setter
    def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "subnet_ids", value)


@pulumi.input_type
class InputMediaConnectFlowRequestArgs:
    def __init__(__self__, *,
                 flow_arn: Optional[pulumi.Input[str]] = None):
        if flow_arn is not None:
            pulumi.set(__self__, "flow_arn", flow_arn)

    @property
    @pulumi.getter(name="flowArn")
    def flow_arn(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "flow_arn")

    @flow_arn.setter
    def flow_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "flow_arn", value)


@pulumi.input_type
class InputSecurityGroupInputWhitelistRuleCidrArgs:
    def __init__(__self__, *,
                 cidr: Optional[pulumi.Input[str]] = None):
        if cidr is not None:
            pulumi.set(__self__, "cidr", cidr)

    @property
    @pulumi.getter
    def cidr(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "cidr")

    @cidr.setter
    def cidr(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cidr", value)


