# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

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

__all__ = [
    'AccountFilterPresentationTimeRangeArgs',
    'AccountFilterTrackSelectionArgs',
    'AccountFilterTrackSelectionConditionArgs',
    'AssetFilterPresentationTimeRangeArgs',
    'AssetFilterTrackSelectionArgs',
    'AssetFilterTrackSelectionConditionArgs',
    'ContentKeyPolicyPolicyOptionArgs',
    'ContentKeyPolicyPolicyOptionFairplayConfigurationArgs',
    'ContentKeyPolicyPolicyOptionFairplayConfigurationOfflineRentalConfigurationArgs',
    'ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicenseArgs',
    'ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightArgs',
    'ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightExplicitAnalogTelevisionOutputRestrictionArgs',
    'ContentKeyPolicyPolicyOptionTokenRestrictionArgs',
    'ContentKeyPolicyPolicyOptionTokenRestrictionAlternateKeyArgs',
    'ContentKeyPolicyPolicyOptionTokenRestrictionRequiredClaimArgs',
    'JobInputAssetArgs',
    'JobOutputAssetArgs',
    'LiveEventCrossSiteAccessPolicyArgs',
    'LiveEventEncodingArgs',
    'LiveEventInputArgs',
    'LiveEventInputEndpointArgs',
    'LiveEventInputIpAccessControlAllowArgs',
    'LiveEventPreviewArgs',
    'LiveEventPreviewEndpointArgs',
    'LiveEventPreviewIpAccessControlAllowArgs',
    'ServiceAccountEncryptionArgs',
    'ServiceAccountEncryptionManagedIdentityArgs',
    'ServiceAccountIdentityArgs',
    'ServiceAccountKeyDeliveryAccessControlArgs',
    'ServiceAccountStorageAccountArgs',
    'ServiceAccountStorageAccountManagedIdentityArgs',
    'StreamingEndpointAccessControlArgs',
    'StreamingEndpointAccessControlAkamaiSignatureHeaderAuthenticationKeyArgs',
    'StreamingEndpointAccessControlIpAllowArgs',
    'StreamingEndpointCrossSiteAccessPolicyArgs',
    'StreamingEndpointSkusArgs',
    'StreamingLocatorContentKeyArgs',
    'StreamingPolicyCommonEncryptionCbcsArgs',
    'StreamingPolicyCommonEncryptionCbcsClearKeyEncryptionArgs',
    'StreamingPolicyCommonEncryptionCbcsDefaultContentKeyArgs',
    'StreamingPolicyCommonEncryptionCbcsDrmFairplayArgs',
    'StreamingPolicyCommonEncryptionCbcsEnabledProtocolsArgs',
    'StreamingPolicyCommonEncryptionCencArgs',
    'StreamingPolicyCommonEncryptionCencClearKeyEncryptionArgs',
    'StreamingPolicyCommonEncryptionCencClearTrackArgs',
    'StreamingPolicyCommonEncryptionCencClearTrackConditionArgs',
    'StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingArgs',
    'StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrackArgs',
    'StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrackConditionArgs',
    'StreamingPolicyCommonEncryptionCencDefaultContentKeyArgs',
    'StreamingPolicyCommonEncryptionCencDrmPlayreadyArgs',
    'StreamingPolicyCommonEncryptionCencEnabledProtocolsArgs',
    'StreamingPolicyEnvelopeEncryptionArgs',
    'StreamingPolicyEnvelopeEncryptionDefaultContentKeyArgs',
    'StreamingPolicyEnvelopeEncryptionEnabledProtocolsArgs',
    'StreamingPolicyNoEncryptionEnabledProtocolsArgs',
    'TransformOutputArgs',
    'TransformOutputAudioAnalyzerPresetArgs',
    'TransformOutputBuiltinPresetArgs',
    'TransformOutputBuiltinPresetPresetConfigurationArgs',
    'TransformOutputCustomPresetArgs',
    'TransformOutputCustomPresetCodecArgs',
    'TransformOutputCustomPresetCodecAacAudioArgs',
    'TransformOutputCustomPresetCodecCopyAudioArgs',
    'TransformOutputCustomPresetCodecCopyVideoArgs',
    'TransformOutputCustomPresetCodecDdAudioArgs',
    'TransformOutputCustomPresetCodecH264VideoArgs',
    'TransformOutputCustomPresetCodecH264VideoLayerArgs',
    'TransformOutputCustomPresetCodecH265VideoArgs',
    'TransformOutputCustomPresetCodecH265VideoLayerArgs',
    'TransformOutputCustomPresetCodecJpgImageArgs',
    'TransformOutputCustomPresetCodecJpgImageLayerArgs',
    'TransformOutputCustomPresetCodecPngImageArgs',
    'TransformOutputCustomPresetCodecPngImageLayerArgs',
    'TransformOutputCustomPresetFilterArgs',
    'TransformOutputCustomPresetFilterCropRectangleArgs',
    'TransformOutputCustomPresetFilterDeinterlaceArgs',
    'TransformOutputCustomPresetFilterFadeInArgs',
    'TransformOutputCustomPresetFilterFadeOutArgs',
    'TransformOutputCustomPresetFilterOverlayArgs',
    'TransformOutputCustomPresetFilterOverlayAudioArgs',
    'TransformOutputCustomPresetFilterOverlayVideoArgs',
    'TransformOutputCustomPresetFilterOverlayVideoCropRectangleArgs',
    'TransformOutputCustomPresetFilterOverlayVideoPositionArgs',
    'TransformOutputCustomPresetFormatArgs',
    'TransformOutputCustomPresetFormatJpgArgs',
    'TransformOutputCustomPresetFormatMp4Args',
    'TransformOutputCustomPresetFormatMp4OutputFileArgs',
    'TransformOutputCustomPresetFormatPngArgs',
    'TransformOutputCustomPresetFormatTransportStreamArgs',
    'TransformOutputCustomPresetFormatTransportStreamOutputFileArgs',
    'TransformOutputFaceDetectorPresetArgs',
    'TransformOutputVideoAnalyzerPresetArgs',
]

@pulumi.input_type
class AccountFilterPresentationTimeRangeArgs:
    def __init__(__self__, *,
                 unit_timescale_in_milliseconds: pulumi.Input[int],
                 end_in_units: Optional[pulumi.Input[int]] = None,
                 force_end: Optional[pulumi.Input[bool]] = None,
                 live_backoff_in_units: Optional[pulumi.Input[int]] = None,
                 presentation_window_in_units: Optional[pulumi.Input[int]] = None,
                 start_in_units: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] unit_timescale_in_milliseconds: Specified as the number of milliseconds in one unit timescale. For example, if you want to set a `start_in_units` at 30 seconds, you would use a value of 30 when using the `unit_timescale_in_milliseconds` in 1000. Or if you want to set `start_in_units` in 30 milliseconds, you would use a value of 30 when using the `unit_timescale_in_milliseconds` in 1. Applies timescale to `start_in_units`, `start_timescale` and `presentation_window_in_timescale` and `live_backoff_in_timescale`.
        :param pulumi.Input[int] end_in_units: The absolute end time boundary. Applies to Video on Demand (VoD).
               For the Live Streaming presentation, it is silently ignored and applied when the presentation ends and the stream becomes VoD. This is a long value that represents an absolute end point of the presentation, rounded to the closest next GOP start. The unit is defined by `unit_timescale_in_milliseconds`, so an `end_in_units` of 180 would be for 3 minutes. Use `start_in_units` and `end_in_units` to trim the fragments that will be in the playlist (manifest). For example, `start_in_units` set to 20 and `end_in_units` set to 60 using `unit_timescale_in_milliseconds` in 1000 will generate a playlist that contains fragments from between 20 seconds and 60 seconds of the VoD presentation. If a fragment straddles the boundary, the entire fragment will be included in the manifest.
        :param pulumi.Input[bool] force_end: Indicates whether the `end_in_units` property must be present. If true, `end_in_units` must be specified or a bad request code is returned. Applies to Live Streaming only. Allowed values: `false`, `true`.
        :param pulumi.Input[int] live_backoff_in_units: The relative to end right edge. Applies to Live Streaming only.
               This value defines the latest live position that a client can seek to. Using this property, you can delay live playback position and create a server-side buffer for players. The unit is defined by `unit_timescale_in_milliseconds`. The maximum live back off duration is 300 seconds. For example, a value of 20 means that the latest available content is 20 seconds delayed from the real live edge.
        :param pulumi.Input[int] presentation_window_in_units: The relative to end sliding window. Applies to Live Streaming only. Use `presentation_window_in_units` to apply a sliding window of fragments to include in a playlist. The unit is defined by `unit_timescale_in_milliseconds`. For example, set `presentation_window_in_units` to 120 to apply a two-minute sliding window. Media within 2 minutes of the live edge will be included in the playlist. If a fragment straddles the boundary, the entire fragment will be included in the playlist. The minimum presentation window duration is 60 seconds.
        :param pulumi.Input[int] start_in_units: The absolute start time boundary. Applies to Video on Demand (VoD) or Live Streaming. This is a long value that represents an absolute start point of the stream. The value gets rounded to the closest next GOP start. The unit is defined by `unit_timescale_in_milliseconds`, so a `start_in_units` of 15 would be for 15 seconds. Use `start_in_units` and `end_in_units` to trim the fragments that will be in the playlist (manifest). For example, `start_in_units` set to 20 and `end_in_units` set to 60 using `unit_timescale_in_milliseconds` in 1000 will generate a playlist that contains fragments from between 20 seconds and 60 seconds of the VoD presentation. If a fragment straddles the boundary, the entire fragment will be included in the manifest.
        """
        pulumi.set(__self__, "unit_timescale_in_milliseconds", unit_timescale_in_milliseconds)
        if end_in_units is not None:
            pulumi.set(__self__, "end_in_units", end_in_units)
        if force_end is not None:
            pulumi.set(__self__, "force_end", force_end)
        if live_backoff_in_units is not None:
            pulumi.set(__self__, "live_backoff_in_units", live_backoff_in_units)
        if presentation_window_in_units is not None:
            pulumi.set(__self__, "presentation_window_in_units", presentation_window_in_units)
        if start_in_units is not None:
            pulumi.set(__self__, "start_in_units", start_in_units)

    @property
    @pulumi.getter(name="unitTimescaleInMilliseconds")
    def unit_timescale_in_milliseconds(self) -> pulumi.Input[int]:
        """
        Specified as the number of milliseconds in one unit timescale. For example, if you want to set a `start_in_units` at 30 seconds, you would use a value of 30 when using the `unit_timescale_in_milliseconds` in 1000. Or if you want to set `start_in_units` in 30 milliseconds, you would use a value of 30 when using the `unit_timescale_in_milliseconds` in 1. Applies timescale to `start_in_units`, `start_timescale` and `presentation_window_in_timescale` and `live_backoff_in_timescale`.
        """
        return pulumi.get(self, "unit_timescale_in_milliseconds")

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

    @property
    @pulumi.getter(name="endInUnits")
    def end_in_units(self) -> Optional[pulumi.Input[int]]:
        """
        The absolute end time boundary. Applies to Video on Demand (VoD).
        For the Live Streaming presentation, it is silently ignored and applied when the presentation ends and the stream becomes VoD. This is a long value that represents an absolute end point of the presentation, rounded to the closest next GOP start. The unit is defined by `unit_timescale_in_milliseconds`, so an `end_in_units` of 180 would be for 3 minutes. Use `start_in_units` and `end_in_units` to trim the fragments that will be in the playlist (manifest). For example, `start_in_units` set to 20 and `end_in_units` set to 60 using `unit_timescale_in_milliseconds` in 1000 will generate a playlist that contains fragments from between 20 seconds and 60 seconds of the VoD presentation. If a fragment straddles the boundary, the entire fragment will be included in the manifest.
        """
        return pulumi.get(self, "end_in_units")

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

    @property
    @pulumi.getter(name="forceEnd")
    def force_end(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether the `end_in_units` property must be present. If true, `end_in_units` must be specified or a bad request code is returned. Applies to Live Streaming only. Allowed values: `false`, `true`.
        """
        return pulumi.get(self, "force_end")

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

    @property
    @pulumi.getter(name="liveBackoffInUnits")
    def live_backoff_in_units(self) -> Optional[pulumi.Input[int]]:
        """
        The relative to end right edge. Applies to Live Streaming only.
        This value defines the latest live position that a client can seek to. Using this property, you can delay live playback position and create a server-side buffer for players. The unit is defined by `unit_timescale_in_milliseconds`. The maximum live back off duration is 300 seconds. For example, a value of 20 means that the latest available content is 20 seconds delayed from the real live edge.
        """
        return pulumi.get(self, "live_backoff_in_units")

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

    @property
    @pulumi.getter(name="presentationWindowInUnits")
    def presentation_window_in_units(self) -> Optional[pulumi.Input[int]]:
        """
        The relative to end sliding window. Applies to Live Streaming only. Use `presentation_window_in_units` to apply a sliding window of fragments to include in a playlist. The unit is defined by `unit_timescale_in_milliseconds`. For example, set `presentation_window_in_units` to 120 to apply a two-minute sliding window. Media within 2 minutes of the live edge will be included in the playlist. If a fragment straddles the boundary, the entire fragment will be included in the playlist. The minimum presentation window duration is 60 seconds.
        """
        return pulumi.get(self, "presentation_window_in_units")

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

    @property
    @pulumi.getter(name="startInUnits")
    def start_in_units(self) -> Optional[pulumi.Input[int]]:
        """
        The absolute start time boundary. Applies to Video on Demand (VoD) or Live Streaming. This is a long value that represents an absolute start point of the stream. The value gets rounded to the closest next GOP start. The unit is defined by `unit_timescale_in_milliseconds`, so a `start_in_units` of 15 would be for 15 seconds. Use `start_in_units` and `end_in_units` to trim the fragments that will be in the playlist (manifest). For example, `start_in_units` set to 20 and `end_in_units` set to 60 using `unit_timescale_in_milliseconds` in 1000 will generate a playlist that contains fragments from between 20 seconds and 60 seconds of the VoD presentation. If a fragment straddles the boundary, the entire fragment will be included in the manifest.
        """
        return pulumi.get(self, "start_in_units")

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


@pulumi.input_type
class AccountFilterTrackSelectionArgs:
    def __init__(__self__, *,
                 conditions: pulumi.Input[Sequence[pulumi.Input['AccountFilterTrackSelectionConditionArgs']]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['AccountFilterTrackSelectionConditionArgs']]] conditions: One or more `selection` blocks as defined above.
        """
        pulumi.set(__self__, "conditions", conditions)

    @property
    @pulumi.getter
    def conditions(self) -> pulumi.Input[Sequence[pulumi.Input['AccountFilterTrackSelectionConditionArgs']]]:
        """
        One or more `selection` blocks as defined above.
        """
        return pulumi.get(self, "conditions")

    @conditions.setter
    def conditions(self, value: pulumi.Input[Sequence[pulumi.Input['AccountFilterTrackSelectionConditionArgs']]]):
        pulumi.set(self, "conditions", value)


@pulumi.input_type
class AccountFilterTrackSelectionConditionArgs:
    def __init__(__self__, *,
                 operation: pulumi.Input[str],
                 property: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] operation: The condition operation to test a track property against. Supported values are `Equal` and `NotEqual`.
        :param pulumi.Input[str] property: The track property to compare. Supported values are `Bitrate`, `FourCC`, `Language`, `Name` and `Type`. Check [documentation](https://docs.microsoft.com/azure/media-services/latest/filters-concept) for more details.
        :param pulumi.Input[str] value: The track property value to match or not match.
        """
        pulumi.set(__self__, "operation", operation)
        pulumi.set(__self__, "property", property)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def operation(self) -> pulumi.Input[str]:
        """
        The condition operation to test a track property against. Supported values are `Equal` and `NotEqual`.
        """
        return pulumi.get(self, "operation")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The track property value to match or not match.
        """
        return pulumi.get(self, "value")

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

    @property
    @pulumi.getter
    def property(self) -> pulumi.Input[str]:
        """
        The track property to compare. Supported values are `Bitrate`, `FourCC`, `Language`, `Name` and `Type`. Check [documentation](https://docs.microsoft.com/azure/media-services/latest/filters-concept) for more details.
        """
        return pulumi.get(self, "property")

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


@pulumi.input_type
class AssetFilterPresentationTimeRangeArgs:
    def __init__(__self__, *,
                 end_in_units: Optional[pulumi.Input[int]] = None,
                 force_end: Optional[pulumi.Input[bool]] = None,
                 live_backoff_in_units: Optional[pulumi.Input[int]] = None,
                 presentation_window_in_units: Optional[pulumi.Input[int]] = None,
                 start_in_units: Optional[pulumi.Input[int]] = None,
                 unit_timescale_in_miliseconds: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] end_in_units: The absolute end time boundary. Applies to Video on Demand (VoD).
               For the Live Streaming presentation, it is silently ignored and applied when the presentation ends and the stream becomes VoD. This is a long value that represents an absolute end point of the presentation, rounded to the closest next GOP start. The unit is defined by `unit_timescale_in_miliseconds`, so an `end_in_units` of 180 would be for 3 minutes. Use `start_in_units` and `end_in_units` to trim the fragments that will be in the playlist (manifest). For example, `start_in_units` set to 20 and `end_in_units` set to 60 using `unit_timescale_in_miliseconds` in 1000 will generate a playlist that contains fragments from between 20 seconds and 60 seconds of the VoD presentation. If a fragment straddles the boundary, the entire fragment will be included in the manifest.
        :param pulumi.Input[bool] force_end: Indicates whether the `end_in_units` property must be present. If true, `end_in_units` must be specified or a bad request code is returned. Applies to Live Streaming only. Allowed values: false, true.
        :param pulumi.Input[int] live_backoff_in_units: The relative to end right edge. Applies to Live Streaming only.
               This value defines the latest live position that a client can seek to. Using this property, you can delay live playback position and create a server-side buffer for players. The unit is defined by `unit_timescale_in_miliseconds`. The maximum live back off duration is 300 seconds. For example, a value of 20 means that the latest available content is 20 seconds delayed from the real live edge.
        :param pulumi.Input[int] presentation_window_in_units: The relative to end sliding window. Applies to Live Streaming only. Use `presentation_window_in_units` to apply a sliding window of fragments to include in a playlist. The unit is defined by `unit_timescale_in_miliseconds`. For example, set `presentation_window_in_units` to 120 to apply a two-minute sliding window. Media within 2 minutes of the live edge will be included in the playlist. If a fragment straddles the boundary, the entire fragment will be included in the playlist. The minimum presentation window duration is 60 seconds.
        :param pulumi.Input[int] start_in_units: The absolute start time boundary. Applies to Video on Demand (VoD) or Live Streaming. This is a long value that represents an absolute start point of the stream. The value gets rounded to the closest next GOP start. The unit is defined by `unit_timescale_in_miliseconds`, so a `start_in_units` of 15 would be for 15 seconds. Use `start_in_units` and `end_in_units` to trim the fragments that will be in the playlist (manifest). For example, `start_in_units` set to 20 and `end_in_units` set to 60 using `unit_timescale_in_miliseconds` in 1000 will generate a playlist that contains fragments from between 20 seconds and 60 seconds of the VoD presentation. If a fragment straddles the boundary, the entire fragment will be included in the manifest.
        :param pulumi.Input[int] unit_timescale_in_miliseconds: Specified as the number of miliseconds in one unit timescale. For example, if you want to set a `start_in_units` at 30 seconds, you would use a value of 30 when using the `unit_timescale_in_miliseconds` in 1000. Or if you want to set `start_in_units` in 30 miliseconds, you would use a value of 30 when using the `unit_timescale_in_miliseconds` in 1. Applies timescale to `start_in_units`, `start_timescale` and `presentation_window_in_timescale` and `live_backoff_in_timescale`.
        """
        if end_in_units is not None:
            pulumi.set(__self__, "end_in_units", end_in_units)
        if force_end is not None:
            pulumi.set(__self__, "force_end", force_end)
        if live_backoff_in_units is not None:
            pulumi.set(__self__, "live_backoff_in_units", live_backoff_in_units)
        if presentation_window_in_units is not None:
            pulumi.set(__self__, "presentation_window_in_units", presentation_window_in_units)
        if start_in_units is not None:
            pulumi.set(__self__, "start_in_units", start_in_units)
        if unit_timescale_in_miliseconds is not None:
            pulumi.set(__self__, "unit_timescale_in_miliseconds", unit_timescale_in_miliseconds)

    @property
    @pulumi.getter(name="endInUnits")
    def end_in_units(self) -> Optional[pulumi.Input[int]]:
        """
        The absolute end time boundary. Applies to Video on Demand (VoD).
        For the Live Streaming presentation, it is silently ignored and applied when the presentation ends and the stream becomes VoD. This is a long value that represents an absolute end point of the presentation, rounded to the closest next GOP start. The unit is defined by `unit_timescale_in_miliseconds`, so an `end_in_units` of 180 would be for 3 minutes. Use `start_in_units` and `end_in_units` to trim the fragments that will be in the playlist (manifest). For example, `start_in_units` set to 20 and `end_in_units` set to 60 using `unit_timescale_in_miliseconds` in 1000 will generate a playlist that contains fragments from between 20 seconds and 60 seconds of the VoD presentation. If a fragment straddles the boundary, the entire fragment will be included in the manifest.
        """
        return pulumi.get(self, "end_in_units")

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

    @property
    @pulumi.getter(name="forceEnd")
    def force_end(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether the `end_in_units` property must be present. If true, `end_in_units` must be specified or a bad request code is returned. Applies to Live Streaming only. Allowed values: false, true.
        """
        return pulumi.get(self, "force_end")

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

    @property
    @pulumi.getter(name="liveBackoffInUnits")
    def live_backoff_in_units(self) -> Optional[pulumi.Input[int]]:
        """
        The relative to end right edge. Applies to Live Streaming only.
        This value defines the latest live position that a client can seek to. Using this property, you can delay live playback position and create a server-side buffer for players. The unit is defined by `unit_timescale_in_miliseconds`. The maximum live back off duration is 300 seconds. For example, a value of 20 means that the latest available content is 20 seconds delayed from the real live edge.
        """
        return pulumi.get(self, "live_backoff_in_units")

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

    @property
    @pulumi.getter(name="presentationWindowInUnits")
    def presentation_window_in_units(self) -> Optional[pulumi.Input[int]]:
        """
        The relative to end sliding window. Applies to Live Streaming only. Use `presentation_window_in_units` to apply a sliding window of fragments to include in a playlist. The unit is defined by `unit_timescale_in_miliseconds`. For example, set `presentation_window_in_units` to 120 to apply a two-minute sliding window. Media within 2 minutes of the live edge will be included in the playlist. If a fragment straddles the boundary, the entire fragment will be included in the playlist. The minimum presentation window duration is 60 seconds.
        """
        return pulumi.get(self, "presentation_window_in_units")

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

    @property
    @pulumi.getter(name="startInUnits")
    def start_in_units(self) -> Optional[pulumi.Input[int]]:
        """
        The absolute start time boundary. Applies to Video on Demand (VoD) or Live Streaming. This is a long value that represents an absolute start point of the stream. The value gets rounded to the closest next GOP start. The unit is defined by `unit_timescale_in_miliseconds`, so a `start_in_units` of 15 would be for 15 seconds. Use `start_in_units` and `end_in_units` to trim the fragments that will be in the playlist (manifest). For example, `start_in_units` set to 20 and `end_in_units` set to 60 using `unit_timescale_in_miliseconds` in 1000 will generate a playlist that contains fragments from between 20 seconds and 60 seconds of the VoD presentation. If a fragment straddles the boundary, the entire fragment will be included in the manifest.
        """
        return pulumi.get(self, "start_in_units")

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

    @property
    @pulumi.getter(name="unitTimescaleInMiliseconds")
    def unit_timescale_in_miliseconds(self) -> Optional[pulumi.Input[int]]:
        """
        Specified as the number of miliseconds in one unit timescale. For example, if you want to set a `start_in_units` at 30 seconds, you would use a value of 30 when using the `unit_timescale_in_miliseconds` in 1000. Or if you want to set `start_in_units` in 30 miliseconds, you would use a value of 30 when using the `unit_timescale_in_miliseconds` in 1. Applies timescale to `start_in_units`, `start_timescale` and `presentation_window_in_timescale` and `live_backoff_in_timescale`.
        """
        return pulumi.get(self, "unit_timescale_in_miliseconds")

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


@pulumi.input_type
class AssetFilterTrackSelectionArgs:
    def __init__(__self__, *,
                 conditions: pulumi.Input[Sequence[pulumi.Input['AssetFilterTrackSelectionConditionArgs']]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['AssetFilterTrackSelectionConditionArgs']]] conditions: One or more `condition` blocks as defined above.
        """
        pulumi.set(__self__, "conditions", conditions)

    @property
    @pulumi.getter
    def conditions(self) -> pulumi.Input[Sequence[pulumi.Input['AssetFilterTrackSelectionConditionArgs']]]:
        """
        One or more `condition` blocks as defined above.
        """
        return pulumi.get(self, "conditions")

    @conditions.setter
    def conditions(self, value: pulumi.Input[Sequence[pulumi.Input['AssetFilterTrackSelectionConditionArgs']]]):
        pulumi.set(self, "conditions", value)


@pulumi.input_type
class AssetFilterTrackSelectionConditionArgs:
    def __init__(__self__, *,
                 operation: Optional[pulumi.Input[str]] = None,
                 property: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] operation: The condition operation to test a track property against. Supported values are `Equal` and `NotEqual`.
        :param pulumi.Input[str] property: The track property to compare. Supported values are `Bitrate`, `FourCC`, `Language`, `Name` and `Type`. Check [documentation](https://docs.microsoft.com/azure/media-services/latest/filters-concept) for more details.
        :param pulumi.Input[str] value: The track property value to match or not match.
        """
        if operation is not None:
            pulumi.set(__self__, "operation", operation)
        if property is not None:
            pulumi.set(__self__, "property", property)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def operation(self) -> Optional[pulumi.Input[str]]:
        """
        The condition operation to test a track property against. Supported values are `Equal` and `NotEqual`.
        """
        return pulumi.get(self, "operation")

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

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        """
        The track property value to match or not match.
        """
        return pulumi.get(self, "value")

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

    @property
    @pulumi.getter
    def property(self) -> Optional[pulumi.Input[str]]:
        """
        The track property to compare. Supported values are `Bitrate`, `FourCC`, `Language`, `Name` and `Type`. Check [documentation](https://docs.microsoft.com/azure/media-services/latest/filters-concept) for more details.
        """
        return pulumi.get(self, "property")

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


@pulumi.input_type
class ContentKeyPolicyPolicyOptionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 clear_key_configuration_enabled: Optional[pulumi.Input[bool]] = None,
                 fairplay_configuration: Optional[pulumi.Input['ContentKeyPolicyPolicyOptionFairplayConfigurationArgs']] = None,
                 open_restriction_enabled: Optional[pulumi.Input[bool]] = None,
                 playready_configuration_licenses: Optional[pulumi.Input[Sequence[pulumi.Input['ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicenseArgs']]]] = None,
                 playready_response_custom_data: Optional[pulumi.Input[str]] = None,
                 token_restriction: Optional[pulumi.Input['ContentKeyPolicyPolicyOptionTokenRestrictionArgs']] = None,
                 widevine_configuration_template: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The name which should be used for this Policy Option.
        :param pulumi.Input[bool] clear_key_configuration_enabled: Enable a configuration for non-DRM keys.
        :param pulumi.Input['ContentKeyPolicyPolicyOptionFairplayConfigurationArgs'] fairplay_configuration: A `fairplay_configuration` block as defined above. Check license requirements here <https://docs.microsoft.com/azure/media-services/latest/fairplay-license-overview>.
        :param pulumi.Input[bool] open_restriction_enabled: Enable an open restriction. License or key will be delivered on every request.
        :param pulumi.Input[Sequence[pulumi.Input['ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicenseArgs']]] playready_configuration_licenses: One or more `playready_configuration_license` blocks as defined above.
        :param pulumi.Input[str] playready_response_custom_data: The custom response data of the PlayReady configuration. This only applies when `playready_configuration_license` is specified.
        :param pulumi.Input['ContentKeyPolicyPolicyOptionTokenRestrictionArgs'] token_restriction: A `token_restriction` block as defined below.
        :param pulumi.Input[str] widevine_configuration_template: The Widevine template.
               
               > **NOTE:** Each policy_option can only have one type of configuration: `fairplay_configuration`, `clear_key_configuration_enabled`, `playready_configuration_license` or `widevine_configuration_template`. And is possible to assign only one type of restriction: `open_restriction_enabled` or `token_restriction`.
        """
        pulumi.set(__self__, "name", name)
        if clear_key_configuration_enabled is not None:
            pulumi.set(__self__, "clear_key_configuration_enabled", clear_key_configuration_enabled)
        if fairplay_configuration is not None:
            pulumi.set(__self__, "fairplay_configuration", fairplay_configuration)
        if open_restriction_enabled is not None:
            pulumi.set(__self__, "open_restriction_enabled", open_restriction_enabled)
        if playready_configuration_licenses is not None:
            pulumi.set(__self__, "playready_configuration_licenses", playready_configuration_licenses)
        if playready_response_custom_data is not None:
            pulumi.set(__self__, "playready_response_custom_data", playready_response_custom_data)
        if token_restriction is not None:
            pulumi.set(__self__, "token_restriction", token_restriction)
        if widevine_configuration_template is not None:
            pulumi.set(__self__, "widevine_configuration_template", widevine_configuration_template)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name which should be used for this Policy Option.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="clearKeyConfigurationEnabled")
    def clear_key_configuration_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable a configuration for non-DRM keys.
        """
        return pulumi.get(self, "clear_key_configuration_enabled")

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

    @property
    @pulumi.getter(name="fairplayConfiguration")
    def fairplay_configuration(self) -> Optional[pulumi.Input['ContentKeyPolicyPolicyOptionFairplayConfigurationArgs']]:
        """
        A `fairplay_configuration` block as defined above. Check license requirements here <https://docs.microsoft.com/azure/media-services/latest/fairplay-license-overview>.
        """
        return pulumi.get(self, "fairplay_configuration")

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

    @property
    @pulumi.getter(name="openRestrictionEnabled")
    def open_restriction_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable an open restriction. License or key will be delivered on every request.
        """
        return pulumi.get(self, "open_restriction_enabled")

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

    @property
    @pulumi.getter(name="playreadyConfigurationLicenses")
    def playready_configuration_licenses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicenseArgs']]]]:
        """
        One or more `playready_configuration_license` blocks as defined above.
        """
        return pulumi.get(self, "playready_configuration_licenses")

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

    @property
    @pulumi.getter(name="playreadyResponseCustomData")
    def playready_response_custom_data(self) -> Optional[pulumi.Input[str]]:
        """
        The custom response data of the PlayReady configuration. This only applies when `playready_configuration_license` is specified.
        """
        return pulumi.get(self, "playready_response_custom_data")

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

    @property
    @pulumi.getter(name="tokenRestriction")
    def token_restriction(self) -> Optional[pulumi.Input['ContentKeyPolicyPolicyOptionTokenRestrictionArgs']]:
        """
        A `token_restriction` block as defined below.
        """
        return pulumi.get(self, "token_restriction")

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

    @property
    @pulumi.getter(name="widevineConfigurationTemplate")
    def widevine_configuration_template(self) -> Optional[pulumi.Input[str]]:
        """
        The Widevine template.

        > **NOTE:** Each policy_option can only have one type of configuration: `fairplay_configuration`, `clear_key_configuration_enabled`, `playready_configuration_license` or `widevine_configuration_template`. And is possible to assign only one type of restriction: `open_restriction_enabled` or `token_restriction`.
        """
        return pulumi.get(self, "widevine_configuration_template")

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


@pulumi.input_type
class ContentKeyPolicyPolicyOptionFairplayConfigurationArgs:
    def __init__(__self__, *,
                 ask: Optional[pulumi.Input[str]] = None,
                 offline_rental_configuration: Optional[pulumi.Input['ContentKeyPolicyPolicyOptionFairplayConfigurationOfflineRentalConfigurationArgs']] = None,
                 pfx: Optional[pulumi.Input[str]] = None,
                 pfx_password: Optional[pulumi.Input[str]] = None,
                 rental_and_lease_key_type: Optional[pulumi.Input[str]] = None,
                 rental_duration_seconds: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] ask: The key that must be used as FairPlay Application Secret key.
        :param pulumi.Input['ContentKeyPolicyPolicyOptionFairplayConfigurationOfflineRentalConfigurationArgs'] offline_rental_configuration: A `offline_rental_configuration` block as defined below.
        :param pulumi.Input[str] pfx: The Base64 representation of FairPlay certificate in PKCS 12 (pfx) format (including private key).
        :param pulumi.Input[str] pfx_password: The password encrypting FairPlay certificate in PKCS 12 (pfx) format.
        :param pulumi.Input[str] rental_and_lease_key_type: The rental and lease key type. Supported values are `DualExpiry`, `PersistentLimited`, `PersistentUnlimited` or `Undefined`.
        :param pulumi.Input[int] rental_duration_seconds: The rental duration. Must be greater than 0.
        """
        if ask is not None:
            pulumi.set(__self__, "ask", ask)
        if offline_rental_configuration is not None:
            pulumi.set(__self__, "offline_rental_configuration", offline_rental_configuration)
        if pfx is not None:
            pulumi.set(__self__, "pfx", pfx)
        if pfx_password is not None:
            pulumi.set(__self__, "pfx_password", pfx_password)
        if rental_and_lease_key_type is not None:
            pulumi.set(__self__, "rental_and_lease_key_type", rental_and_lease_key_type)
        if rental_duration_seconds is not None:
            pulumi.set(__self__, "rental_duration_seconds", rental_duration_seconds)

    @property
    @pulumi.getter
    def ask(self) -> Optional[pulumi.Input[str]]:
        """
        The key that must be used as FairPlay Application Secret key.
        """
        return pulumi.get(self, "ask")

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

    @property
    @pulumi.getter(name="offlineRentalConfiguration")
    def offline_rental_configuration(self) -> Optional[pulumi.Input['ContentKeyPolicyPolicyOptionFairplayConfigurationOfflineRentalConfigurationArgs']]:
        """
        A `offline_rental_configuration` block as defined below.
        """
        return pulumi.get(self, "offline_rental_configuration")

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

    @property
    @pulumi.getter
    def pfx(self) -> Optional[pulumi.Input[str]]:
        """
        The Base64 representation of FairPlay certificate in PKCS 12 (pfx) format (including private key).
        """
        return pulumi.get(self, "pfx")

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

    @property
    @pulumi.getter(name="pfxPassword")
    def pfx_password(self) -> Optional[pulumi.Input[str]]:
        """
        The password encrypting FairPlay certificate in PKCS 12 (pfx) format.
        """
        return pulumi.get(self, "pfx_password")

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

    @property
    @pulumi.getter(name="rentalAndLeaseKeyType")
    def rental_and_lease_key_type(self) -> Optional[pulumi.Input[str]]:
        """
        The rental and lease key type. Supported values are `DualExpiry`, `PersistentLimited`, `PersistentUnlimited` or `Undefined`.
        """
        return pulumi.get(self, "rental_and_lease_key_type")

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

    @property
    @pulumi.getter(name="rentalDurationSeconds")
    def rental_duration_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        The rental duration. Must be greater than 0.
        """
        return pulumi.get(self, "rental_duration_seconds")

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


@pulumi.input_type
class ContentKeyPolicyPolicyOptionFairplayConfigurationOfflineRentalConfigurationArgs:
    def __init__(__self__, *,
                 playback_duration_seconds: Optional[pulumi.Input[int]] = None,
                 storage_duration_seconds: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] playback_duration_seconds: Playback duration.
        :param pulumi.Input[int] storage_duration_seconds: Storage duration.
        """
        if playback_duration_seconds is not None:
            pulumi.set(__self__, "playback_duration_seconds", playback_duration_seconds)
        if storage_duration_seconds is not None:
            pulumi.set(__self__, "storage_duration_seconds", storage_duration_seconds)

    @property
    @pulumi.getter(name="playbackDurationSeconds")
    def playback_duration_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Playback duration.
        """
        return pulumi.get(self, "playback_duration_seconds")

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

    @property
    @pulumi.getter(name="storageDurationSeconds")
    def storage_duration_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Storage duration.
        """
        return pulumi.get(self, "storage_duration_seconds")

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


@pulumi.input_type
class ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicenseArgs:
    def __init__(__self__, *,
                 allow_test_devices: Optional[pulumi.Input[bool]] = None,
                 begin_date: Optional[pulumi.Input[str]] = None,
                 content_key_location_from_header_enabled: Optional[pulumi.Input[bool]] = None,
                 content_key_location_from_key_id: Optional[pulumi.Input[str]] = None,
                 content_type: Optional[pulumi.Input[str]] = None,
                 expiration_date: Optional[pulumi.Input[str]] = None,
                 grace_period: Optional[pulumi.Input[str]] = None,
                 license_type: Optional[pulumi.Input[str]] = None,
                 play_right: Optional[pulumi.Input['ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightArgs']] = None,
                 relative_begin_date: Optional[pulumi.Input[str]] = None,
                 relative_expiration_date: Optional[pulumi.Input[str]] = None,
                 security_level: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] allow_test_devices: A flag indicating whether test devices can use the license.
        :param pulumi.Input[str] begin_date: The begin date of license.
        :param pulumi.Input[bool] content_key_location_from_header_enabled: Specifies that the content key ID is in the PlayReady header.
        :param pulumi.Input[str] content_key_location_from_key_id: The content key ID. Specifies that the content key ID is specified in the PlayReady configuration.
               
               > **NOTE:** You can only specify one content key location. For example if you specify `content_key_location_from_header_enabled` in true, you shouldn't specify `content_key_location_from_key_id` and vice versa.
        :param pulumi.Input[str] content_type: The PlayReady content type. Supported values are `UltraVioletDownload`, `UltraVioletStreaming` or `Unspecified`.
        :param pulumi.Input[str] expiration_date: The expiration date of license.
        :param pulumi.Input[str] grace_period: The grace period of license.
        :param pulumi.Input[str] license_type: The license type. Supported values are `NonPersistent` or `Persistent`.
        :param pulumi.Input['ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightArgs'] play_right: A `play_right` block as defined above.
        :param pulumi.Input[str] relative_begin_date: The relative begin date of license.
        :param pulumi.Input[str] relative_expiration_date: The relative expiration date of license.
        :param pulumi.Input[str] security_level: The security level of the PlayReady license. Possible values are `SL150`, `SL2000` and `SL3000`. Please see [this document](https://learn.microsoft.com/en-us/rest/api/media/content-key-policies/create-or-update?tabs=HTTP#securitylevel) for more information about security level. See [this document](https://learn.microsoft.com/en-us/azure/media-services/latest/drm-playready-license-template-concept#playready-sl3000-support) for more information about `SL3000` support.
        """
        if allow_test_devices is not None:
            pulumi.set(__self__, "allow_test_devices", allow_test_devices)
        if begin_date is not None:
            pulumi.set(__self__, "begin_date", begin_date)
        if content_key_location_from_header_enabled is not None:
            pulumi.set(__self__, "content_key_location_from_header_enabled", content_key_location_from_header_enabled)
        if content_key_location_from_key_id is not None:
            pulumi.set(__self__, "content_key_location_from_key_id", content_key_location_from_key_id)
        if content_type is not None:
            pulumi.set(__self__, "content_type", content_type)
        if expiration_date is not None:
            pulumi.set(__self__, "expiration_date", expiration_date)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if license_type is not None:
            pulumi.set(__self__, "license_type", license_type)
        if play_right is not None:
            pulumi.set(__self__, "play_right", play_right)
        if relative_begin_date is not None:
            pulumi.set(__self__, "relative_begin_date", relative_begin_date)
        if relative_expiration_date is not None:
            pulumi.set(__self__, "relative_expiration_date", relative_expiration_date)
        if security_level is not None:
            pulumi.set(__self__, "security_level", security_level)

    @property
    @pulumi.getter(name="allowTestDevices")
    def allow_test_devices(self) -> Optional[pulumi.Input[bool]]:
        """
        A flag indicating whether test devices can use the license.
        """
        return pulumi.get(self, "allow_test_devices")

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

    @property
    @pulumi.getter(name="beginDate")
    def begin_date(self) -> Optional[pulumi.Input[str]]:
        """
        The begin date of license.
        """
        return pulumi.get(self, "begin_date")

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

    @property
    @pulumi.getter(name="contentKeyLocationFromHeaderEnabled")
    def content_key_location_from_header_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies that the content key ID is in the PlayReady header.
        """
        return pulumi.get(self, "content_key_location_from_header_enabled")

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

    @property
    @pulumi.getter(name="contentKeyLocationFromKeyId")
    def content_key_location_from_key_id(self) -> Optional[pulumi.Input[str]]:
        """
        The content key ID. Specifies that the content key ID is specified in the PlayReady configuration.

        > **NOTE:** You can only specify one content key location. For example if you specify `content_key_location_from_header_enabled` in true, you shouldn't specify `content_key_location_from_key_id` and vice versa.
        """
        return pulumi.get(self, "content_key_location_from_key_id")

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

    @property
    @pulumi.getter(name="contentType")
    def content_type(self) -> Optional[pulumi.Input[str]]:
        """
        The PlayReady content type. Supported values are `UltraVioletDownload`, `UltraVioletStreaming` or `Unspecified`.
        """
        return pulumi.get(self, "content_type")

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

    @property
    @pulumi.getter(name="expirationDate")
    def expiration_date(self) -> Optional[pulumi.Input[str]]:
        """
        The expiration date of license.
        """
        return pulumi.get(self, "expiration_date")

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

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[pulumi.Input[str]]:
        """
        The grace period of license.
        """
        return pulumi.get(self, "grace_period")

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

    @property
    @pulumi.getter(name="licenseType")
    def license_type(self) -> Optional[pulumi.Input[str]]:
        """
        The license type. Supported values are `NonPersistent` or `Persistent`.
        """
        return pulumi.get(self, "license_type")

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

    @property
    @pulumi.getter(name="playRight")
    def play_right(self) -> Optional[pulumi.Input['ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightArgs']]:
        """
        A `play_right` block as defined above.
        """
        return pulumi.get(self, "play_right")

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

    @property
    @pulumi.getter(name="relativeBeginDate")
    def relative_begin_date(self) -> Optional[pulumi.Input[str]]:
        """
        The relative begin date of license.
        """
        return pulumi.get(self, "relative_begin_date")

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

    @property
    @pulumi.getter(name="relativeExpirationDate")
    def relative_expiration_date(self) -> Optional[pulumi.Input[str]]:
        """
        The relative expiration date of license.
        """
        return pulumi.get(self, "relative_expiration_date")

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

    @property
    @pulumi.getter(name="securityLevel")
    def security_level(self) -> Optional[pulumi.Input[str]]:
        """
        The security level of the PlayReady license. Possible values are `SL150`, `SL2000` and `SL3000`. Please see [this document](https://learn.microsoft.com/en-us/rest/api/media/content-key-policies/create-or-update?tabs=HTTP#securitylevel) for more information about security level. See [this document](https://learn.microsoft.com/en-us/azure/media-services/latest/drm-playready-license-template-concept#playready-sl3000-support) for more information about `SL3000` support.
        """
        return pulumi.get(self, "security_level")

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


@pulumi.input_type
class ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightArgs:
    def __init__(__self__, *,
                 agc_and_color_stripe_restriction: Optional[pulumi.Input[int]] = None,
                 allow_passing_video_content_to_unknown_output: Optional[pulumi.Input[str]] = None,
                 analog_video_opl: Optional[pulumi.Input[int]] = None,
                 compressed_digital_audio_opl: Optional[pulumi.Input[int]] = None,
                 compressed_digital_video_opl: Optional[pulumi.Input[int]] = None,
                 digital_video_only_content_restriction: Optional[pulumi.Input[bool]] = None,
                 explicit_analog_television_output_restriction: Optional[pulumi.Input['ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightExplicitAnalogTelevisionOutputRestrictionArgs']] = None,
                 first_play_expiration: Optional[pulumi.Input[str]] = None,
                 image_constraint_for_analog_component_video_restriction: Optional[pulumi.Input[bool]] = None,
                 image_constraint_for_analog_computer_monitor_restriction: Optional[pulumi.Input[bool]] = None,
                 scms_restriction: Optional[pulumi.Input[int]] = None,
                 uncompressed_digital_audio_opl: Optional[pulumi.Input[int]] = None,
                 uncompressed_digital_video_opl: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] agc_and_color_stripe_restriction: Configures Automatic Gain Control (AGC) and Color Stripe in the license. Must be between `0` and `3` inclusive.
        :param pulumi.Input[str] allow_passing_video_content_to_unknown_output: Configures Unknown output handling settings of the license. Supported values are `Allowed`, `AllowedWithVideoConstriction` or `NotAllowed`.
        :param pulumi.Input[int] analog_video_opl: Specifies the output protection level for compressed digital audio. Supported values are `100`, `150` or `200`.
        :param pulumi.Input[int] compressed_digital_audio_opl: Specifies the output protection level for compressed digital audio.Supported values are `100`, `150`, `200`, `250` or `300`.
        :param pulumi.Input[int] compressed_digital_video_opl: Specifies the output protection level for compressed digital video. Supported values are `400` or `500`.
        :param pulumi.Input[bool] digital_video_only_content_restriction: Enables the Image Constraint For Analog Component Video Restriction in the license.
        :param pulumi.Input['ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightExplicitAnalogTelevisionOutputRestrictionArgs'] explicit_analog_television_output_restriction: An `explicit_analog_television_output_restriction` block as defined above.
        :param pulumi.Input[str] first_play_expiration: The amount of time that the license is valid after the license is first used to play content.
        :param pulumi.Input[bool] image_constraint_for_analog_component_video_restriction: Enables the Image Constraint For Analog Component Video Restriction in the license.
        :param pulumi.Input[bool] image_constraint_for_analog_computer_monitor_restriction: Enables the Image Constraint For Analog Component Video Restriction in the license.
        :param pulumi.Input[int] scms_restriction: Configures the Serial Copy Management System (SCMS) in the license. Must be between `0` and `3` inclusive.
        :param pulumi.Input[int] uncompressed_digital_audio_opl: Specifies the output protection level for uncompressed digital audio. Supported values are `100`, `150`, `200`, `250` or `300`.
        :param pulumi.Input[int] uncompressed_digital_video_opl: Specifies the output protection level for uncompressed digital video. Supported values are `100`, `250`, `270` or `300`.
        """
        if agc_and_color_stripe_restriction is not None:
            pulumi.set(__self__, "agc_and_color_stripe_restriction", agc_and_color_stripe_restriction)
        if allow_passing_video_content_to_unknown_output is not None:
            pulumi.set(__self__, "allow_passing_video_content_to_unknown_output", allow_passing_video_content_to_unknown_output)
        if analog_video_opl is not None:
            pulumi.set(__self__, "analog_video_opl", analog_video_opl)
        if compressed_digital_audio_opl is not None:
            pulumi.set(__self__, "compressed_digital_audio_opl", compressed_digital_audio_opl)
        if compressed_digital_video_opl is not None:
            pulumi.set(__self__, "compressed_digital_video_opl", compressed_digital_video_opl)
        if digital_video_only_content_restriction is not None:
            pulumi.set(__self__, "digital_video_only_content_restriction", digital_video_only_content_restriction)
        if explicit_analog_television_output_restriction is not None:
            pulumi.set(__self__, "explicit_analog_television_output_restriction", explicit_analog_television_output_restriction)
        if first_play_expiration is not None:
            pulumi.set(__self__, "first_play_expiration", first_play_expiration)
        if image_constraint_for_analog_component_video_restriction is not None:
            pulumi.set(__self__, "image_constraint_for_analog_component_video_restriction", image_constraint_for_analog_component_video_restriction)
        if image_constraint_for_analog_computer_monitor_restriction is not None:
            pulumi.set(__self__, "image_constraint_for_analog_computer_monitor_restriction", image_constraint_for_analog_computer_monitor_restriction)
        if scms_restriction is not None:
            pulumi.set(__self__, "scms_restriction", scms_restriction)
        if uncompressed_digital_audio_opl is not None:
            pulumi.set(__self__, "uncompressed_digital_audio_opl", uncompressed_digital_audio_opl)
        if uncompressed_digital_video_opl is not None:
            pulumi.set(__self__, "uncompressed_digital_video_opl", uncompressed_digital_video_opl)

    @property
    @pulumi.getter(name="agcAndColorStripeRestriction")
    def agc_and_color_stripe_restriction(self) -> Optional[pulumi.Input[int]]:
        """
        Configures Automatic Gain Control (AGC) and Color Stripe in the license. Must be between `0` and `3` inclusive.
        """
        return pulumi.get(self, "agc_and_color_stripe_restriction")

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

    @property
    @pulumi.getter(name="allowPassingVideoContentToUnknownOutput")
    def allow_passing_video_content_to_unknown_output(self) -> Optional[pulumi.Input[str]]:
        """
        Configures Unknown output handling settings of the license. Supported values are `Allowed`, `AllowedWithVideoConstriction` or `NotAllowed`.
        """
        return pulumi.get(self, "allow_passing_video_content_to_unknown_output")

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

    @property
    @pulumi.getter(name="analogVideoOpl")
    def analog_video_opl(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the output protection level for compressed digital audio. Supported values are `100`, `150` or `200`.
        """
        return pulumi.get(self, "analog_video_opl")

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

    @property
    @pulumi.getter(name="compressedDigitalAudioOpl")
    def compressed_digital_audio_opl(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the output protection level for compressed digital audio.Supported values are `100`, `150`, `200`, `250` or `300`.
        """
        return pulumi.get(self, "compressed_digital_audio_opl")

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

    @property
    @pulumi.getter(name="compressedDigitalVideoOpl")
    def compressed_digital_video_opl(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the output protection level for compressed digital video. Supported values are `400` or `500`.
        """
        return pulumi.get(self, "compressed_digital_video_opl")

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

    @property
    @pulumi.getter(name="digitalVideoOnlyContentRestriction")
    def digital_video_only_content_restriction(self) -> Optional[pulumi.Input[bool]]:
        """
        Enables the Image Constraint For Analog Component Video Restriction in the license.
        """
        return pulumi.get(self, "digital_video_only_content_restriction")

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

    @property
    @pulumi.getter(name="explicitAnalogTelevisionOutputRestriction")
    def explicit_analog_television_output_restriction(self) -> Optional[pulumi.Input['ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightExplicitAnalogTelevisionOutputRestrictionArgs']]:
        """
        An `explicit_analog_television_output_restriction` block as defined above.
        """
        return pulumi.get(self, "explicit_analog_television_output_restriction")

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

    @property
    @pulumi.getter(name="firstPlayExpiration")
    def first_play_expiration(self) -> Optional[pulumi.Input[str]]:
        """
        The amount of time that the license is valid after the license is first used to play content.
        """
        return pulumi.get(self, "first_play_expiration")

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

    @property
    @pulumi.getter(name="imageConstraintForAnalogComponentVideoRestriction")
    def image_constraint_for_analog_component_video_restriction(self) -> Optional[pulumi.Input[bool]]:
        """
        Enables the Image Constraint For Analog Component Video Restriction in the license.
        """
        return pulumi.get(self, "image_constraint_for_analog_component_video_restriction")

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

    @property
    @pulumi.getter(name="imageConstraintForAnalogComputerMonitorRestriction")
    def image_constraint_for_analog_computer_monitor_restriction(self) -> Optional[pulumi.Input[bool]]:
        """
        Enables the Image Constraint For Analog Component Video Restriction in the license.
        """
        return pulumi.get(self, "image_constraint_for_analog_computer_monitor_restriction")

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

    @property
    @pulumi.getter(name="scmsRestriction")
    def scms_restriction(self) -> Optional[pulumi.Input[int]]:
        """
        Configures the Serial Copy Management System (SCMS) in the license. Must be between `0` and `3` inclusive.
        """
        return pulumi.get(self, "scms_restriction")

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

    @property
    @pulumi.getter(name="uncompressedDigitalAudioOpl")
    def uncompressed_digital_audio_opl(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the output protection level for uncompressed digital audio. Supported values are `100`, `150`, `200`, `250` or `300`.
        """
        return pulumi.get(self, "uncompressed_digital_audio_opl")

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

    @property
    @pulumi.getter(name="uncompressedDigitalVideoOpl")
    def uncompressed_digital_video_opl(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the output protection level for uncompressed digital video. Supported values are `100`, `250`, `270` or `300`.
        """
        return pulumi.get(self, "uncompressed_digital_video_opl")

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


@pulumi.input_type
class ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightExplicitAnalogTelevisionOutputRestrictionArgs:
    def __init__(__self__, *,
                 control_bits: pulumi.Input[int],
                 best_effort_enforced: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[int] control_bits: The restriction control bits. Possible value is integer between `0` and `3` inclusive.
        :param pulumi.Input[bool] best_effort_enforced: Indicates whether this restriction is enforced on a best effort basis. Possible values are `true` or `false`. Defaults to `false`.
        """
        pulumi.set(__self__, "control_bits", control_bits)
        if best_effort_enforced is not None:
            pulumi.set(__self__, "best_effort_enforced", best_effort_enforced)

    @property
    @pulumi.getter(name="controlBits")
    def control_bits(self) -> pulumi.Input[int]:
        """
        The restriction control bits. Possible value is integer between `0` and `3` inclusive.
        """
        return pulumi.get(self, "control_bits")

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

    @property
    @pulumi.getter(name="bestEffortEnforced")
    def best_effort_enforced(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates whether this restriction is enforced on a best effort basis. Possible values are `true` or `false`. Defaults to `false`.
        """
        return pulumi.get(self, "best_effort_enforced")

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


@pulumi.input_type
class ContentKeyPolicyPolicyOptionTokenRestrictionArgs:
    def __init__(__self__, *,
                 alternate_keys: Optional[pulumi.Input[Sequence[pulumi.Input['ContentKeyPolicyPolicyOptionTokenRestrictionAlternateKeyArgs']]]] = None,
                 audience: Optional[pulumi.Input[str]] = None,
                 issuer: Optional[pulumi.Input[str]] = None,
                 open_id_connect_discovery_document: Optional[pulumi.Input[str]] = None,
                 primary_rsa_token_key_exponent: Optional[pulumi.Input[str]] = None,
                 primary_rsa_token_key_modulus: Optional[pulumi.Input[str]] = None,
                 primary_symmetric_token_key: Optional[pulumi.Input[str]] = None,
                 primary_x509_token_key_raw: Optional[pulumi.Input[str]] = None,
                 required_claims: Optional[pulumi.Input[Sequence[pulumi.Input['ContentKeyPolicyPolicyOptionTokenRestrictionRequiredClaimArgs']]]] = None,
                 token_type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ContentKeyPolicyPolicyOptionTokenRestrictionAlternateKeyArgs']]] alternate_keys: One or more `alternate_key` block as defined above.
        :param pulumi.Input[str] audience: The audience for the token.
        :param pulumi.Input[str] issuer: The token issuer.
        :param pulumi.Input[str] open_id_connect_discovery_document: The OpenID connect discovery document.
        :param pulumi.Input[str] primary_rsa_token_key_exponent: The RSA parameter exponent.
        :param pulumi.Input[str] primary_rsa_token_key_modulus: The RSA parameter modulus.
        :param pulumi.Input[str] primary_symmetric_token_key: The key value of the key. Specifies a symmetric key for token validation.
        :param pulumi.Input[str] primary_x509_token_key_raw: The raw data field of a certificate in PKCS 12 format (X509Certificate2 in .NET). Specifies a certificate for token validation.
        :param pulumi.Input[Sequence[pulumi.Input['ContentKeyPolicyPolicyOptionTokenRestrictionRequiredClaimArgs']]] required_claims: One or more `required_claim` blocks as defined above.
        :param pulumi.Input[str] token_type: The type of token. Supported values are `Jwt` or `Swt`.
               
               > **NOTE:** Each token_restriction can only have one type of primary verification key: if you want to use RSA you must provide `primary_rsa_token_key_exponent` and `primary_rsa_token_key_modulus`, if you want to use symmetric you need to provide `primary_symmetric_token_key` and for x509 you must provide `primary_x509_token_key_raw`. For more information about Token access please refer to <https://docs.microsoft.com/azure/media-services/latest/content-protection-overview#controlling-content-access>
        """
        if alternate_keys is not None:
            pulumi.set(__self__, "alternate_keys", alternate_keys)
        if audience is not None:
            pulumi.set(__self__, "audience", audience)
        if issuer is not None:
            pulumi.set(__self__, "issuer", issuer)
        if open_id_connect_discovery_document is not None:
            pulumi.set(__self__, "open_id_connect_discovery_document", open_id_connect_discovery_document)
        if primary_rsa_token_key_exponent is not None:
            pulumi.set(__self__, "primary_rsa_token_key_exponent", primary_rsa_token_key_exponent)
        if primary_rsa_token_key_modulus is not None:
            pulumi.set(__self__, "primary_rsa_token_key_modulus", primary_rsa_token_key_modulus)
        if primary_symmetric_token_key is not None:
            pulumi.set(__self__, "primary_symmetric_token_key", primary_symmetric_token_key)
        if primary_x509_token_key_raw is not None:
            pulumi.set(__self__, "primary_x509_token_key_raw", primary_x509_token_key_raw)
        if required_claims is not None:
            pulumi.set(__self__, "required_claims", required_claims)
        if token_type is not None:
            pulumi.set(__self__, "token_type", token_type)

    @property
    @pulumi.getter(name="alternateKeys")
    def alternate_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContentKeyPolicyPolicyOptionTokenRestrictionAlternateKeyArgs']]]]:
        """
        One or more `alternate_key` block as defined above.
        """
        return pulumi.get(self, "alternate_keys")

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

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

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

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

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

    @property
    @pulumi.getter(name="openIdConnectDiscoveryDocument")
    def open_id_connect_discovery_document(self) -> Optional[pulumi.Input[str]]:
        """
        The OpenID connect discovery document.
        """
        return pulumi.get(self, "open_id_connect_discovery_document")

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

    @property
    @pulumi.getter(name="primaryRsaTokenKeyExponent")
    def primary_rsa_token_key_exponent(self) -> Optional[pulumi.Input[str]]:
        """
        The RSA parameter exponent.
        """
        return pulumi.get(self, "primary_rsa_token_key_exponent")

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

    @property
    @pulumi.getter(name="primaryRsaTokenKeyModulus")
    def primary_rsa_token_key_modulus(self) -> Optional[pulumi.Input[str]]:
        """
        The RSA parameter modulus.
        """
        return pulumi.get(self, "primary_rsa_token_key_modulus")

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

    @property
    @pulumi.getter(name="primarySymmetricTokenKey")
    def primary_symmetric_token_key(self) -> Optional[pulumi.Input[str]]:
        """
        The key value of the key. Specifies a symmetric key for token validation.
        """
        return pulumi.get(self, "primary_symmetric_token_key")

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

    @property
    @pulumi.getter(name="primaryX509TokenKeyRaw")
    def primary_x509_token_key_raw(self) -> Optional[pulumi.Input[str]]:
        """
        The raw data field of a certificate in PKCS 12 format (X509Certificate2 in .NET). Specifies a certificate for token validation.
        """
        return pulumi.get(self, "primary_x509_token_key_raw")

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

    @property
    @pulumi.getter(name="requiredClaims")
    def required_claims(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContentKeyPolicyPolicyOptionTokenRestrictionRequiredClaimArgs']]]]:
        """
        One or more `required_claim` blocks as defined above.
        """
        return pulumi.get(self, "required_claims")

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

    @property
    @pulumi.getter(name="tokenType")
    def token_type(self) -> Optional[pulumi.Input[str]]:
        """
        The type of token. Supported values are `Jwt` or `Swt`.

        > **NOTE:** Each token_restriction can only have one type of primary verification key: if you want to use RSA you must provide `primary_rsa_token_key_exponent` and `primary_rsa_token_key_modulus`, if you want to use symmetric you need to provide `primary_symmetric_token_key` and for x509 you must provide `primary_x509_token_key_raw`. For more information about Token access please refer to <https://docs.microsoft.com/azure/media-services/latest/content-protection-overview#controlling-content-access>
        """
        return pulumi.get(self, "token_type")

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


@pulumi.input_type
class ContentKeyPolicyPolicyOptionTokenRestrictionAlternateKeyArgs:
    def __init__(__self__, *,
                 rsa_token_key_exponent: Optional[pulumi.Input[str]] = None,
                 rsa_token_key_modulus: Optional[pulumi.Input[str]] = None,
                 symmetric_token_key: Optional[pulumi.Input[str]] = None,
                 x509_token_key_raw: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] rsa_token_key_exponent: The RSA parameter exponent.
        :param pulumi.Input[str] rsa_token_key_modulus: The RSA parameter modulus.
        :param pulumi.Input[str] symmetric_token_key: The key value of the key. Specifies a symmetric key for token validation.
        :param pulumi.Input[str] x509_token_key_raw: The raw data field of a certificate in PKCS 12 format (X509Certificate2 in .NET). Specifies a certificate for token validation.
               
               > **NOTE:** Each `alternate_key` block can only have one type of primary verification key: if you want to use RSA you must provide `rsa_token_key_exponent` and `rsa_token_key_modulus`, if you want to use symmetric you need to provide `symmetric_token_key` and for x509 you must provide `x509_token_key_raw`.
        """
        if rsa_token_key_exponent is not None:
            pulumi.set(__self__, "rsa_token_key_exponent", rsa_token_key_exponent)
        if rsa_token_key_modulus is not None:
            pulumi.set(__self__, "rsa_token_key_modulus", rsa_token_key_modulus)
        if symmetric_token_key is not None:
            pulumi.set(__self__, "symmetric_token_key", symmetric_token_key)
        if x509_token_key_raw is not None:
            pulumi.set(__self__, "x509_token_key_raw", x509_token_key_raw)

    @property
    @pulumi.getter(name="rsaTokenKeyExponent")
    def rsa_token_key_exponent(self) -> Optional[pulumi.Input[str]]:
        """
        The RSA parameter exponent.
        """
        return pulumi.get(self, "rsa_token_key_exponent")

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

    @property
    @pulumi.getter(name="rsaTokenKeyModulus")
    def rsa_token_key_modulus(self) -> Optional[pulumi.Input[str]]:
        """
        The RSA parameter modulus.
        """
        return pulumi.get(self, "rsa_token_key_modulus")

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

    @property
    @pulumi.getter(name="symmetricTokenKey")
    def symmetric_token_key(self) -> Optional[pulumi.Input[str]]:
        """
        The key value of the key. Specifies a symmetric key for token validation.
        """
        return pulumi.get(self, "symmetric_token_key")

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

    @property
    @pulumi.getter(name="x509TokenKeyRaw")
    def x509_token_key_raw(self) -> Optional[pulumi.Input[str]]:
        """
        The raw data field of a certificate in PKCS 12 format (X509Certificate2 in .NET). Specifies a certificate for token validation.

        > **NOTE:** Each `alternate_key` block can only have one type of primary verification key: if you want to use RSA you must provide `rsa_token_key_exponent` and `rsa_token_key_modulus`, if you want to use symmetric you need to provide `symmetric_token_key` and for x509 you must provide `x509_token_key_raw`.
        """
        return pulumi.get(self, "x509_token_key_raw")

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


@pulumi.input_type
class ContentKeyPolicyPolicyOptionTokenRestrictionRequiredClaimArgs:
    def __init__(__self__, *,
                 type: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] type: Token claim type.
        :param pulumi.Input[str] value: Token claim value.
        """
        if type is not None:
            pulumi.set(__self__, "type", type)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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


@pulumi.input_type
class JobInputAssetArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 label: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The name of the input Asset. Changing this forces a new Media Job to be created.
        :param pulumi.Input[str] label: A label that is assigned to a JobInputClip, that is used to satisfy a reference used in the Transform. For example, a Transform can be authored so as to take an image file with the label 'xyz' and apply it as an overlay onto the input video before it is encoded. When submitting a Job, exactly one of the JobInputs should be the image file, and it should have the label 'xyz'. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "name", name)
        if label is not None:
            pulumi.set(__self__, "label", label)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the input Asset. Changing this forces a new Media Job to be created.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        A label that is assigned to a JobInputClip, that is used to satisfy a reference used in the Transform. For example, a Transform can be authored so as to take an image file with the label 'xyz' and apply it as an overlay onto the input video before it is encoded. When submitting a Job, exactly one of the JobInputs should be the image file, and it should have the label 'xyz'. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "label")

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


@pulumi.input_type
class JobOutputAssetArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 label: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The name of the output Asset. Changing this forces a new Media Job to be created.
        :param pulumi.Input[str] label: A label that is assigned to a JobOutput in order to help uniquely identify it. This is useful when your Transform has more than one TransformOutput, whereby your Job has more than one JobOutput. In such cases, when you submit the Job, you will add two or more JobOutputs, in the same order as TransformOutputs in the Transform. Subsequently, when you retrieve the Job, either through events or on a GET request, you can use the label to easily identify the JobOutput. If a label is not provided, a default value of '{presetName}_{outputIndex}' will be used, where the preset name is the name of the preset in the corresponding TransformOutput and the output index is the relative index of the this JobOutput within the Job. Note that this index is the same as the relative index of the corresponding TransformOutput within its Transform. Changing this forces a new resource to be created.
        """
        pulumi.set(__self__, "name", name)
        if label is not None:
            pulumi.set(__self__, "label", label)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the output Asset. Changing this forces a new Media Job to be created.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        A label that is assigned to a JobOutput in order to help uniquely identify it. This is useful when your Transform has more than one TransformOutput, whereby your Job has more than one JobOutput. In such cases, when you submit the Job, you will add two or more JobOutputs, in the same order as TransformOutputs in the Transform. Subsequently, when you retrieve the Job, either through events or on a GET request, you can use the label to easily identify the JobOutput. If a label is not provided, a default value of '{presetName}_{outputIndex}' will be used, where the preset name is the name of the preset in the corresponding TransformOutput and the output index is the relative index of the this JobOutput within the Job. Note that this index is the same as the relative index of the corresponding TransformOutput within its Transform. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "label")

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


@pulumi.input_type
class LiveEventCrossSiteAccessPolicyArgs:
    def __init__(__self__, *,
                 client_access_policy: Optional[pulumi.Input[str]] = None,
                 cross_domain_policy: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] client_access_policy: The content of clientaccesspolicy.xml used by Silverlight.
        :param pulumi.Input[str] cross_domain_policy: The content of the Cross Domain Policy (`crossdomain.xml`).
        """
        if client_access_policy is not None:
            pulumi.set(__self__, "client_access_policy", client_access_policy)
        if cross_domain_policy is not None:
            pulumi.set(__self__, "cross_domain_policy", cross_domain_policy)

    @property
    @pulumi.getter(name="clientAccessPolicy")
    def client_access_policy(self) -> Optional[pulumi.Input[str]]:
        """
        The content of clientaccesspolicy.xml used by Silverlight.
        """
        return pulumi.get(self, "client_access_policy")

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

    @property
    @pulumi.getter(name="crossDomainPolicy")
    def cross_domain_policy(self) -> Optional[pulumi.Input[str]]:
        """
        The content of the Cross Domain Policy (`crossdomain.xml`).
        """
        return pulumi.get(self, "cross_domain_policy")

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


@pulumi.input_type
class LiveEventEncodingArgs:
    def __init__(__self__, *,
                 key_frame_interval: Optional[pulumi.Input[str]] = None,
                 preset_name: Optional[pulumi.Input[str]] = None,
                 stretch_mode: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] key_frame_interval: Use an `ISO 8601` time value between 0.5 to 20 seconds to specify the output fragment length for the video and audio tracks of an encoding live event. For example, use `PT2S` to indicate 2 seconds. For the video track it also defines the key frame interval, or the length of a GoP (group of pictures). The value cannot be set for pass-through live events. Defaults to `PT2S`.
        :param pulumi.Input[str] preset_name: The optional encoding preset name, used when `type` is not `None`. If the `type` is set to `Standard`, then the default preset name is `Default720p`. Else if the `type` is set to `Premium1080p`, Changing this forces a new resource to be created.
        :param pulumi.Input[str] stretch_mode: Specifies how the input video will be resized to fit the desired output resolution(s). Allowed values are `None`, `AutoFit` or `AutoSize`. Default is `None`.
        :param pulumi.Input[str] type: Live event type. Possible values are `None`, `Premium1080p`, `PassthroughBasic`, `PassthroughStandard` and `Standard`. When set to `None`, the service simply passes through the incoming video and audio layer(s) to the output. When `type` is set to `Standard` or `Premium1080p`, a live encoder transcodes the incoming stream into multiple bitrates or layers. Defaults to `None`. Changing this forces a new resource to be created.
               
               > [More information can be found in the Microsoft Documentation](https://go.microsoft.com/fwlink/?linkid=2095101).
        """
        if key_frame_interval is not None:
            pulumi.set(__self__, "key_frame_interval", key_frame_interval)
        if preset_name is not None:
            pulumi.set(__self__, "preset_name", preset_name)
        if stretch_mode is not None:
            pulumi.set(__self__, "stretch_mode", stretch_mode)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="keyFrameInterval")
    def key_frame_interval(self) -> Optional[pulumi.Input[str]]:
        """
        Use an `ISO 8601` time value between 0.5 to 20 seconds to specify the output fragment length for the video and audio tracks of an encoding live event. For example, use `PT2S` to indicate 2 seconds. For the video track it also defines the key frame interval, or the length of a GoP (group of pictures). The value cannot be set for pass-through live events. Defaults to `PT2S`.
        """
        return pulumi.get(self, "key_frame_interval")

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

    @property
    @pulumi.getter(name="presetName")
    def preset_name(self) -> Optional[pulumi.Input[str]]:
        """
        The optional encoding preset name, used when `type` is not `None`. If the `type` is set to `Standard`, then the default preset name is `Default720p`. Else if the `type` is set to `Premium1080p`, Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "preset_name")

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

    @property
    @pulumi.getter(name="stretchMode")
    def stretch_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies how the input video will be resized to fit the desired output resolution(s). Allowed values are `None`, `AutoFit` or `AutoSize`. Default is `None`.
        """
        return pulumi.get(self, "stretch_mode")

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Live event type. Possible values are `None`, `Premium1080p`, `PassthroughBasic`, `PassthroughStandard` and `Standard`. When set to `None`, the service simply passes through the incoming video and audio layer(s) to the output. When `type` is set to `Standard` or `Premium1080p`, a live encoder transcodes the incoming stream into multiple bitrates or layers. Defaults to `None`. Changing this forces a new resource to be created.

        > [More information can be found in the Microsoft Documentation](https://go.microsoft.com/fwlink/?linkid=2095101).
        """
        return pulumi.get(self, "type")

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


@pulumi.input_type
class LiveEventInputArgs:
    def __init__(__self__, *,
                 access_token: Optional[pulumi.Input[str]] = None,
                 endpoints: Optional[pulumi.Input[Sequence[pulumi.Input['LiveEventInputEndpointArgs']]]] = None,
                 ip_access_control_allows: Optional[pulumi.Input[Sequence[pulumi.Input['LiveEventInputIpAccessControlAllowArgs']]]] = None,
                 key_frame_interval_duration: Optional[pulumi.Input[str]] = None,
                 streaming_protocol: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] access_token: A UUID in string form to uniquely identify the stream. If omitted, the service will generate a unique value. Changing this forces a new value to be created.
        :param pulumi.Input[Sequence[pulumi.Input['LiveEventInputIpAccessControlAllowArgs']]] ip_access_control_allows: One or more `ip_access_control_allow` blocks as defined below.
        :param pulumi.Input[str] key_frame_interval_duration: ISO 8601 time duration of the key frame interval duration of the input. This value sets the `EXT-X-TARGETDURATION` property in the HLS output. For example, use PT2S to indicate 2 seconds. This field cannot be set when `type` is set to `Encoding`.
        :param pulumi.Input[str] streaming_protocol: The input protocol for the live event. Allowed values are `FragmentedMP4` and `RTMP`. Changing this forces a new resource to be created.
        """
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if endpoints is not None:
            pulumi.set(__self__, "endpoints", endpoints)
        if ip_access_control_allows is not None:
            pulumi.set(__self__, "ip_access_control_allows", ip_access_control_allows)
        if key_frame_interval_duration is not None:
            pulumi.set(__self__, "key_frame_interval_duration", key_frame_interval_duration)
        if streaming_protocol is not None:
            pulumi.set(__self__, "streaming_protocol", streaming_protocol)

    @property
    @pulumi.getter(name="accessToken")
    def access_token(self) -> Optional[pulumi.Input[str]]:
        """
        A UUID in string form to uniquely identify the stream. If omitted, the service will generate a unique value. Changing this forces a new value to be created.
        """
        return pulumi.get(self, "access_token")

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

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

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

    @property
    @pulumi.getter(name="ipAccessControlAllows")
    def ip_access_control_allows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LiveEventInputIpAccessControlAllowArgs']]]]:
        """
        One or more `ip_access_control_allow` blocks as defined below.
        """
        return pulumi.get(self, "ip_access_control_allows")

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

    @property
    @pulumi.getter(name="keyFrameIntervalDuration")
    def key_frame_interval_duration(self) -> Optional[pulumi.Input[str]]:
        """
        ISO 8601 time duration of the key frame interval duration of the input. This value sets the `EXT-X-TARGETDURATION` property in the HLS output. For example, use PT2S to indicate 2 seconds. This field cannot be set when `type` is set to `Encoding`.
        """
        return pulumi.get(self, "key_frame_interval_duration")

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

    @property
    @pulumi.getter(name="streamingProtocol")
    def streaming_protocol(self) -> Optional[pulumi.Input[str]]:
        """
        The input protocol for the live event. Allowed values are `FragmentedMP4` and `RTMP`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "streaming_protocol")

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


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

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

    @protocol.setter
    def protocol(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "protocol", 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)


@pulumi.input_type
class LiveEventInputIpAccessControlAllowArgs:
    def __init__(__self__, *,
                 address: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 subnet_prefix_length: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] address: The IP address or CIDR range.
        :param pulumi.Input[str] name: The friendly name for the IP address range.
        :param pulumi.Input[int] subnet_prefix_length: The subnet mask prefix length (see CIDR notation).
        """
        if address is not None:
            pulumi.set(__self__, "address", address)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if subnet_prefix_length is not None:
            pulumi.set(__self__, "subnet_prefix_length", subnet_prefix_length)

    @property
    @pulumi.getter
    def address(self) -> Optional[pulumi.Input[str]]:
        """
        The IP address or CIDR range.
        """
        return pulumi.get(self, "address")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        The friendly name for the IP address range.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="subnetPrefixLength")
    def subnet_prefix_length(self) -> Optional[pulumi.Input[int]]:
        """
        The subnet mask prefix length (see CIDR notation).
        """
        return pulumi.get(self, "subnet_prefix_length")

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


@pulumi.input_type
class LiveEventPreviewArgs:
    def __init__(__self__, *,
                 alternative_media_id: Optional[pulumi.Input[str]] = None,
                 endpoints: Optional[pulumi.Input[Sequence[pulumi.Input['LiveEventPreviewEndpointArgs']]]] = None,
                 ip_access_control_allows: Optional[pulumi.Input[Sequence[pulumi.Input['LiveEventPreviewIpAccessControlAllowArgs']]]] = None,
                 preview_locator: Optional[pulumi.Input[str]] = None,
                 streaming_policy_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] alternative_media_id: An alternative media identifier associated with the streaming locator created for the preview. The identifier can be used in the `CustomLicenseAcquisitionUrlTemplate` or the `CustomKeyAcquisitionUrlTemplate` of the Streaming Policy specified in the `streaming_policy_name` field.
        :param pulumi.Input[Sequence[pulumi.Input['LiveEventPreviewIpAccessControlAllowArgs']]] ip_access_control_allows: One or more `ip_access_control_allow` blocks as defined above.
        :param pulumi.Input[str] preview_locator: The identifier of the preview locator in GUID format. Specifying this at creation time allows the caller to know the preview locator url before the event is created. If omitted, the service will generate a random identifier. Changing this forces a new resource to be created.
        :param pulumi.Input[str] streaming_policy_name: The name of streaming policy used for the live event preview. Changing this forces a new resource to be created.
        """
        if alternative_media_id is not None:
            pulumi.set(__self__, "alternative_media_id", alternative_media_id)
        if endpoints is not None:
            pulumi.set(__self__, "endpoints", endpoints)
        if ip_access_control_allows is not None:
            pulumi.set(__self__, "ip_access_control_allows", ip_access_control_allows)
        if preview_locator is not None:
            pulumi.set(__self__, "preview_locator", preview_locator)
        if streaming_policy_name is not None:
            pulumi.set(__self__, "streaming_policy_name", streaming_policy_name)

    @property
    @pulumi.getter(name="alternativeMediaId")
    def alternative_media_id(self) -> Optional[pulumi.Input[str]]:
        """
        An alternative media identifier associated with the streaming locator created for the preview. The identifier can be used in the `CustomLicenseAcquisitionUrlTemplate` or the `CustomKeyAcquisitionUrlTemplate` of the Streaming Policy specified in the `streaming_policy_name` field.
        """
        return pulumi.get(self, "alternative_media_id")

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

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

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

    @property
    @pulumi.getter(name="ipAccessControlAllows")
    def ip_access_control_allows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LiveEventPreviewIpAccessControlAllowArgs']]]]:
        """
        One or more `ip_access_control_allow` blocks as defined above.
        """
        return pulumi.get(self, "ip_access_control_allows")

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

    @property
    @pulumi.getter(name="previewLocator")
    def preview_locator(self) -> Optional[pulumi.Input[str]]:
        """
        The identifier of the preview locator in GUID format. Specifying this at creation time allows the caller to know the preview locator url before the event is created. If omitted, the service will generate a random identifier. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "preview_locator")

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

    @property
    @pulumi.getter(name="streamingPolicyName")
    def streaming_policy_name(self) -> Optional[pulumi.Input[str]]:
        """
        The name of streaming policy used for the live event preview. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "streaming_policy_name")

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


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

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

    @protocol.setter
    def protocol(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "protocol", 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)


@pulumi.input_type
class LiveEventPreviewIpAccessControlAllowArgs:
    def __init__(__self__, *,
                 address: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 subnet_prefix_length: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] address: The IP address or CIDR range.
        :param pulumi.Input[str] name: The friendly name for the IP address range.
        :param pulumi.Input[int] subnet_prefix_length: The subnet mask prefix length (see CIDR notation).
        """
        if address is not None:
            pulumi.set(__self__, "address", address)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if subnet_prefix_length is not None:
            pulumi.set(__self__, "subnet_prefix_length", subnet_prefix_length)

    @property
    @pulumi.getter
    def address(self) -> Optional[pulumi.Input[str]]:
        """
        The IP address or CIDR range.
        """
        return pulumi.get(self, "address")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        The friendly name for the IP address range.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="subnetPrefixLength")
    def subnet_prefix_length(self) -> Optional[pulumi.Input[int]]:
        """
        The subnet mask prefix length (see CIDR notation).
        """
        return pulumi.get(self, "subnet_prefix_length")

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


@pulumi.input_type
class ServiceAccountEncryptionArgs:
    def __init__(__self__, *,
                 current_key_identifier: Optional[pulumi.Input[str]] = None,
                 key_vault_key_identifier: Optional[pulumi.Input[str]] = None,
                 managed_identity: Optional[pulumi.Input['ServiceAccountEncryptionManagedIdentityArgs']] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] current_key_identifier: The current key used to encrypt the Media Services Account, including the key version.
        :param pulumi.Input[str] key_vault_key_identifier: Specifies the URI of the Key Vault Key used to encrypt data. The key may either be versioned (for example https://vault/keys/mykey/version1) or reference a key without a version (for example https://vault/keys/mykey).
        :param pulumi.Input['ServiceAccountEncryptionManagedIdentityArgs'] managed_identity: A `managed_identity` block as defined below.
        :param pulumi.Input[str] type: Specifies the type of key used to encrypt the account data. Possible values are `SystemKey` and `CustomerKey`. Defaults to `SystemKey`.
        """
        if current_key_identifier is not None:
            pulumi.set(__self__, "current_key_identifier", current_key_identifier)
        if key_vault_key_identifier is not None:
            pulumi.set(__self__, "key_vault_key_identifier", key_vault_key_identifier)
        if managed_identity is not None:
            pulumi.set(__self__, "managed_identity", managed_identity)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter(name="currentKeyIdentifier")
    def current_key_identifier(self) -> Optional[pulumi.Input[str]]:
        """
        The current key used to encrypt the Media Services Account, including the key version.
        """
        return pulumi.get(self, "current_key_identifier")

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

    @property
    @pulumi.getter(name="keyVaultKeyIdentifier")
    def key_vault_key_identifier(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the URI of the Key Vault Key used to encrypt data. The key may either be versioned (for example https://vault/keys/mykey/version1) or reference a key without a version (for example https://vault/keys/mykey).
        """
        return pulumi.get(self, "key_vault_key_identifier")

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

    @property
    @pulumi.getter(name="managedIdentity")
    def managed_identity(self) -> Optional[pulumi.Input['ServiceAccountEncryptionManagedIdentityArgs']]:
        """
        A `managed_identity` block as defined below.
        """
        return pulumi.get(self, "managed_identity")

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the type of key used to encrypt the account data. Possible values are `SystemKey` and `CustomerKey`. Defaults to `SystemKey`.
        """
        return pulumi.get(self, "type")

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


@pulumi.input_type
class ServiceAccountEncryptionManagedIdentityArgs:
    def __init__(__self__, *,
                 use_system_assigned_identity: Optional[pulumi.Input[bool]] = None,
                 user_assigned_identity_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] use_system_assigned_identity: Whether to use System Assigned Identity. Possible Values are `true` and `false`.
        :param pulumi.Input[str] user_assigned_identity_id: The ID of the User Assigned Identity. This value can only be set when `use_system_assigned_identity` is `false`
        """
        if use_system_assigned_identity is not None:
            pulumi.set(__self__, "use_system_assigned_identity", use_system_assigned_identity)
        if user_assigned_identity_id is not None:
            pulumi.set(__self__, "user_assigned_identity_id", user_assigned_identity_id)

    @property
    @pulumi.getter(name="useSystemAssignedIdentity")
    def use_system_assigned_identity(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to use System Assigned Identity. Possible Values are `true` and `false`.
        """
        return pulumi.get(self, "use_system_assigned_identity")

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

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the User Assigned Identity. This value can only be set when `use_system_assigned_identity` is `false`
        """
        return pulumi.get(self, "user_assigned_identity_id")

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


@pulumi.input_type
class ServiceAccountIdentityArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 identity_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 principal_id: Optional[pulumi.Input[str]] = None,
                 tenant_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] type: Specifies the type of Managed Service Identity that should be configured on this Media Services Account. Possible values are `SystemAssigned`, `UserAssigned`, `SystemAssigned, UserAssigned` (to enable both).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] identity_ids: Specifies a list of User Assigned Managed Identity IDs to be assigned to this Media Services Account.
        :param pulumi.Input[str] principal_id: The Principal ID associated with this Managed Service Identity.
        :param pulumi.Input[str] tenant_id: The Tenant ID associated with this Managed Service Identity.
        """
        pulumi.set(__self__, "type", type)
        if identity_ids is not None:
            pulumi.set(__self__, "identity_ids", identity_ids)
        if principal_id is not None:
            pulumi.set(__self__, "principal_id", principal_id)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        Specifies the type of Managed Service Identity that should be configured on this Media Services Account. Possible values are `SystemAssigned`, `UserAssigned`, `SystemAssigned, UserAssigned` (to enable both).
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter(name="identityIds")
    def identity_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Specifies a list of User Assigned Managed Identity IDs to be assigned to this Media Services Account.
        """
        return pulumi.get(self, "identity_ids")

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

    @property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> Optional[pulumi.Input[str]]:
        """
        The Principal ID associated with this Managed Service Identity.
        """
        return pulumi.get(self, "principal_id")

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

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[pulumi.Input[str]]:
        """
        The Tenant ID associated with this Managed Service Identity.
        """
        return pulumi.get(self, "tenant_id")

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


@pulumi.input_type
class ServiceAccountKeyDeliveryAccessControlArgs:
    def __init__(__self__, *,
                 default_action: Optional[pulumi.Input[str]] = None,
                 ip_allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] default_action: The Default Action to use when no rules match from `ip_allow_list`. Possible values are `Allow` and `Deny`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_allow_lists: One or more IP Addresses, or CIDR Blocks which should be able to access the Key Delivery.
        """
        if default_action is not None:
            pulumi.set(__self__, "default_action", default_action)
        if ip_allow_lists is not None:
            pulumi.set(__self__, "ip_allow_lists", ip_allow_lists)

    @property
    @pulumi.getter(name="defaultAction")
    def default_action(self) -> Optional[pulumi.Input[str]]:
        """
        The Default Action to use when no rules match from `ip_allow_list`. Possible values are `Allow` and `Deny`.
        """
        return pulumi.get(self, "default_action")

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

    @property
    @pulumi.getter(name="ipAllowLists")
    def ip_allow_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        One or more IP Addresses, or CIDR Blocks which should be able to access the Key Delivery.
        """
        return pulumi.get(self, "ip_allow_lists")

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


@pulumi.input_type
class ServiceAccountStorageAccountArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 is_primary: Optional[pulumi.Input[bool]] = None,
                 managed_identity: Optional[pulumi.Input['ServiceAccountStorageAccountManagedIdentityArgs']] = None):
        """
        :param pulumi.Input[str] id: Specifies the ID of the Storage Account that will be associated with the Media Services instance.
        :param pulumi.Input[bool] is_primary: Specifies whether the storage account should be the primary account or not. Defaults to `false`.
               
               > **NOTE:** Whilst multiple `storage_account` blocks can be specified - one of them must be set to the primary
        :param pulumi.Input['ServiceAccountStorageAccountManagedIdentityArgs'] managed_identity: A `managed_identity` block as defined below.
        """
        pulumi.set(__self__, "id", id)
        if is_primary is not None:
            pulumi.set(__self__, "is_primary", is_primary)
        if managed_identity is not None:
            pulumi.set(__self__, "managed_identity", managed_identity)

    @property
    @pulumi.getter
    def id(self) -> pulumi.Input[str]:
        """
        Specifies the ID of the Storage Account that will be associated with the Media Services instance.
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter(name="isPrimary")
    def is_primary(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies whether the storage account should be the primary account or not. Defaults to `false`.

        > **NOTE:** Whilst multiple `storage_account` blocks can be specified - one of them must be set to the primary
        """
        return pulumi.get(self, "is_primary")

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

    @property
    @pulumi.getter(name="managedIdentity")
    def managed_identity(self) -> Optional[pulumi.Input['ServiceAccountStorageAccountManagedIdentityArgs']]:
        """
        A `managed_identity` block as defined below.
        """
        return pulumi.get(self, "managed_identity")

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


@pulumi.input_type
class ServiceAccountStorageAccountManagedIdentityArgs:
    def __init__(__self__, *,
                 use_system_assigned_identity: Optional[pulumi.Input[bool]] = None,
                 user_assigned_identity_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] use_system_assigned_identity: Whether to use System Assigned Identity. Possible Values are `true` and `false`.
        :param pulumi.Input[str] user_assigned_identity_id: The ID of the User Assigned Identity. This value can only be set when `use_system_assigned_identity` is `false`
        """
        if use_system_assigned_identity is not None:
            pulumi.set(__self__, "use_system_assigned_identity", use_system_assigned_identity)
        if user_assigned_identity_id is not None:
            pulumi.set(__self__, "user_assigned_identity_id", user_assigned_identity_id)

    @property
    @pulumi.getter(name="useSystemAssignedIdentity")
    def use_system_assigned_identity(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to use System Assigned Identity. Possible Values are `true` and `false`.
        """
        return pulumi.get(self, "use_system_assigned_identity")

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

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the User Assigned Identity. This value can only be set when `use_system_assigned_identity` is `false`
        """
        return pulumi.get(self, "user_assigned_identity_id")

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


@pulumi.input_type
class StreamingEndpointAccessControlArgs:
    def __init__(__self__, *,
                 akamai_signature_header_authentication_keys: Optional[pulumi.Input[Sequence[pulumi.Input['StreamingEndpointAccessControlAkamaiSignatureHeaderAuthenticationKeyArgs']]]] = None,
                 ip_allows: Optional[pulumi.Input[Sequence[pulumi.Input['StreamingEndpointAccessControlIpAllowArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['StreamingEndpointAccessControlAkamaiSignatureHeaderAuthenticationKeyArgs']]] akamai_signature_header_authentication_keys: One or more `akamai_signature_header_authentication_key` blocks as defined below.
        :param pulumi.Input[Sequence[pulumi.Input['StreamingEndpointAccessControlIpAllowArgs']]] ip_allows: A `ip_allow` block as defined below.
        """
        if akamai_signature_header_authentication_keys is not None:
            pulumi.set(__self__, "akamai_signature_header_authentication_keys", akamai_signature_header_authentication_keys)
        if ip_allows is not None:
            pulumi.set(__self__, "ip_allows", ip_allows)

    @property
    @pulumi.getter(name="akamaiSignatureHeaderAuthenticationKeys")
    def akamai_signature_header_authentication_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamingEndpointAccessControlAkamaiSignatureHeaderAuthenticationKeyArgs']]]]:
        """
        One or more `akamai_signature_header_authentication_key` blocks as defined below.
        """
        return pulumi.get(self, "akamai_signature_header_authentication_keys")

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

    @property
    @pulumi.getter(name="ipAllows")
    def ip_allows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamingEndpointAccessControlIpAllowArgs']]]]:
        """
        A `ip_allow` block as defined below.
        """
        return pulumi.get(self, "ip_allows")

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


@pulumi.input_type
class StreamingEndpointAccessControlAkamaiSignatureHeaderAuthenticationKeyArgs:
    def __init__(__self__, *,
                 base64_key: Optional[pulumi.Input[str]] = None,
                 expiration: Optional[pulumi.Input[str]] = None,
                 identifier: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] base64_key: Authentication key.
        :param pulumi.Input[str] expiration: The expiration time of the authentication key.
        :param pulumi.Input[str] identifier: Identifier of the key.
        """
        if base64_key is not None:
            pulumi.set(__self__, "base64_key", base64_key)
        if expiration is not None:
            pulumi.set(__self__, "expiration", expiration)
        if identifier is not None:
            pulumi.set(__self__, "identifier", identifier)

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

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

    @property
    @pulumi.getter
    def expiration(self) -> Optional[pulumi.Input[str]]:
        """
        The expiration time of the authentication key.
        """
        return pulumi.get(self, "expiration")

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

    @property
    @pulumi.getter
    def identifier(self) -> Optional[pulumi.Input[str]]:
        """
        Identifier of the key.
        """
        return pulumi.get(self, "identifier")

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


@pulumi.input_type
class StreamingEndpointAccessControlIpAllowArgs:
    def __init__(__self__, *,
                 address: Optional[pulumi.Input[str]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 subnet_prefix_length: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] address: The IP address to allow.
        :param pulumi.Input[str] name: The friendly name for the IP address range.
        :param pulumi.Input[int] subnet_prefix_length: The subnet mask prefix length (see CIDR notation).
        """
        if address is not None:
            pulumi.set(__self__, "address", address)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if subnet_prefix_length is not None:
            pulumi.set(__self__, "subnet_prefix_length", subnet_prefix_length)

    @property
    @pulumi.getter
    def address(self) -> Optional[pulumi.Input[str]]:
        """
        The IP address to allow.
        """
        return pulumi.get(self, "address")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        The friendly name for the IP address range.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="subnetPrefixLength")
    def subnet_prefix_length(self) -> Optional[pulumi.Input[int]]:
        """
        The subnet mask prefix length (see CIDR notation).
        """
        return pulumi.get(self, "subnet_prefix_length")

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


@pulumi.input_type
class StreamingEndpointCrossSiteAccessPolicyArgs:
    def __init__(__self__, *,
                 client_access_policy: Optional[pulumi.Input[str]] = None,
                 cross_domain_policy: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] client_access_policy: The content of `clientaccesspolicy.xml` used by Silverlight.
        :param pulumi.Input[str] cross_domain_policy: The content of `crossdomain.xml` used by Silverlight.
        """
        if client_access_policy is not None:
            pulumi.set(__self__, "client_access_policy", client_access_policy)
        if cross_domain_policy is not None:
            pulumi.set(__self__, "cross_domain_policy", cross_domain_policy)

    @property
    @pulumi.getter(name="clientAccessPolicy")
    def client_access_policy(self) -> Optional[pulumi.Input[str]]:
        """
        The content of `clientaccesspolicy.xml` used by Silverlight.
        """
        return pulumi.get(self, "client_access_policy")

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

    @property
    @pulumi.getter(name="crossDomainPolicy")
    def cross_domain_policy(self) -> Optional[pulumi.Input[str]]:
        """
        The content of `crossdomain.xml` used by Silverlight.
        """
        return pulumi.get(self, "cross_domain_policy")

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


@pulumi.input_type
class StreamingEndpointSkusArgs:
    def __init__(__self__, *,
                 capacity: Optional[pulumi.Input[int]] = None,
                 name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] capacity: The sku capacity of Streaming Endpoint.
        :param pulumi.Input[str] name: The name which should be used for this Streaming Endpoint maximum length is `24`. Changing this forces a new Streaming Endpoint to be created.
        """
        if capacity is not None:
            pulumi.set(__self__, "capacity", capacity)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def capacity(self) -> Optional[pulumi.Input[int]]:
        """
        The sku capacity of Streaming Endpoint.
        """
        return pulumi.get(self, "capacity")

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        The name which should be used for this Streaming Endpoint maximum length is `24`. Changing this forces a new Streaming Endpoint to be created.
        """
        return pulumi.get(self, "name")

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


@pulumi.input_type
class StreamingLocatorContentKeyArgs:
    def __init__(__self__, *,
                 content_key_id: Optional[pulumi.Input[str]] = None,
                 label_reference_in_streaming_policy: Optional[pulumi.Input[str]] = None,
                 policy_name: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] content_key_id: ID of Content Key. Changing this forces a new Streaming Locator to be created.
        :param pulumi.Input[str] label_reference_in_streaming_policy: Label of Content Key as specified in the Streaming Policy. Changing this forces a new Streaming Locator to be created.
        :param pulumi.Input[str] policy_name: Content Key Policy used by Content Key. Changing this forces a new Streaming Locator to be created.
        :param pulumi.Input[str] type: Encryption type of Content Key. Supported values are `CommonEncryptionCbcs`, `CommonEncryptionCenc` or `EnvelopeEncryption`. Changing this forces a new Streaming Locator to be created.
        :param pulumi.Input[str] value: Value of Content Key. Changing this forces a new Streaming Locator to be created.
        """
        if content_key_id is not None:
            pulumi.set(__self__, "content_key_id", content_key_id)
        if label_reference_in_streaming_policy is not None:
            pulumi.set(__self__, "label_reference_in_streaming_policy", label_reference_in_streaming_policy)
        if policy_name is not None:
            pulumi.set(__self__, "policy_name", policy_name)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="contentKeyId")
    def content_key_id(self) -> Optional[pulumi.Input[str]]:
        """
        ID of Content Key. Changing this forces a new Streaming Locator to be created.
        """
        return pulumi.get(self, "content_key_id")

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

    @property
    @pulumi.getter(name="labelReferenceInStreamingPolicy")
    def label_reference_in_streaming_policy(self) -> Optional[pulumi.Input[str]]:
        """
        Label of Content Key as specified in the Streaming Policy. Changing this forces a new Streaming Locator to be created.
        """
        return pulumi.get(self, "label_reference_in_streaming_policy")

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

    @property
    @pulumi.getter(name="policyName")
    def policy_name(self) -> Optional[pulumi.Input[str]]:
        """
        Content Key Policy used by Content Key. Changing this forces a new Streaming Locator to be created.
        """
        return pulumi.get(self, "policy_name")

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Encryption type of Content Key. Supported values are `CommonEncryptionCbcs`, `CommonEncryptionCenc` or `EnvelopeEncryption`. Changing this forces a new Streaming Locator to be created.
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        """
        Value of Content Key. Changing this forces a new Streaming Locator to be created.
        """
        return pulumi.get(self, "value")

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCbcsArgs:
    def __init__(__self__, *,
                 clear_key_encryption: Optional[pulumi.Input['StreamingPolicyCommonEncryptionCbcsClearKeyEncryptionArgs']] = None,
                 default_content_key: Optional[pulumi.Input['StreamingPolicyCommonEncryptionCbcsDefaultContentKeyArgs']] = None,
                 drm_fairplay: Optional[pulumi.Input['StreamingPolicyCommonEncryptionCbcsDrmFairplayArgs']] = None,
                 enabled_protocols: Optional[pulumi.Input['StreamingPolicyCommonEncryptionCbcsEnabledProtocolsArgs']] = None):
        """
        :param pulumi.Input['StreamingPolicyCommonEncryptionCbcsClearKeyEncryptionArgs'] clear_key_encryption: A `clear_key_encryption` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input['StreamingPolicyCommonEncryptionCbcsDefaultContentKeyArgs'] default_content_key: A `default_content_key` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input['StreamingPolicyCommonEncryptionCbcsDrmFairplayArgs'] drm_fairplay: A `drm_fairplay` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input['StreamingPolicyCommonEncryptionCbcsEnabledProtocolsArgs'] enabled_protocols: A `enabled_protocols` block as defined below. Changing this forces a new Streaming Policy to be created.
        """
        if clear_key_encryption is not None:
            pulumi.set(__self__, "clear_key_encryption", clear_key_encryption)
        if default_content_key is not None:
            pulumi.set(__self__, "default_content_key", default_content_key)
        if drm_fairplay is not None:
            pulumi.set(__self__, "drm_fairplay", drm_fairplay)
        if enabled_protocols is not None:
            pulumi.set(__self__, "enabled_protocols", enabled_protocols)

    @property
    @pulumi.getter(name="clearKeyEncryption")
    def clear_key_encryption(self) -> Optional[pulumi.Input['StreamingPolicyCommonEncryptionCbcsClearKeyEncryptionArgs']]:
        """
        A `clear_key_encryption` block as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "clear_key_encryption")

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

    @property
    @pulumi.getter(name="defaultContentKey")
    def default_content_key(self) -> Optional[pulumi.Input['StreamingPolicyCommonEncryptionCbcsDefaultContentKeyArgs']]:
        """
        A `default_content_key` block as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "default_content_key")

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

    @property
    @pulumi.getter(name="drmFairplay")
    def drm_fairplay(self) -> Optional[pulumi.Input['StreamingPolicyCommonEncryptionCbcsDrmFairplayArgs']]:
        """
        A `drm_fairplay` block as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "drm_fairplay")

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

    @property
    @pulumi.getter(name="enabledProtocols")
    def enabled_protocols(self) -> Optional[pulumi.Input['StreamingPolicyCommonEncryptionCbcsEnabledProtocolsArgs']]:
        """
        A `enabled_protocols` block as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "enabled_protocols")

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCbcsClearKeyEncryptionArgs:
    def __init__(__self__, *,
                 custom_keys_acquisition_url_template: pulumi.Input[str]):
        """
        :param pulumi.Input[str] custom_keys_acquisition_url_template: The URL template for the custom service that delivers content keys to the end user. This is not required when using Azure Media Services for issuing keys. Changing this forces a new Streaming Policy to be created.
               
               > **Note** Either `clear_key_encryption` or `drm` must be specified.
        """
        pulumi.set(__self__, "custom_keys_acquisition_url_template", custom_keys_acquisition_url_template)

    @property
    @pulumi.getter(name="customKeysAcquisitionUrlTemplate")
    def custom_keys_acquisition_url_template(self) -> pulumi.Input[str]:
        """
        The URL template for the custom service that delivers content keys to the end user. This is not required when using Azure Media Services for issuing keys. Changing this forces a new Streaming Policy to be created.

        > **Note** Either `clear_key_encryption` or `drm` must be specified.
        """
        return pulumi.get(self, "custom_keys_acquisition_url_template")

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCbcsDefaultContentKeyArgs:
    def __init__(__self__, *,
                 label: Optional[pulumi.Input[str]] = None,
                 policy_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] label: Label can be used to specify Content Key when creating a Streaming Locator. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[str] policy_name: Policy used by Default Key. Changing this forces a new Streaming Policy to be created.
        """
        if label is not None:
            pulumi.set(__self__, "label", label)
        if policy_name is not None:
            pulumi.set(__self__, "policy_name", policy_name)

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        Label can be used to specify Content Key when creating a Streaming Locator. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter(name="policyName")
    def policy_name(self) -> Optional[pulumi.Input[str]]:
        """
        Policy used by Default Key. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "policy_name")

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCbcsDrmFairplayArgs:
    def __init__(__self__, *,
                 allow_persistent_license: Optional[pulumi.Input[bool]] = None,
                 custom_license_acquisition_url_template: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] allow_persistent_license: All license to be persistent or not. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[str] custom_license_acquisition_url_template: The URL template for the custom service that delivers licenses to the end user. This is not required when using Azure Media Services for issuing licenses. Changing this forces a new Streaming Policy to be created.
        """
        if allow_persistent_license is not None:
            pulumi.set(__self__, "allow_persistent_license", allow_persistent_license)
        if custom_license_acquisition_url_template is not None:
            pulumi.set(__self__, "custom_license_acquisition_url_template", custom_license_acquisition_url_template)

    @property
    @pulumi.getter(name="allowPersistentLicense")
    def allow_persistent_license(self) -> Optional[pulumi.Input[bool]]:
        """
        All license to be persistent or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "allow_persistent_license")

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

    @property
    @pulumi.getter(name="customLicenseAcquisitionUrlTemplate")
    def custom_license_acquisition_url_template(self) -> Optional[pulumi.Input[str]]:
        """
        The URL template for the custom service that delivers licenses to the end user. This is not required when using Azure Media Services for issuing licenses. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "custom_license_acquisition_url_template")

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCbcsEnabledProtocolsArgs:
    def __init__(__self__, *,
                 dash: Optional[pulumi.Input[bool]] = None,
                 download: Optional[pulumi.Input[bool]] = None,
                 hls: Optional[pulumi.Input[bool]] = None,
                 smooth_streaming: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] dash: Enable DASH protocol or not. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[bool] download: Enable Download protocol or not. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[bool] hls: Enable HLS protocol or not. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[bool] smooth_streaming: Enable SmoothStreaming protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        if dash is not None:
            pulumi.set(__self__, "dash", dash)
        if download is not None:
            pulumi.set(__self__, "download", download)
        if hls is not None:
            pulumi.set(__self__, "hls", hls)
        if smooth_streaming is not None:
            pulumi.set(__self__, "smooth_streaming", smooth_streaming)

    @property
    @pulumi.getter
    def dash(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable DASH protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "dash")

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

    @property
    @pulumi.getter
    def download(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable Download protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "download")

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

    @property
    @pulumi.getter
    def hls(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable HLS protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "hls")

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

    @property
    @pulumi.getter(name="smoothStreaming")
    def smooth_streaming(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable SmoothStreaming protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "smooth_streaming")

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCencArgs:
    def __init__(__self__, *,
                 clear_key_encryption: Optional[pulumi.Input['StreamingPolicyCommonEncryptionCencClearKeyEncryptionArgs']] = None,
                 clear_tracks: Optional[pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencClearTrackArgs']]]] = None,
                 content_key_to_track_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingArgs']]]] = None,
                 default_content_key: Optional[pulumi.Input['StreamingPolicyCommonEncryptionCencDefaultContentKeyArgs']] = None,
                 drm_playready: Optional[pulumi.Input['StreamingPolicyCommonEncryptionCencDrmPlayreadyArgs']] = None,
                 drm_widevine_custom_license_acquisition_url_template: Optional[pulumi.Input[str]] = None,
                 enabled_protocols: Optional[pulumi.Input['StreamingPolicyCommonEncryptionCencEnabledProtocolsArgs']] = None):
        """
        :param pulumi.Input['StreamingPolicyCommonEncryptionCencClearKeyEncryptionArgs'] clear_key_encryption: A `clear_key_encryption` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencClearTrackArgs']]] clear_tracks: One or more `clear_track` blocks as defined below. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingArgs']]] content_key_to_track_mappings: One or more `content_key_to_track_mapping` blocks as defined below. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input['StreamingPolicyCommonEncryptionCencDefaultContentKeyArgs'] default_content_key: A `default_content_key` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input['StreamingPolicyCommonEncryptionCencDrmPlayreadyArgs'] drm_playready: A `drm_playready` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[str] drm_widevine_custom_license_acquisition_url_template: The URL template for the custom service that delivers licenses to the end user. This is not required when using Azure Media Services for issuing licenses. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input['StreamingPolicyCommonEncryptionCencEnabledProtocolsArgs'] enabled_protocols: A `enabled_protocols` block as defined below. Changing this forces a new Streaming Policy to be created.
        """
        if clear_key_encryption is not None:
            pulumi.set(__self__, "clear_key_encryption", clear_key_encryption)
        if clear_tracks is not None:
            pulumi.set(__self__, "clear_tracks", clear_tracks)
        if content_key_to_track_mappings is not None:
            pulumi.set(__self__, "content_key_to_track_mappings", content_key_to_track_mappings)
        if default_content_key is not None:
            pulumi.set(__self__, "default_content_key", default_content_key)
        if drm_playready is not None:
            pulumi.set(__self__, "drm_playready", drm_playready)
        if drm_widevine_custom_license_acquisition_url_template is not None:
            pulumi.set(__self__, "drm_widevine_custom_license_acquisition_url_template", drm_widevine_custom_license_acquisition_url_template)
        if enabled_protocols is not None:
            pulumi.set(__self__, "enabled_protocols", enabled_protocols)

    @property
    @pulumi.getter(name="clearKeyEncryption")
    def clear_key_encryption(self) -> Optional[pulumi.Input['StreamingPolicyCommonEncryptionCencClearKeyEncryptionArgs']]:
        """
        A `clear_key_encryption` block as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "clear_key_encryption")

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

    @property
    @pulumi.getter(name="clearTracks")
    def clear_tracks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencClearTrackArgs']]]]:
        """
        One or more `clear_track` blocks as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "clear_tracks")

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

    @property
    @pulumi.getter(name="contentKeyToTrackMappings")
    def content_key_to_track_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingArgs']]]]:
        """
        One or more `content_key_to_track_mapping` blocks as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "content_key_to_track_mappings")

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

    @property
    @pulumi.getter(name="defaultContentKey")
    def default_content_key(self) -> Optional[pulumi.Input['StreamingPolicyCommonEncryptionCencDefaultContentKeyArgs']]:
        """
        A `default_content_key` block as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "default_content_key")

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

    @property
    @pulumi.getter(name="drmPlayready")
    def drm_playready(self) -> Optional[pulumi.Input['StreamingPolicyCommonEncryptionCencDrmPlayreadyArgs']]:
        """
        A `drm_playready` block as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "drm_playready")

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

    @property
    @pulumi.getter(name="drmWidevineCustomLicenseAcquisitionUrlTemplate")
    def drm_widevine_custom_license_acquisition_url_template(self) -> Optional[pulumi.Input[str]]:
        """
        The URL template for the custom service that delivers licenses to the end user. This is not required when using Azure Media Services for issuing licenses. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "drm_widevine_custom_license_acquisition_url_template")

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

    @property
    @pulumi.getter(name="enabledProtocols")
    def enabled_protocols(self) -> Optional[pulumi.Input['StreamingPolicyCommonEncryptionCencEnabledProtocolsArgs']]:
        """
        A `enabled_protocols` block as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "enabled_protocols")

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCencClearKeyEncryptionArgs:
    def __init__(__self__, *,
                 custom_keys_acquisition_url_template: pulumi.Input[str]):
        """
        :param pulumi.Input[str] custom_keys_acquisition_url_template: The URL template for the custom service that delivers content keys to the end user. This is not required when using Azure Media Services for issuing keys. Changing this forces a new Streaming Policy to be created.
               
               > **Note** Either `clear_key_encryption` or `drm` must be specified.
        """
        pulumi.set(__self__, "custom_keys_acquisition_url_template", custom_keys_acquisition_url_template)

    @property
    @pulumi.getter(name="customKeysAcquisitionUrlTemplate")
    def custom_keys_acquisition_url_template(self) -> pulumi.Input[str]:
        """
        The URL template for the custom service that delivers content keys to the end user. This is not required when using Azure Media Services for issuing keys. Changing this forces a new Streaming Policy to be created.

        > **Note** Either `clear_key_encryption` or `drm` must be specified.
        """
        return pulumi.get(self, "custom_keys_acquisition_url_template")

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCencClearTrackArgs:
    def __init__(__self__, *,
                 conditions: pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencClearTrackConditionArgs']]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencClearTrackConditionArgs']]] conditions: One or more `condition` blocks as defined below. Changing this forces a new Streaming Policy to be created.
        """
        pulumi.set(__self__, "conditions", conditions)

    @property
    @pulumi.getter
    def conditions(self) -> pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencClearTrackConditionArgs']]]:
        """
        One or more `condition` blocks as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "conditions")

    @conditions.setter
    def conditions(self, value: pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencClearTrackConditionArgs']]]):
        pulumi.set(self, "conditions", value)


@pulumi.input_type
class StreamingPolicyCommonEncryptionCencClearTrackConditionArgs:
    def __init__(__self__, *,
                 operation: pulumi.Input[str],
                 property: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] operation: The track property condition operation. Possible value is `Equal`. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[str] property: The track property type. Possible value is `FourCC`. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[str] value: The track property value. Changing this forces a new Streaming Policy to be created.
        """
        pulumi.set(__self__, "operation", operation)
        pulumi.set(__self__, "property", property)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def operation(self) -> pulumi.Input[str]:
        """
        The track property condition operation. Possible value is `Equal`. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "operation")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The track property value. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "value")

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

    @property
    @pulumi.getter
    def property(self) -> pulumi.Input[str]:
        """
        The track property type. Possible value is `FourCC`. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "property")

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingArgs:
    def __init__(__self__, *,
                 tracks: pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrackArgs']]],
                 label: Optional[pulumi.Input[str]] = None,
                 policy_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrackArgs']]] tracks: One or more `track` blocks as defined below. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[str] label: Specifies the content key when creating a Streaming Locator. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[str] policy_name: The policy used by the default key. Changing this forces a new Streaming Policy to be created.
        """
        pulumi.set(__self__, "tracks", tracks)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if policy_name is not None:
            pulumi.set(__self__, "policy_name", policy_name)

    @property
    @pulumi.getter
    def tracks(self) -> pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrackArgs']]]:
        """
        One or more `track` blocks as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "tracks")

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

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the content key when creating a Streaming Locator. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter(name="policyName")
    def policy_name(self) -> Optional[pulumi.Input[str]]:
        """
        The policy used by the default key. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "policy_name")

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrackArgs:
    def __init__(__self__, *,
                 conditions: pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrackConditionArgs']]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrackConditionArgs']]] conditions: One or more `condition` blocks as defined below. Changing this forces a new Streaming Policy to be created.
        """
        pulumi.set(__self__, "conditions", conditions)

    @property
    @pulumi.getter
    def conditions(self) -> pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrackConditionArgs']]]:
        """
        One or more `condition` blocks as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "conditions")

    @conditions.setter
    def conditions(self, value: pulumi.Input[Sequence[pulumi.Input['StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrackConditionArgs']]]):
        pulumi.set(self, "conditions", value)


@pulumi.input_type
class StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrackConditionArgs:
    def __init__(__self__, *,
                 operation: pulumi.Input[str],
                 property: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] operation: The track property condition operation. Possible value is `Equal`. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[str] property: The track property type. Possible value is `FourCC`. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[str] value: The track property value. Changing this forces a new Streaming Policy to be created.
        """
        pulumi.set(__self__, "operation", operation)
        pulumi.set(__self__, "property", property)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def operation(self) -> pulumi.Input[str]:
        """
        The track property condition operation. Possible value is `Equal`. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "operation")

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

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The track property value. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "value")

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

    @property
    @pulumi.getter
    def property(self) -> pulumi.Input[str]:
        """
        The track property type. Possible value is `FourCC`. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "property")

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCencDefaultContentKeyArgs:
    def __init__(__self__, *,
                 label: Optional[pulumi.Input[str]] = None,
                 policy_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] label: Label can be used to specify Content Key when creating a Streaming Locator. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[str] policy_name: Policy used by Default Key. Changing this forces a new Streaming Policy to be created.
        """
        if label is not None:
            pulumi.set(__self__, "label", label)
        if policy_name is not None:
            pulumi.set(__self__, "policy_name", policy_name)

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        Label can be used to specify Content Key when creating a Streaming Locator. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter(name="policyName")
    def policy_name(self) -> Optional[pulumi.Input[str]]:
        """
        Policy used by Default Key. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "policy_name")

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCencDrmPlayreadyArgs:
    def __init__(__self__, *,
                 custom_attributes: Optional[pulumi.Input[str]] = None,
                 custom_license_acquisition_url_template: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] custom_attributes: Custom attributes for PlayReady. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[str] custom_license_acquisition_url_template: The URL template for the custom service that delivers licenses to the end user. This is not required when using Azure Media Services for issuing licenses. Changing this forces a new Streaming Policy to be created.
        """
        if custom_attributes is not None:
            pulumi.set(__self__, "custom_attributes", custom_attributes)
        if custom_license_acquisition_url_template is not None:
            pulumi.set(__self__, "custom_license_acquisition_url_template", custom_license_acquisition_url_template)

    @property
    @pulumi.getter(name="customAttributes")
    def custom_attributes(self) -> Optional[pulumi.Input[str]]:
        """
        Custom attributes for PlayReady. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "custom_attributes")

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

    @property
    @pulumi.getter(name="customLicenseAcquisitionUrlTemplate")
    def custom_license_acquisition_url_template(self) -> Optional[pulumi.Input[str]]:
        """
        The URL template for the custom service that delivers licenses to the end user. This is not required when using Azure Media Services for issuing licenses. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "custom_license_acquisition_url_template")

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCencEnabledProtocolsArgs:
    def __init__(__self__, *,
                 dash: Optional[pulumi.Input[bool]] = None,
                 download: Optional[pulumi.Input[bool]] = None,
                 hls: Optional[pulumi.Input[bool]] = None,
                 smooth_streaming: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] dash: Enable DASH protocol or not. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[bool] download: Enable Download protocol or not. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[bool] hls: Enable HLS protocol or not. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[bool] smooth_streaming: Enable SmoothStreaming protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        if dash is not None:
            pulumi.set(__self__, "dash", dash)
        if download is not None:
            pulumi.set(__self__, "download", download)
        if hls is not None:
            pulumi.set(__self__, "hls", hls)
        if smooth_streaming is not None:
            pulumi.set(__self__, "smooth_streaming", smooth_streaming)

    @property
    @pulumi.getter
    def dash(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable DASH protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "dash")

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

    @property
    @pulumi.getter
    def download(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable Download protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "download")

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

    @property
    @pulumi.getter
    def hls(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable HLS protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "hls")

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

    @property
    @pulumi.getter(name="smoothStreaming")
    def smooth_streaming(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable SmoothStreaming protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "smooth_streaming")

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


@pulumi.input_type
class StreamingPolicyEnvelopeEncryptionArgs:
    def __init__(__self__, *,
                 custom_keys_acquisition_url_template: Optional[pulumi.Input[str]] = None,
                 default_content_key: Optional[pulumi.Input['StreamingPolicyEnvelopeEncryptionDefaultContentKeyArgs']] = None,
                 enabled_protocols: Optional[pulumi.Input['StreamingPolicyEnvelopeEncryptionEnabledProtocolsArgs']] = None):
        """
        :param pulumi.Input[str] custom_keys_acquisition_url_template: The URL template for the custom service that delivers content keys to the end user. This is not required when using Azure Media Services for issuing keys. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input['StreamingPolicyEnvelopeEncryptionDefaultContentKeyArgs'] default_content_key: A `default_content_key` block as defined above. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input['StreamingPolicyEnvelopeEncryptionEnabledProtocolsArgs'] enabled_protocols: A `enabled_protocols` block as defined above. Changing this forces a new Streaming Policy to be created.
        """
        if custom_keys_acquisition_url_template is not None:
            pulumi.set(__self__, "custom_keys_acquisition_url_template", custom_keys_acquisition_url_template)
        if default_content_key is not None:
            pulumi.set(__self__, "default_content_key", default_content_key)
        if enabled_protocols is not None:
            pulumi.set(__self__, "enabled_protocols", enabled_protocols)

    @property
    @pulumi.getter(name="customKeysAcquisitionUrlTemplate")
    def custom_keys_acquisition_url_template(self) -> Optional[pulumi.Input[str]]:
        """
        The URL template for the custom service that delivers content keys to the end user. This is not required when using Azure Media Services for issuing keys. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "custom_keys_acquisition_url_template")

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

    @property
    @pulumi.getter(name="defaultContentKey")
    def default_content_key(self) -> Optional[pulumi.Input['StreamingPolicyEnvelopeEncryptionDefaultContentKeyArgs']]:
        """
        A `default_content_key` block as defined above. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "default_content_key")

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

    @property
    @pulumi.getter(name="enabledProtocols")
    def enabled_protocols(self) -> Optional[pulumi.Input['StreamingPolicyEnvelopeEncryptionEnabledProtocolsArgs']]:
        """
        A `enabled_protocols` block as defined above. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "enabled_protocols")

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


@pulumi.input_type
class StreamingPolicyEnvelopeEncryptionDefaultContentKeyArgs:
    def __init__(__self__, *,
                 label: Optional[pulumi.Input[str]] = None,
                 policy_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] label: Label can be used to specify Content Key when creating a Streaming Locator. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[str] policy_name: Policy used by Default Key. Changing this forces a new Streaming Policy to be created.
        """
        if label is not None:
            pulumi.set(__self__, "label", label)
        if policy_name is not None:
            pulumi.set(__self__, "policy_name", policy_name)

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        Label can be used to specify Content Key when creating a Streaming Locator. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter(name="policyName")
    def policy_name(self) -> Optional[pulumi.Input[str]]:
        """
        Policy used by Default Key. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "policy_name")

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


@pulumi.input_type
class StreamingPolicyEnvelopeEncryptionEnabledProtocolsArgs:
    def __init__(__self__, *,
                 dash: Optional[pulumi.Input[bool]] = None,
                 download: Optional[pulumi.Input[bool]] = None,
                 hls: Optional[pulumi.Input[bool]] = None,
                 smooth_streaming: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] dash: Enable DASH protocol or not. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[bool] download: Enable Download protocol or not. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[bool] hls: Enable HLS protocol or not. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[bool] smooth_streaming: Enable SmoothStreaming protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        if dash is not None:
            pulumi.set(__self__, "dash", dash)
        if download is not None:
            pulumi.set(__self__, "download", download)
        if hls is not None:
            pulumi.set(__self__, "hls", hls)
        if smooth_streaming is not None:
            pulumi.set(__self__, "smooth_streaming", smooth_streaming)

    @property
    @pulumi.getter
    def dash(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable DASH protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "dash")

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

    @property
    @pulumi.getter
    def download(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable Download protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "download")

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

    @property
    @pulumi.getter
    def hls(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable HLS protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "hls")

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

    @property
    @pulumi.getter(name="smoothStreaming")
    def smooth_streaming(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable SmoothStreaming protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "smooth_streaming")

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


@pulumi.input_type
class StreamingPolicyNoEncryptionEnabledProtocolsArgs:
    def __init__(__self__, *,
                 dash: Optional[pulumi.Input[bool]] = None,
                 download: Optional[pulumi.Input[bool]] = None,
                 hls: Optional[pulumi.Input[bool]] = None,
                 smooth_streaming: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] dash: Enable DASH protocol or not. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[bool] download: Enable Download protocol or not. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[bool] hls: Enable HLS protocol or not. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[bool] smooth_streaming: Enable SmoothStreaming protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        if dash is not None:
            pulumi.set(__self__, "dash", dash)
        if download is not None:
            pulumi.set(__self__, "download", download)
        if hls is not None:
            pulumi.set(__self__, "hls", hls)
        if smooth_streaming is not None:
            pulumi.set(__self__, "smooth_streaming", smooth_streaming)

    @property
    @pulumi.getter
    def dash(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable DASH protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "dash")

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

    @property
    @pulumi.getter
    def download(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable Download protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "download")

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

    @property
    @pulumi.getter
    def hls(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable HLS protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "hls")

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

    @property
    @pulumi.getter(name="smoothStreaming")
    def smooth_streaming(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable SmoothStreaming protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "smooth_streaming")

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


@pulumi.input_type
class TransformOutputArgs:
    def __init__(__self__, *,
                 audio_analyzer_preset: Optional[pulumi.Input['TransformOutputAudioAnalyzerPresetArgs']] = None,
                 builtin_preset: Optional[pulumi.Input['TransformOutputBuiltinPresetArgs']] = None,
                 custom_preset: Optional[pulumi.Input['TransformOutputCustomPresetArgs']] = None,
                 face_detector_preset: Optional[pulumi.Input['TransformOutputFaceDetectorPresetArgs']] = None,
                 on_error_action: Optional[pulumi.Input[str]] = None,
                 relative_priority: Optional[pulumi.Input[str]] = None,
                 video_analyzer_preset: Optional[pulumi.Input['TransformOutputVideoAnalyzerPresetArgs']] = None):
        """
        :param pulumi.Input['TransformOutputAudioAnalyzerPresetArgs'] audio_analyzer_preset: An `audio_analyzer_preset` block as defined above.
        :param pulumi.Input['TransformOutputBuiltinPresetArgs'] builtin_preset: A `builtin_preset` block as defined above.
        :param pulumi.Input['TransformOutputCustomPresetArgs'] custom_preset: A `custom_preset` block as defined above.
        :param pulumi.Input['TransformOutputFaceDetectorPresetArgs'] face_detector_preset: A `face_detector_preset` block as defined above.
        :param pulumi.Input[str] on_error_action: A Transform can define more than one outputs. This property defines what the service should do when one output fails - either continue to produce other outputs, or, stop the other outputs. The overall Job state will not reflect failures of outputs that are specified with `ContinueJob`. Possible values are `StopProcessingJob` or `ContinueJob`. Defaults to `StopProcessingJob`.
        :param pulumi.Input[str] relative_priority: Sets the relative priority of the TransformOutputs within a Transform. This sets the priority that the service uses for processing Transform Outputs. Possible values are `High`, `Normal` or `Low`. Defaults to `Normal`.
        :param pulumi.Input['TransformOutputVideoAnalyzerPresetArgs'] video_analyzer_preset: A `video_analyzer_preset` block as defined below.
               
               > **NOTE:** Each output can only have one type of preset: `builtin_preset`, `audio_analyzer_preset`, `custom_preset`, `face_detector_preset` or `video_analyzer_preset`. If you need to apply different presets you must create one output for each one.
        """
        if audio_analyzer_preset is not None:
            pulumi.set(__self__, "audio_analyzer_preset", audio_analyzer_preset)
        if builtin_preset is not None:
            pulumi.set(__self__, "builtin_preset", builtin_preset)
        if custom_preset is not None:
            pulumi.set(__self__, "custom_preset", custom_preset)
        if face_detector_preset is not None:
            warnings.warn("""`face_detector_preset` will be removed in version 4.0 of the AzureRM Provider as it has been retired.""", DeprecationWarning)
            pulumi.log.warn("""face_detector_preset is deprecated: `face_detector_preset` will be removed in version 4.0 of the AzureRM Provider as it has been retired.""")
        if face_detector_preset is not None:
            pulumi.set(__self__, "face_detector_preset", face_detector_preset)
        if on_error_action is not None:
            pulumi.set(__self__, "on_error_action", on_error_action)
        if relative_priority is not None:
            pulumi.set(__self__, "relative_priority", relative_priority)
        if video_analyzer_preset is not None:
            warnings.warn("""`video_analyzer_preset` will be removed in version 4.0 of the AzureRM Provider as it has been retired.""", DeprecationWarning)
            pulumi.log.warn("""video_analyzer_preset is deprecated: `video_analyzer_preset` will be removed in version 4.0 of the AzureRM Provider as it has been retired.""")
        if video_analyzer_preset is not None:
            pulumi.set(__self__, "video_analyzer_preset", video_analyzer_preset)

    @property
    @pulumi.getter(name="audioAnalyzerPreset")
    def audio_analyzer_preset(self) -> Optional[pulumi.Input['TransformOutputAudioAnalyzerPresetArgs']]:
        """
        An `audio_analyzer_preset` block as defined above.
        """
        return pulumi.get(self, "audio_analyzer_preset")

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

    @property
    @pulumi.getter(name="builtinPreset")
    def builtin_preset(self) -> Optional[pulumi.Input['TransformOutputBuiltinPresetArgs']]:
        """
        A `builtin_preset` block as defined above.
        """
        return pulumi.get(self, "builtin_preset")

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

    @property
    @pulumi.getter(name="customPreset")
    def custom_preset(self) -> Optional[pulumi.Input['TransformOutputCustomPresetArgs']]:
        """
        A `custom_preset` block as defined above.
        """
        return pulumi.get(self, "custom_preset")

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

    @property
    @pulumi.getter(name="faceDetectorPreset")
    def face_detector_preset(self) -> Optional[pulumi.Input['TransformOutputFaceDetectorPresetArgs']]:
        """
        A `face_detector_preset` block as defined above.
        """
        warnings.warn("""`face_detector_preset` will be removed in version 4.0 of the AzureRM Provider as it has been retired.""", DeprecationWarning)
        pulumi.log.warn("""face_detector_preset is deprecated: `face_detector_preset` will be removed in version 4.0 of the AzureRM Provider as it has been retired.""")

        return pulumi.get(self, "face_detector_preset")

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

    @property
    @pulumi.getter(name="onErrorAction")
    def on_error_action(self) -> Optional[pulumi.Input[str]]:
        """
        A Transform can define more than one outputs. This property defines what the service should do when one output fails - either continue to produce other outputs, or, stop the other outputs. The overall Job state will not reflect failures of outputs that are specified with `ContinueJob`. Possible values are `StopProcessingJob` or `ContinueJob`. Defaults to `StopProcessingJob`.
        """
        return pulumi.get(self, "on_error_action")

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

    @property
    @pulumi.getter(name="relativePriority")
    def relative_priority(self) -> Optional[pulumi.Input[str]]:
        """
        Sets the relative priority of the TransformOutputs within a Transform. This sets the priority that the service uses for processing Transform Outputs. Possible values are `High`, `Normal` or `Low`. Defaults to `Normal`.
        """
        return pulumi.get(self, "relative_priority")

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

    @property
    @pulumi.getter(name="videoAnalyzerPreset")
    def video_analyzer_preset(self) -> Optional[pulumi.Input['TransformOutputVideoAnalyzerPresetArgs']]:
        """
        A `video_analyzer_preset` block as defined below.

        > **NOTE:** Each output can only have one type of preset: `builtin_preset`, `audio_analyzer_preset`, `custom_preset`, `face_detector_preset` or `video_analyzer_preset`. If you need to apply different presets you must create one output for each one.
        """
        warnings.warn("""`video_analyzer_preset` will be removed in version 4.0 of the AzureRM Provider as it has been retired.""", DeprecationWarning)
        pulumi.log.warn("""video_analyzer_preset is deprecated: `video_analyzer_preset` will be removed in version 4.0 of the AzureRM Provider as it has been retired.""")

        return pulumi.get(self, "video_analyzer_preset")

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


@pulumi.input_type
class TransformOutputAudioAnalyzerPresetArgs:
    def __init__(__self__, *,
                 audio_analysis_mode: Optional[pulumi.Input[str]] = None,
                 audio_language: Optional[pulumi.Input[str]] = None,
                 experimental_options: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] audio_analysis_mode: Possible values are `Basic` or `Standard`. Determines the set of audio analysis operations to be performed. Default to `Standard`.
        :param pulumi.Input[str] audio_language: The language for the audio payload in the input using the BCP-47 format of 'language tag-region' (e.g: 'en-US'). If you know the language of your content, it is recommended that you specify it. The language must be specified explicitly for AudioAnalysisMode:Basic, since automatic language detection is not included in basic mode. If the language isn't specified, automatic language detection will choose the first language detected and process with the selected language for the duration of the file. It does not currently support dynamically switching between languages after the first language is detected. The automatic detection works best with audio recordings with clearly discernible speech. If automatic detection fails to find the language, transcription would fall back to `en-US`. The list of supported languages is available here: <https://go.microsoft.com/fwlink/?linkid=2109463>.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] experimental_options: Dictionary containing key value pairs for parameters not exposed in the preset itself.
        """
        if audio_analysis_mode is not None:
            pulumi.set(__self__, "audio_analysis_mode", audio_analysis_mode)
        if audio_language is not None:
            pulumi.set(__self__, "audio_language", audio_language)
        if experimental_options is not None:
            pulumi.set(__self__, "experimental_options", experimental_options)

    @property
    @pulumi.getter(name="audioAnalysisMode")
    def audio_analysis_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Possible values are `Basic` or `Standard`. Determines the set of audio analysis operations to be performed. Default to `Standard`.
        """
        return pulumi.get(self, "audio_analysis_mode")

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

    @property
    @pulumi.getter(name="audioLanguage")
    def audio_language(self) -> Optional[pulumi.Input[str]]:
        """
        The language for the audio payload in the input using the BCP-47 format of 'language tag-region' (e.g: 'en-US'). If you know the language of your content, it is recommended that you specify it. The language must be specified explicitly for AudioAnalysisMode:Basic, since automatic language detection is not included in basic mode. If the language isn't specified, automatic language detection will choose the first language detected and process with the selected language for the duration of the file. It does not currently support dynamically switching between languages after the first language is detected. The automatic detection works best with audio recordings with clearly discernible speech. If automatic detection fails to find the language, transcription would fall back to `en-US`. The list of supported languages is available here: <https://go.microsoft.com/fwlink/?linkid=2109463>.
        """
        return pulumi.get(self, "audio_language")

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

    @property
    @pulumi.getter(name="experimentalOptions")
    def experimental_options(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Dictionary containing key value pairs for parameters not exposed in the preset itself.
        """
        return pulumi.get(self, "experimental_options")

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


@pulumi.input_type
class TransformOutputBuiltinPresetArgs:
    def __init__(__self__, *,
                 preset_name: pulumi.Input[str],
                 preset_configuration: Optional[pulumi.Input['TransformOutputBuiltinPresetPresetConfigurationArgs']] = None):
        """
        :param pulumi.Input[str] preset_name: The built-in preset to be used for encoding videos. The Possible values are `AACGoodQualityAudio`, `AdaptiveStreaming`, `ContentAwareEncoding`, `ContentAwareEncodingExperimental`, `CopyAllBitrateNonInterleaved`, `DDGoodQualityAudio`, `H265AdaptiveStreaming`, `H265ContentAwareEncoding`, `H265SingleBitrate4K`, `H265SingleBitrate1080p`, `H265SingleBitrate720p`, `H264MultipleBitrate1080p`, `H264MultipleBitrateSD`, `H264MultipleBitrate720p`, `H264SingleBitrate1080p`, `H264SingleBitrateSD` and `H264SingleBitrate720p`.
        :param pulumi.Input['TransformOutputBuiltinPresetPresetConfigurationArgs'] preset_configuration: A `preset_configuration` block as defined below.
        """
        pulumi.set(__self__, "preset_name", preset_name)
        if preset_configuration is not None:
            pulumi.set(__self__, "preset_configuration", preset_configuration)

    @property
    @pulumi.getter(name="presetName")
    def preset_name(self) -> pulumi.Input[str]:
        """
        The built-in preset to be used for encoding videos. The Possible values are `AACGoodQualityAudio`, `AdaptiveStreaming`, `ContentAwareEncoding`, `ContentAwareEncodingExperimental`, `CopyAllBitrateNonInterleaved`, `DDGoodQualityAudio`, `H265AdaptiveStreaming`, `H265ContentAwareEncoding`, `H265SingleBitrate4K`, `H265SingleBitrate1080p`, `H265SingleBitrate720p`, `H264MultipleBitrate1080p`, `H264MultipleBitrateSD`, `H264MultipleBitrate720p`, `H264SingleBitrate1080p`, `H264SingleBitrateSD` and `H264SingleBitrate720p`.
        """
        return pulumi.get(self, "preset_name")

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

    @property
    @pulumi.getter(name="presetConfiguration")
    def preset_configuration(self) -> Optional[pulumi.Input['TransformOutputBuiltinPresetPresetConfigurationArgs']]:
        """
        A `preset_configuration` block as defined below.
        """
        return pulumi.get(self, "preset_configuration")

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


@pulumi.input_type
class TransformOutputBuiltinPresetPresetConfigurationArgs:
    def __init__(__self__, *,
                 complexity: Optional[pulumi.Input[str]] = None,
                 interleave_output: Optional[pulumi.Input[str]] = None,
                 key_frame_interval_in_seconds: Optional[pulumi.Input[float]] = None,
                 max_bitrate_bps: Optional[pulumi.Input[int]] = None,
                 max_height: Optional[pulumi.Input[int]] = None,
                 max_layers: Optional[pulumi.Input[int]] = None,
                 min_bitrate_bps: Optional[pulumi.Input[int]] = None,
                 min_height: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] complexity: The complexity of the encoding. Possible values are `Balanced`, `Speed` or `Quality`.
        :param pulumi.Input[str] interleave_output: Specifies the interleave mode of the output to control how audio are stored in the container format. Possible values are `InterleavedOutput` and `NonInterleavedOutput`.
        :param pulumi.Input[float] key_frame_interval_in_seconds: The key frame interval in seconds. Possible value is a positive float. For example, set as `2.0` to reduce the playback buffering for some players.
        :param pulumi.Input[int] max_bitrate_bps: The maximum bitrate in bits per second (threshold for the top video layer). For example, set as `6000000` to avoid producing very high bitrate outputs for contents with high complexity.
        :param pulumi.Input[int] max_height: The maximum height of output video layers. For example, set as `720` to produce output layers up to 720P even if the input is 4K.
        :param pulumi.Input[int] max_layers: The maximum number of output video layers. For example, set as `4` to make sure at most 4 output layers are produced to control the overall cost of the encoding job.
        :param pulumi.Input[int] min_bitrate_bps: The minimum bitrate in bits per second (threshold for the bottom video layer). For example, set as `200000` to have a bottom layer that covers users with low network bandwidth.
        :param pulumi.Input[int] min_height: The minimum height of output video layers. For example, set as `360` to avoid output layers of smaller resolutions like 180P.
        """
        if complexity is not None:
            pulumi.set(__self__, "complexity", complexity)
        if interleave_output is not None:
            pulumi.set(__self__, "interleave_output", interleave_output)
        if key_frame_interval_in_seconds is not None:
            pulumi.set(__self__, "key_frame_interval_in_seconds", key_frame_interval_in_seconds)
        if max_bitrate_bps is not None:
            pulumi.set(__self__, "max_bitrate_bps", max_bitrate_bps)
        if max_height is not None:
            pulumi.set(__self__, "max_height", max_height)
        if max_layers is not None:
            pulumi.set(__self__, "max_layers", max_layers)
        if min_bitrate_bps is not None:
            pulumi.set(__self__, "min_bitrate_bps", min_bitrate_bps)
        if min_height is not None:
            pulumi.set(__self__, "min_height", min_height)

    @property
    @pulumi.getter
    def complexity(self) -> Optional[pulumi.Input[str]]:
        """
        The complexity of the encoding. Possible values are `Balanced`, `Speed` or `Quality`.
        """
        return pulumi.get(self, "complexity")

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

    @property
    @pulumi.getter(name="interleaveOutput")
    def interleave_output(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the interleave mode of the output to control how audio are stored in the container format. Possible values are `InterleavedOutput` and `NonInterleavedOutput`.
        """
        return pulumi.get(self, "interleave_output")

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

    @property
    @pulumi.getter(name="keyFrameIntervalInSeconds")
    def key_frame_interval_in_seconds(self) -> Optional[pulumi.Input[float]]:
        """
        The key frame interval in seconds. Possible value is a positive float. For example, set as `2.0` to reduce the playback buffering for some players.
        """
        return pulumi.get(self, "key_frame_interval_in_seconds")

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

    @property
    @pulumi.getter(name="maxBitrateBps")
    def max_bitrate_bps(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum bitrate in bits per second (threshold for the top video layer). For example, set as `6000000` to avoid producing very high bitrate outputs for contents with high complexity.
        """
        return pulumi.get(self, "max_bitrate_bps")

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

    @property
    @pulumi.getter(name="maxHeight")
    def max_height(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum height of output video layers. For example, set as `720` to produce output layers up to 720P even if the input is 4K.
        """
        return pulumi.get(self, "max_height")

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

    @property
    @pulumi.getter(name="maxLayers")
    def max_layers(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of output video layers. For example, set as `4` to make sure at most 4 output layers are produced to control the overall cost of the encoding job.
        """
        return pulumi.get(self, "max_layers")

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

    @property
    @pulumi.getter(name="minBitrateBps")
    def min_bitrate_bps(self) -> Optional[pulumi.Input[int]]:
        """
        The minimum bitrate in bits per second (threshold for the bottom video layer). For example, set as `200000` to have a bottom layer that covers users with low network bandwidth.
        """
        return pulumi.get(self, "min_bitrate_bps")

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

    @property
    @pulumi.getter(name="minHeight")
    def min_height(self) -> Optional[pulumi.Input[int]]:
        """
        The minimum height of output video layers. For example, set as `360` to avoid output layers of smaller resolutions like 180P.
        """
        return pulumi.get(self, "min_height")

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


@pulumi.input_type
class TransformOutputCustomPresetArgs:
    def __init__(__self__, *,
                 codecs: pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetCodecArgs']]],
                 formats: pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetFormatArgs']]],
                 experimental_options: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 filter: Optional[pulumi.Input['TransformOutputCustomPresetFilterArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetCodecArgs']]] codecs: One or more `codec` blocks as defined above.
        :param pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetFormatArgs']]] formats: One or more `format` blocks as defined below.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] experimental_options: Dictionary containing key value pairs for parameters not exposed in the preset itself.
        :param pulumi.Input['TransformOutputCustomPresetFilterArgs'] filter: A `filter` block as defined below.
        """
        pulumi.set(__self__, "codecs", codecs)
        pulumi.set(__self__, "formats", formats)
        if experimental_options is not None:
            pulumi.set(__self__, "experimental_options", experimental_options)
        if filter is not None:
            pulumi.set(__self__, "filter", filter)

    @property
    @pulumi.getter
    def codecs(self) -> pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetCodecArgs']]]:
        """
        One or more `codec` blocks as defined above.
        """
        return pulumi.get(self, "codecs")

    @codecs.setter
    def codecs(self, value: pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetCodecArgs']]]):
        pulumi.set(self, "codecs", value)

    @property
    @pulumi.getter
    def formats(self) -> pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetFormatArgs']]]:
        """
        One or more `format` blocks as defined below.
        """
        return pulumi.get(self, "formats")

    @formats.setter
    def formats(self, value: pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetFormatArgs']]]):
        pulumi.set(self, "formats", value)

    @property
    @pulumi.getter(name="experimentalOptions")
    def experimental_options(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Dictionary containing key value pairs for parameters not exposed in the preset itself.
        """
        return pulumi.get(self, "experimental_options")

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

    @property
    @pulumi.getter
    def filter(self) -> Optional[pulumi.Input['TransformOutputCustomPresetFilterArgs']]:
        """
        A `filter` block as defined below.
        """
        return pulumi.get(self, "filter")

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


@pulumi.input_type
class TransformOutputCustomPresetCodecArgs:
    def __init__(__self__, *,
                 aac_audio: Optional[pulumi.Input['TransformOutputCustomPresetCodecAacAudioArgs']] = None,
                 copy_audio: Optional[pulumi.Input['TransformOutputCustomPresetCodecCopyAudioArgs']] = None,
                 copy_video: Optional[pulumi.Input['TransformOutputCustomPresetCodecCopyVideoArgs']] = None,
                 dd_audio: Optional[pulumi.Input['TransformOutputCustomPresetCodecDdAudioArgs']] = None,
                 h264_video: Optional[pulumi.Input['TransformOutputCustomPresetCodecH264VideoArgs']] = None,
                 h265_video: Optional[pulumi.Input['TransformOutputCustomPresetCodecH265VideoArgs']] = None,
                 jpg_image: Optional[pulumi.Input['TransformOutputCustomPresetCodecJpgImageArgs']] = None,
                 png_image: Optional[pulumi.Input['TransformOutputCustomPresetCodecPngImageArgs']] = None):
        """
        :param pulumi.Input['TransformOutputCustomPresetCodecAacAudioArgs'] aac_audio: A `aac_audio` block as defined above.
        :param pulumi.Input['TransformOutputCustomPresetCodecCopyAudioArgs'] copy_audio: A `copy_audio` block as defined below.
        :param pulumi.Input['TransformOutputCustomPresetCodecCopyVideoArgs'] copy_video: A `copy_video` block as defined below.
        :param pulumi.Input['TransformOutputCustomPresetCodecDdAudioArgs'] dd_audio: A `dd_audio` block as defined below.
        :param pulumi.Input['TransformOutputCustomPresetCodecH264VideoArgs'] h264_video: A `h264_video` block as defined below.
        :param pulumi.Input['TransformOutputCustomPresetCodecH265VideoArgs'] h265_video: A `h265_video` block as defined below.
        :param pulumi.Input['TransformOutputCustomPresetCodecJpgImageArgs'] jpg_image: A `jpg_image` block as defined below.
        :param pulumi.Input['TransformOutputCustomPresetCodecPngImageArgs'] png_image: A `png_image` block as defined below.
               
               > **NOTE:** Each codec can only have one type: `aac_audio`, `copy_audio`, `copy_video`, `dd_audio`, `h264_video`, `h265_video`, `jpg_image` or `png_image`. If you need to apply different codec you must create one codec for each one.
        """
        if aac_audio is not None:
            pulumi.set(__self__, "aac_audio", aac_audio)
        if copy_audio is not None:
            pulumi.set(__self__, "copy_audio", copy_audio)
        if copy_video is not None:
            pulumi.set(__self__, "copy_video", copy_video)
        if dd_audio is not None:
            pulumi.set(__self__, "dd_audio", dd_audio)
        if h264_video is not None:
            pulumi.set(__self__, "h264_video", h264_video)
        if h265_video is not None:
            pulumi.set(__self__, "h265_video", h265_video)
        if jpg_image is not None:
            pulumi.set(__self__, "jpg_image", jpg_image)
        if png_image is not None:
            pulumi.set(__self__, "png_image", png_image)

    @property
    @pulumi.getter(name="aacAudio")
    def aac_audio(self) -> Optional[pulumi.Input['TransformOutputCustomPresetCodecAacAudioArgs']]:
        """
        A `aac_audio` block as defined above.
        """
        return pulumi.get(self, "aac_audio")

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

    @property
    @pulumi.getter(name="copyAudio")
    def copy_audio(self) -> Optional[pulumi.Input['TransformOutputCustomPresetCodecCopyAudioArgs']]:
        """
        A `copy_audio` block as defined below.
        """
        return pulumi.get(self, "copy_audio")

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

    @property
    @pulumi.getter(name="copyVideo")
    def copy_video(self) -> Optional[pulumi.Input['TransformOutputCustomPresetCodecCopyVideoArgs']]:
        """
        A `copy_video` block as defined below.
        """
        return pulumi.get(self, "copy_video")

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

    @property
    @pulumi.getter(name="ddAudio")
    def dd_audio(self) -> Optional[pulumi.Input['TransformOutputCustomPresetCodecDdAudioArgs']]:
        """
        A `dd_audio` block as defined below.
        """
        return pulumi.get(self, "dd_audio")

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

    @property
    @pulumi.getter(name="h264Video")
    def h264_video(self) -> Optional[pulumi.Input['TransformOutputCustomPresetCodecH264VideoArgs']]:
        """
        A `h264_video` block as defined below.
        """
        return pulumi.get(self, "h264_video")

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

    @property
    @pulumi.getter(name="h265Video")
    def h265_video(self) -> Optional[pulumi.Input['TransformOutputCustomPresetCodecH265VideoArgs']]:
        """
        A `h265_video` block as defined below.
        """
        return pulumi.get(self, "h265_video")

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

    @property
    @pulumi.getter(name="jpgImage")
    def jpg_image(self) -> Optional[pulumi.Input['TransformOutputCustomPresetCodecJpgImageArgs']]:
        """
        A `jpg_image` block as defined below.
        """
        return pulumi.get(self, "jpg_image")

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

    @property
    @pulumi.getter(name="pngImage")
    def png_image(self) -> Optional[pulumi.Input['TransformOutputCustomPresetCodecPngImageArgs']]:
        """
        A `png_image` block as defined below.

        > **NOTE:** Each codec can only have one type: `aac_audio`, `copy_audio`, `copy_video`, `dd_audio`, `h264_video`, `h265_video`, `jpg_image` or `png_image`. If you need to apply different codec you must create one codec for each one.
        """
        return pulumi.get(self, "png_image")

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


@pulumi.input_type
class TransformOutputCustomPresetCodecAacAudioArgs:
    def __init__(__self__, *,
                 bitrate: Optional[pulumi.Input[int]] = None,
                 channels: Optional[pulumi.Input[int]] = None,
                 label: Optional[pulumi.Input[str]] = None,
                 profile: Optional[pulumi.Input[str]] = None,
                 sampling_rate: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] bitrate: The bitrate of the audio in bits per second. Default to `128000`.
        :param pulumi.Input[int] channels: The number of audio channels. Default to `2`.
        :param pulumi.Input[str] label: Specifies the label for the codec. The label can be used to control muxing behavior.
        :param pulumi.Input[str] profile: The encoding profile to be used when encoding audio with AAC. Possible values are `AacLc`, `HeAacV1`,and `HeAacV2`. Default to `AacLc`.
        :param pulumi.Input[int] sampling_rate: The sampling rate to use for encoding in Hertz. Default to `48000`.
        """
        if bitrate is not None:
            pulumi.set(__self__, "bitrate", bitrate)
        if channels is not None:
            pulumi.set(__self__, "channels", channels)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if profile is not None:
            pulumi.set(__self__, "profile", profile)
        if sampling_rate is not None:
            pulumi.set(__self__, "sampling_rate", sampling_rate)

    @property
    @pulumi.getter
    def bitrate(self) -> Optional[pulumi.Input[int]]:
        """
        The bitrate of the audio in bits per second. Default to `128000`.
        """
        return pulumi.get(self, "bitrate")

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

    @property
    @pulumi.getter
    def channels(self) -> Optional[pulumi.Input[int]]:
        """
        The number of audio channels. Default to `2`.
        """
        return pulumi.get(self, "channels")

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

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the label for the codec. The label can be used to control muxing behavior.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter
    def profile(self) -> Optional[pulumi.Input[str]]:
        """
        The encoding profile to be used when encoding audio with AAC. Possible values are `AacLc`, `HeAacV1`,and `HeAacV2`. Default to `AacLc`.
        """
        return pulumi.get(self, "profile")

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

    @property
    @pulumi.getter(name="samplingRate")
    def sampling_rate(self) -> Optional[pulumi.Input[int]]:
        """
        The sampling rate to use for encoding in Hertz. Default to `48000`.
        """
        return pulumi.get(self, "sampling_rate")

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


@pulumi.input_type
class TransformOutputCustomPresetCodecCopyAudioArgs:
    def __init__(__self__, *,
                 label: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] label: Specifies the label for the codec. The label can be used to control muxing behavior.
        """
        if label is not None:
            pulumi.set(__self__, "label", label)

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the label for the codec. The label can be used to control muxing behavior.
        """
        return pulumi.get(self, "label")

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


@pulumi.input_type
class TransformOutputCustomPresetCodecCopyVideoArgs:
    def __init__(__self__, *,
                 label: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] label: Specifies the label for the codec. The label can be used to control muxing behavior.
        """
        if label is not None:
            pulumi.set(__self__, "label", label)

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the label for the codec. The label can be used to control muxing behavior.
        """
        return pulumi.get(self, "label")

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


@pulumi.input_type
class TransformOutputCustomPresetCodecDdAudioArgs:
    def __init__(__self__, *,
                 bitrate: Optional[pulumi.Input[int]] = None,
                 channels: Optional[pulumi.Input[int]] = None,
                 label: Optional[pulumi.Input[str]] = None,
                 sampling_rate: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] bitrate: The bitrate of the audio in bits per second. Default to `192000`.
        :param pulumi.Input[int] channels: The number of audio channels. Default to `2`.
        :param pulumi.Input[str] label: Specifies the label for the codec. The label can be used to control muxing behavior.
        :param pulumi.Input[int] sampling_rate: The sampling rate to use for encoding in Hertz. Default to `48000`.
        """
        if bitrate is not None:
            pulumi.set(__self__, "bitrate", bitrate)
        if channels is not None:
            pulumi.set(__self__, "channels", channels)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if sampling_rate is not None:
            pulumi.set(__self__, "sampling_rate", sampling_rate)

    @property
    @pulumi.getter
    def bitrate(self) -> Optional[pulumi.Input[int]]:
        """
        The bitrate of the audio in bits per second. Default to `192000`.
        """
        return pulumi.get(self, "bitrate")

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

    @property
    @pulumi.getter
    def channels(self) -> Optional[pulumi.Input[int]]:
        """
        The number of audio channels. Default to `2`.
        """
        return pulumi.get(self, "channels")

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

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the label for the codec. The label can be used to control muxing behavior.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter(name="samplingRate")
    def sampling_rate(self) -> Optional[pulumi.Input[int]]:
        """
        The sampling rate to use for encoding in Hertz. Default to `48000`.
        """
        return pulumi.get(self, "sampling_rate")

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


@pulumi.input_type
class TransformOutputCustomPresetCodecH264VideoArgs:
    def __init__(__self__, *,
                 complexity: Optional[pulumi.Input[str]] = None,
                 key_frame_interval: Optional[pulumi.Input[str]] = None,
                 label: Optional[pulumi.Input[str]] = None,
                 layers: Optional[pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetCodecH264VideoLayerArgs']]]] = None,
                 rate_control_mode: Optional[pulumi.Input[str]] = None,
                 scene_change_detection_enabled: Optional[pulumi.Input[bool]] = None,
                 stretch_mode: Optional[pulumi.Input[str]] = None,
                 sync_mode: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] complexity: The complexity of the encoding. Possible values are `Balanced`, `Speed` or `Quality`. Default to `Balanced`.
        :param pulumi.Input[str] key_frame_interval: The distance between two key frames. The value should be non-zero in the range `0.5` to `20` seconds, specified in ISO 8601 format. Note that this setting is ignored if `sync_mode` is set to `Passthrough`, where the KeyFrameInterval value will follow the input source setting. Defaults to `PT2S`.
        :param pulumi.Input[str] label: Specifies the label for the codec. The label can be used to control muxing behavior.
        :param pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetCodecH264VideoLayerArgs']]] layers: One or more `layer` blocks as defined below.
        :param pulumi.Input[str] rate_control_mode: The rate control mode. Possible values are `ABR`, `CBR` or `CRF`. Default to `ABR`.
        :param pulumi.Input[bool] scene_change_detection_enabled: Whether the encoder should insert key frames at scene changes. This flag should be set to true only when the encoder is being configured to produce a single output video. Default to `false`.
        :param pulumi.Input[str] stretch_mode: Specifies the resizing mode - how the input video will be resized to fit the desired output resolution(s). Possible values are `AutoFit`, `AutoSize` or `None`. Default to `AutoSize`.
        :param pulumi.Input[str] sync_mode: Specifies the synchronization mode for the video. Possible values are `Auto`, `Cfr`, `Passthrough` or `Vfr`. Default to `Auto`.
        """
        if complexity is not None:
            pulumi.set(__self__, "complexity", complexity)
        if key_frame_interval is not None:
            pulumi.set(__self__, "key_frame_interval", key_frame_interval)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if layers is not None:
            pulumi.set(__self__, "layers", layers)
        if rate_control_mode is not None:
            pulumi.set(__self__, "rate_control_mode", rate_control_mode)
        if scene_change_detection_enabled is not None:
            pulumi.set(__self__, "scene_change_detection_enabled", scene_change_detection_enabled)
        if stretch_mode is not None:
            pulumi.set(__self__, "stretch_mode", stretch_mode)
        if sync_mode is not None:
            pulumi.set(__self__, "sync_mode", sync_mode)

    @property
    @pulumi.getter
    def complexity(self) -> Optional[pulumi.Input[str]]:
        """
        The complexity of the encoding. Possible values are `Balanced`, `Speed` or `Quality`. Default to `Balanced`.
        """
        return pulumi.get(self, "complexity")

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

    @property
    @pulumi.getter(name="keyFrameInterval")
    def key_frame_interval(self) -> Optional[pulumi.Input[str]]:
        """
        The distance between two key frames. The value should be non-zero in the range `0.5` to `20` seconds, specified in ISO 8601 format. Note that this setting is ignored if `sync_mode` is set to `Passthrough`, where the KeyFrameInterval value will follow the input source setting. Defaults to `PT2S`.
        """
        return pulumi.get(self, "key_frame_interval")

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

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the label for the codec. The label can be used to control muxing behavior.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter
    def layers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetCodecH264VideoLayerArgs']]]]:
        """
        One or more `layer` blocks as defined below.
        """
        return pulumi.get(self, "layers")

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

    @property
    @pulumi.getter(name="rateControlMode")
    def rate_control_mode(self) -> Optional[pulumi.Input[str]]:
        """
        The rate control mode. Possible values are `ABR`, `CBR` or `CRF`. Default to `ABR`.
        """
        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="sceneChangeDetectionEnabled")
    def scene_change_detection_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the encoder should insert key frames at scene changes. This flag should be set to true only when the encoder is being configured to produce a single output video. Default to `false`.
        """
        return pulumi.get(self, "scene_change_detection_enabled")

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

    @property
    @pulumi.getter(name="stretchMode")
    def stretch_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the resizing mode - how the input video will be resized to fit the desired output resolution(s). Possible values are `AutoFit`, `AutoSize` or `None`. Default to `AutoSize`.
        """
        return pulumi.get(self, "stretch_mode")

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

    @property
    @pulumi.getter(name="syncMode")
    def sync_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the synchronization mode for the video. Possible values are `Auto`, `Cfr`, `Passthrough` or `Vfr`. Default to `Auto`.
        """
        return pulumi.get(self, "sync_mode")

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


@pulumi.input_type
class TransformOutputCustomPresetCodecH264VideoLayerArgs:
    def __init__(__self__, *,
                 bitrate: pulumi.Input[int],
                 adaptive_b_frame_enabled: Optional[pulumi.Input[bool]] = None,
                 b_frames: Optional[pulumi.Input[int]] = None,
                 buffer_window: Optional[pulumi.Input[str]] = None,
                 crf: Optional[pulumi.Input[float]] = None,
                 entropy_mode: Optional[pulumi.Input[str]] = None,
                 frame_rate: Optional[pulumi.Input[str]] = None,
                 height: Optional[pulumi.Input[str]] = None,
                 label: Optional[pulumi.Input[str]] = None,
                 level: Optional[pulumi.Input[str]] = None,
                 max_bitrate: Optional[pulumi.Input[int]] = None,
                 profile: Optional[pulumi.Input[str]] = None,
                 reference_frames: Optional[pulumi.Input[int]] = None,
                 slices: Optional[pulumi.Input[int]] = None,
                 width: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] bitrate: The average bitrate in bits per second at which to encode the input video when generating this layer.
        :param pulumi.Input[bool] adaptive_b_frame_enabled: Whether adaptive B-frames are used when encoding this layer. If not specified, the encoder will turn it on whenever the video profile permits its use. Default to `true`.
        :param pulumi.Input[int] b_frames: The number of B-frames to use when encoding this layer. If not specified, the encoder chooses an appropriate number based on the video profile and level.
        :param pulumi.Input[str] buffer_window: Specifies the maximum amount of time that the encoder should buffer frames before encoding. The value should be in ISO 8601 format. The value should be in the range `0.1` to `100` seconds. Defaults to `PT5S`.
        :param pulumi.Input[float] crf: The value of CRF to be used when encoding this layer. This setting takes effect when `rate_control_mode` is set `CRF`. The range of CRF value is between `0` and `51`, where lower values would result in better quality, at the expense of higher file sizes. Higher values mean more compression, but at some point quality degradation will be noticed. Default to `28`.
        :param pulumi.Input[str] entropy_mode: The entropy mode to be used for this layer. Possible values are `Cabac` or `Cavlc`. If not specified, the encoder chooses the mode that is appropriate for the profile and level.
        :param pulumi.Input[str] frame_rate: The frame rate (in frames per second) at which to encode this layer. The value can be in the form of `M/N` where `M` and `N` are integers (For example, `30000/1001`), or in the form of a number (For example, `30`, or `29.97`). The encoder enforces constraints on allowed frame rates based on the profile and level. If it is not specified, the encoder will use the same frame rate as the input video.
        :param pulumi.Input[str] height: The height of the output video for this layer. The value can be absolute (in pixels) or relative (in percentage). For example `50%` means the output video has half as many pixels in height as the input.
        :param pulumi.Input[str] label: The alphanumeric label for this layer, which can be used in multiplexing different video and audio layers, or in naming the output file.
        :param pulumi.Input[str] level: The H.264 levels. Currently, the resource support Level up to `6.2`. The value can be `auto`, or a number that matches the H.264 profile. If not specified, the default is `auto`, which lets the encoder choose the Level that is appropriate for this layer.
        :param pulumi.Input[int] max_bitrate: The maximum bitrate (in bits per second), at which the VBV buffer should be assumed to refill. If not specified, defaults to the same value as bitrate.
        :param pulumi.Input[str] profile: The H.264 profile. Possible values are `Auto`, `Main` and `Main10`. Default to `Auto`.
        :param pulumi.Input[int] reference_frames: The number of reference frames to be used when encoding this layer. If not specified, the encoder determines an appropriate number based on the encoder complexity setting.
        :param pulumi.Input[int] slices: The number of slices to be used when encoding this layer. If not specified, default is `1`, which means that encoder will use a single slice for each frame.
        :param pulumi.Input[str] width: The width of the output video for this layer. The value can be absolute (in pixels) or relative (in percentage). For example `50%` means the output video has half as many pixels in width as the input.
        """
        pulumi.set(__self__, "bitrate", bitrate)
        if adaptive_b_frame_enabled is not None:
            pulumi.set(__self__, "adaptive_b_frame_enabled", adaptive_b_frame_enabled)
        if b_frames is not None:
            pulumi.set(__self__, "b_frames", b_frames)
        if buffer_window is not None:
            pulumi.set(__self__, "buffer_window", buffer_window)
        if crf is not None:
            pulumi.set(__self__, "crf", crf)
        if entropy_mode is not None:
            pulumi.set(__self__, "entropy_mode", entropy_mode)
        if frame_rate is not None:
            pulumi.set(__self__, "frame_rate", frame_rate)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if level is not None:
            pulumi.set(__self__, "level", level)
        if max_bitrate is not None:
            pulumi.set(__self__, "max_bitrate", max_bitrate)
        if profile is not None:
            pulumi.set(__self__, "profile", profile)
        if reference_frames is not None:
            pulumi.set(__self__, "reference_frames", reference_frames)
        if slices is not None:
            pulumi.set(__self__, "slices", slices)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def bitrate(self) -> pulumi.Input[int]:
        """
        The average bitrate in bits per second at which to encode the input video when generating this layer.
        """
        return pulumi.get(self, "bitrate")

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

    @property
    @pulumi.getter(name="adaptiveBFrameEnabled")
    def adaptive_b_frame_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether adaptive B-frames are used when encoding this layer. If not specified, the encoder will turn it on whenever the video profile permits its use. Default to `true`.
        """
        return pulumi.get(self, "adaptive_b_frame_enabled")

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

    @property
    @pulumi.getter(name="bFrames")
    def b_frames(self) -> Optional[pulumi.Input[int]]:
        """
        The number of B-frames to use when encoding this layer. If not specified, the encoder chooses an appropriate number based on the video profile and level.
        """
        return pulumi.get(self, "b_frames")

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

    @property
    @pulumi.getter(name="bufferWindow")
    def buffer_window(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the maximum amount of time that the encoder should buffer frames before encoding. The value should be in ISO 8601 format. The value should be in the range `0.1` to `100` seconds. Defaults to `PT5S`.
        """
        return pulumi.get(self, "buffer_window")

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

    @property
    @pulumi.getter
    def crf(self) -> Optional[pulumi.Input[float]]:
        """
        The value of CRF to be used when encoding this layer. This setting takes effect when `rate_control_mode` is set `CRF`. The range of CRF value is between `0` and `51`, where lower values would result in better quality, at the expense of higher file sizes. Higher values mean more compression, but at some point quality degradation will be noticed. Default to `28`.
        """
        return pulumi.get(self, "crf")

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

    @property
    @pulumi.getter(name="entropyMode")
    def entropy_mode(self) -> Optional[pulumi.Input[str]]:
        """
        The entropy mode to be used for this layer. Possible values are `Cabac` or `Cavlc`. If not specified, the encoder chooses the mode that is appropriate for the profile and level.
        """
        return pulumi.get(self, "entropy_mode")

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

    @property
    @pulumi.getter(name="frameRate")
    def frame_rate(self) -> Optional[pulumi.Input[str]]:
        """
        The frame rate (in frames per second) at which to encode this layer. The value can be in the form of `M/N` where `M` and `N` are integers (For example, `30000/1001`), or in the form of a number (For example, `30`, or `29.97`). The encoder enforces constraints on allowed frame rates based on the profile and level. If it is not specified, the encoder will use the same frame rate as the input video.
        """
        return pulumi.get(self, "frame_rate")

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

    @property
    @pulumi.getter
    def height(self) -> Optional[pulumi.Input[str]]:
        """
        The height of the output video for this layer. The value can be absolute (in pixels) or relative (in percentage). For example `50%` means the output video has half as many pixels in height as the input.
        """
        return pulumi.get(self, "height")

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

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        The alphanumeric label for this layer, which can be used in multiplexing different video and audio layers, or in naming the output file.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter
    def level(self) -> Optional[pulumi.Input[str]]:
        """
        The H.264 levels. Currently, the resource support Level up to `6.2`. The value can be `auto`, or a number that matches the H.264 profile. If not specified, the default is `auto`, which lets the encoder choose the Level that is appropriate for this layer.
        """
        return pulumi.get(self, "level")

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

    @property
    @pulumi.getter(name="maxBitrate")
    def max_bitrate(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum bitrate (in bits per second), at which the VBV buffer should be assumed to refill. If not specified, defaults to the same value as bitrate.
        """
        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
    def profile(self) -> Optional[pulumi.Input[str]]:
        """
        The H.264 profile. Possible values are `Auto`, `Main` and `Main10`. Default to `Auto`.
        """
        return pulumi.get(self, "profile")

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

    @property
    @pulumi.getter(name="referenceFrames")
    def reference_frames(self) -> Optional[pulumi.Input[int]]:
        """
        The number of reference frames to be used when encoding this layer. If not specified, the encoder determines an appropriate number based on the encoder complexity setting.
        """
        return pulumi.get(self, "reference_frames")

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

    @property
    @pulumi.getter
    def slices(self) -> Optional[pulumi.Input[int]]:
        """
        The number of slices to be used when encoding this layer. If not specified, default is `1`, which means that encoder will use a single slice for each frame.
        """
        return pulumi.get(self, "slices")

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

    @property
    @pulumi.getter
    def width(self) -> Optional[pulumi.Input[str]]:
        """
        The width of the output video for this layer. The value can be absolute (in pixels) or relative (in percentage). For example `50%` means the output video has half as many pixels in width as the input.
        """
        return pulumi.get(self, "width")

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


@pulumi.input_type
class TransformOutputCustomPresetCodecH265VideoArgs:
    def __init__(__self__, *,
                 complexity: Optional[pulumi.Input[str]] = None,
                 key_frame_interval: Optional[pulumi.Input[str]] = None,
                 label: Optional[pulumi.Input[str]] = None,
                 layers: Optional[pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetCodecH265VideoLayerArgs']]]] = None,
                 scene_change_detection_enabled: Optional[pulumi.Input[bool]] = None,
                 stretch_mode: Optional[pulumi.Input[str]] = None,
                 sync_mode: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] complexity: The complexity of the encoding. Possible values are `Balanced`, `Speed` or `Quality`. Default to `Balanced`.
        :param pulumi.Input[str] key_frame_interval: The distance between two key frames. The value should be non-zero in the range `0.5` to `20` seconds, specified in ISO 8601 format. Note that this setting is ignored if `sync_mode` is set to `Passthrough`, where the KeyFrameInterval value will follow the input source setting. Defaults to `PT2S`.
        :param pulumi.Input[str] label: Specifies the label for the codec. The label can be used to control muxing behavior.
        :param pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetCodecH265VideoLayerArgs']]] layers: One or more `layer` blocks as defined below.
        :param pulumi.Input[bool] scene_change_detection_enabled: Whether the encoder should insert key frames at scene changes. This flag should be set to true only when the encoder is being configured to produce a single output video. Default to `false`.
        :param pulumi.Input[str] stretch_mode: Specifies the resizing mode - how the input video will be resized to fit the desired output resolution(s). Possible values are `AutoFit`, `AutoSize` or `None`. Default to `AutoSize`.
        :param pulumi.Input[str] sync_mode: Specifies the synchronization mode for the video. Possible values are `Auto`, `Cfr`, `Passthrough` or `Vfr`. Default to `Auto`.
        """
        if complexity is not None:
            pulumi.set(__self__, "complexity", complexity)
        if key_frame_interval is not None:
            pulumi.set(__self__, "key_frame_interval", key_frame_interval)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if layers is not None:
            pulumi.set(__self__, "layers", layers)
        if scene_change_detection_enabled is not None:
            pulumi.set(__self__, "scene_change_detection_enabled", scene_change_detection_enabled)
        if stretch_mode is not None:
            pulumi.set(__self__, "stretch_mode", stretch_mode)
        if sync_mode is not None:
            pulumi.set(__self__, "sync_mode", sync_mode)

    @property
    @pulumi.getter
    def complexity(self) -> Optional[pulumi.Input[str]]:
        """
        The complexity of the encoding. Possible values are `Balanced`, `Speed` or `Quality`. Default to `Balanced`.
        """
        return pulumi.get(self, "complexity")

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

    @property
    @pulumi.getter(name="keyFrameInterval")
    def key_frame_interval(self) -> Optional[pulumi.Input[str]]:
        """
        The distance between two key frames. The value should be non-zero in the range `0.5` to `20` seconds, specified in ISO 8601 format. Note that this setting is ignored if `sync_mode` is set to `Passthrough`, where the KeyFrameInterval value will follow the input source setting. Defaults to `PT2S`.
        """
        return pulumi.get(self, "key_frame_interval")

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

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the label for the codec. The label can be used to control muxing behavior.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter
    def layers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetCodecH265VideoLayerArgs']]]]:
        """
        One or more `layer` blocks as defined below.
        """
        return pulumi.get(self, "layers")

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

    @property
    @pulumi.getter(name="sceneChangeDetectionEnabled")
    def scene_change_detection_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether the encoder should insert key frames at scene changes. This flag should be set to true only when the encoder is being configured to produce a single output video. Default to `false`.
        """
        return pulumi.get(self, "scene_change_detection_enabled")

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

    @property
    @pulumi.getter(name="stretchMode")
    def stretch_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the resizing mode - how the input video will be resized to fit the desired output resolution(s). Possible values are `AutoFit`, `AutoSize` or `None`. Default to `AutoSize`.
        """
        return pulumi.get(self, "stretch_mode")

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

    @property
    @pulumi.getter(name="syncMode")
    def sync_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the synchronization mode for the video. Possible values are `Auto`, `Cfr`, `Passthrough` or `Vfr`. Default to `Auto`.
        """
        return pulumi.get(self, "sync_mode")

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


@pulumi.input_type
class TransformOutputCustomPresetCodecH265VideoLayerArgs:
    def __init__(__self__, *,
                 bitrate: pulumi.Input[int],
                 adaptive_b_frame_enabled: Optional[pulumi.Input[bool]] = None,
                 b_frames: Optional[pulumi.Input[int]] = None,
                 buffer_window: Optional[pulumi.Input[str]] = None,
                 crf: Optional[pulumi.Input[float]] = None,
                 frame_rate: Optional[pulumi.Input[str]] = None,
                 height: Optional[pulumi.Input[str]] = None,
                 label: Optional[pulumi.Input[str]] = None,
                 level: Optional[pulumi.Input[str]] = None,
                 max_bitrate: Optional[pulumi.Input[int]] = None,
                 profile: Optional[pulumi.Input[str]] = None,
                 reference_frames: Optional[pulumi.Input[int]] = None,
                 slices: Optional[pulumi.Input[int]] = None,
                 width: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[int] bitrate: The average bitrate in bits per second at which to encode the input video when generating this layer.
        :param pulumi.Input[bool] adaptive_b_frame_enabled: Whether adaptive B-frames are used when encoding this layer. If not specified, the encoder will turn it on whenever the video profile permits its use. Default to `true`.
        :param pulumi.Input[int] b_frames: The number of B-frames to use when encoding this layer. If not specified, the encoder chooses an appropriate number based on the video profile and level.
        :param pulumi.Input[str] buffer_window: Specifies the maximum amount of time that the encoder should buffer frames before encoding. The value should be in ISO 8601 format. The value should be in the range `0.1` to `100` seconds. Defaults to `PT5S`.
        :param pulumi.Input[float] crf: The value of CRF to be used when encoding this layer. This setting takes effect when `rate_control_mode` is set `CRF`. The range of CRF value is between `0` and `51`, where lower values would result in better quality, at the expense of higher file sizes. Higher values mean more compression, but at some point quality degradation will be noticed. Default to `28`.
        :param pulumi.Input[str] frame_rate: The frame rate (in frames per second) at which to encode this layer. The value can be in the form of `M/N` where `M` and `N` are integers (For example, `30000/1001`), or in the form of a number (For example, `30`, or `29.97`). The encoder enforces constraints on allowed frame rates based on the profile and level. If it is not specified, the encoder will use the same frame rate as the input video.
        :param pulumi.Input[str] height: The height of the output video for this layer. The value can be absolute (in pixels) or relative (in percentage). For example `50%` means the output video has half as many pixels in height as the input.
        :param pulumi.Input[str] label: The alphanumeric label for this layer, which can be used in multiplexing different video and audio layers, or in naming the output file.
        :param pulumi.Input[str] level: The H.264 levels. Currently, the resource support Level up to `6.2`. The value can be `auto`, or a number that matches the H.264 profile. If not specified, the default is `auto`, which lets the encoder choose the Level that is appropriate for this layer.
        :param pulumi.Input[int] max_bitrate: The maximum bitrate (in bits per second), at which the VBV buffer should be assumed to refill. If not specified, defaults to the same value as bitrate.
        :param pulumi.Input[str] profile: The H.264 profile. Possible values are `Auto`, `Main` and `Main10`. Default to `Auto`.
        :param pulumi.Input[int] reference_frames: The number of reference frames to be used when encoding this layer. If not specified, the encoder determines an appropriate number based on the encoder complexity setting.
        :param pulumi.Input[int] slices: The number of slices to be used when encoding this layer. If not specified, default is `1`, which means that encoder will use a single slice for each frame.
        :param pulumi.Input[str] width: The width of the output video for this layer. The value can be absolute (in pixels) or relative (in percentage). For example `50%` means the output video has half as many pixels in width as the input.
        """
        pulumi.set(__self__, "bitrate", bitrate)
        if adaptive_b_frame_enabled is not None:
            pulumi.set(__self__, "adaptive_b_frame_enabled", adaptive_b_frame_enabled)
        if b_frames is not None:
            pulumi.set(__self__, "b_frames", b_frames)
        if buffer_window is not None:
            pulumi.set(__self__, "buffer_window", buffer_window)
        if crf is not None:
            pulumi.set(__self__, "crf", crf)
        if frame_rate is not None:
            pulumi.set(__self__, "frame_rate", frame_rate)
        if height is not None:
            pulumi.set(__self__, "height", height)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if level is not None:
            pulumi.set(__self__, "level", level)
        if max_bitrate is not None:
            pulumi.set(__self__, "max_bitrate", max_bitrate)
        if profile is not None:
            pulumi.set(__self__, "profile", profile)
        if reference_frames is not None:
            pulumi.set(__self__, "reference_frames", reference_frames)
        if slices is not None:
            pulumi.set(__self__, "slices", slices)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def bitrate(self) -> pulumi.Input[int]:
        """
        The average bitrate in bits per second at which to encode the input video when generating this layer.
        """
        return pulumi.get(self, "bitrate")

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

    @property
    @pulumi.getter(name="adaptiveBFrameEnabled")
    def adaptive_b_frame_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether adaptive B-frames are used when encoding this layer. If not specified, the encoder will turn it on whenever the video profile permits its use. Default to `true`.
        """
        return pulumi.get(self, "adaptive_b_frame_enabled")

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

    @property
    @pulumi.getter(name="bFrames")
    def b_frames(self) -> Optional[pulumi.Input[int]]:
        """
        The number of B-frames to use when encoding this layer. If not specified, the encoder chooses an appropriate number based on the video profile and level.
        """
        return pulumi.get(self, "b_frames")

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

    @property
    @pulumi.getter(name="bufferWindow")
    def buffer_window(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the maximum amount of time that the encoder should buffer frames before encoding. The value should be in ISO 8601 format. The value should be in the range `0.1` to `100` seconds. Defaults to `PT5S`.
        """
        return pulumi.get(self, "buffer_window")

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

    @property
    @pulumi.getter
    def crf(self) -> Optional[pulumi.Input[float]]:
        """
        The value of CRF to be used when encoding this layer. This setting takes effect when `rate_control_mode` is set `CRF`. The range of CRF value is between `0` and `51`, where lower values would result in better quality, at the expense of higher file sizes. Higher values mean more compression, but at some point quality degradation will be noticed. Default to `28`.
        """
        return pulumi.get(self, "crf")

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

    @property
    @pulumi.getter(name="frameRate")
    def frame_rate(self) -> Optional[pulumi.Input[str]]:
        """
        The frame rate (in frames per second) at which to encode this layer. The value can be in the form of `M/N` where `M` and `N` are integers (For example, `30000/1001`), or in the form of a number (For example, `30`, or `29.97`). The encoder enforces constraints on allowed frame rates based on the profile and level. If it is not specified, the encoder will use the same frame rate as the input video.
        """
        return pulumi.get(self, "frame_rate")

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

    @property
    @pulumi.getter
    def height(self) -> Optional[pulumi.Input[str]]:
        """
        The height of the output video for this layer. The value can be absolute (in pixels) or relative (in percentage). For example `50%` means the output video has half as many pixels in height as the input.
        """
        return pulumi.get(self, "height")

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

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        The alphanumeric label for this layer, which can be used in multiplexing different video and audio layers, or in naming the output file.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter
    def level(self) -> Optional[pulumi.Input[str]]:
        """
        The H.264 levels. Currently, the resource support Level up to `6.2`. The value can be `auto`, or a number that matches the H.264 profile. If not specified, the default is `auto`, which lets the encoder choose the Level that is appropriate for this layer.
        """
        return pulumi.get(self, "level")

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

    @property
    @pulumi.getter(name="maxBitrate")
    def max_bitrate(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum bitrate (in bits per second), at which the VBV buffer should be assumed to refill. If not specified, defaults to the same value as bitrate.
        """
        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
    def profile(self) -> Optional[pulumi.Input[str]]:
        """
        The H.264 profile. Possible values are `Auto`, `Main` and `Main10`. Default to `Auto`.
        """
        return pulumi.get(self, "profile")

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

    @property
    @pulumi.getter(name="referenceFrames")
    def reference_frames(self) -> Optional[pulumi.Input[int]]:
        """
        The number of reference frames to be used when encoding this layer. If not specified, the encoder determines an appropriate number based on the encoder complexity setting.
        """
        return pulumi.get(self, "reference_frames")

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

    @property
    @pulumi.getter
    def slices(self) -> Optional[pulumi.Input[int]]:
        """
        The number of slices to be used when encoding this layer. If not specified, default is `1`, which means that encoder will use a single slice for each frame.
        """
        return pulumi.get(self, "slices")

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

    @property
    @pulumi.getter
    def width(self) -> Optional[pulumi.Input[str]]:
        """
        The width of the output video for this layer. The value can be absolute (in pixels) or relative (in percentage). For example `50%` means the output video has half as many pixels in width as the input.
        """
        return pulumi.get(self, "width")

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


@pulumi.input_type
class TransformOutputCustomPresetCodecJpgImageArgs:
    def __init__(__self__, *,
                 start: pulumi.Input[str],
                 key_frame_interval: Optional[pulumi.Input[str]] = None,
                 label: Optional[pulumi.Input[str]] = None,
                 layers: Optional[pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetCodecJpgImageLayerArgs']]]] = None,
                 range: Optional[pulumi.Input[str]] = None,
                 sprite_column: Optional[pulumi.Input[int]] = None,
                 step: Optional[pulumi.Input[str]] = None,
                 stretch_mode: Optional[pulumi.Input[str]] = None,
                 sync_mode: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] start: The position in the input video from where to start generating thumbnails. The value can be in ISO 8601 format (For example, `PT05S` to start at 5 seconds), or a frame count (For example, `10` to start at the 10th frame), or a relative value to stream duration (For example, `10%` to start at 10% of stream duration). Also supports a macro `{Best}`, which tells the encoder to select the best thumbnail from the first few seconds of the video and will only produce one thumbnail, no matter what other settings are for `step` and `range`.
        :param pulumi.Input[str] key_frame_interval: The distance between two key frames. The value should be non-zero in the range `0.5` to `20` seconds, specified in ISO 8601 format. Note that this setting is ignored if `sync_mode` is set to `Passthrough`, where the KeyFrameInterval value will follow the input source setting. Defaults to `PT2S`.
        :param pulumi.Input[str] label: Specifies the label for the codec. The label can be used to control muxing behavior.
        :param pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetCodecJpgImageLayerArgs']]] layers: One or more `layer` blocks as defined below.
        :param pulumi.Input[str] range: The position relative to transform preset start time in the input video at which to stop generating thumbnails. The value can be in ISO 8601 format (For example, `PT5M30S` to stop at 5 minutes and 30 seconds from start time), or a frame count (For example, `300` to stop at the 300th frame from the frame at start time. If this value is `1`, it means only producing one thumbnail at start time), or a relative value to the stream duration (For example, `50%` to stop at half of stream duration from start time). The default value is `100%`, which means to stop at the end of the stream.
        :param pulumi.Input[int] sprite_column: Sets the number of columns used in thumbnail sprite image. The number of rows are automatically calculated and a VTT file is generated with the coordinate mappings for each thumbnail in the sprite. Note: this value should be a positive integer and a proper value is recommended so that the output image resolution will not go beyond JPEG maximum pixel resolution limit `65535x65535`.
        :param pulumi.Input[str] step: The intervals at which thumbnails are generated. The value can be in ISO 8601 format (For example, `PT05S` for one image every 5 seconds), or a frame count (For example, `30` for one image every 30 frames), or a relative value to stream duration (For example, `10%` for one image every 10% of stream duration). Note: Step value will affect the first generated thumbnail, which may not be exactly the one specified at transform preset start time. This is due to the encoder, which tries to select the best thumbnail between start time and Step position from start time as the first output. As the default value is `10%`, it means if stream has long duration, the first generated thumbnail might be far away from the one specified at start time. Try to select reasonable value for Step if the first thumbnail is expected close to start time, or set Range value at `1` if only one thumbnail is needed at start time.
        :param pulumi.Input[str] stretch_mode: The resizing mode, which indicates how the input video will be resized to fit the desired output resolution(s). Possible values are `AutoFit`, `AutoSize` or `None`. Default to `AutoSize`.
        :param pulumi.Input[str] sync_mode: Specifies the synchronization mode for the video. Possible values are `Auto`, `Cfr`, `Passthrough` or `Vfr`. Default to `Auto`.
        """
        pulumi.set(__self__, "start", start)
        if key_frame_interval is not None:
            pulumi.set(__self__, "key_frame_interval", key_frame_interval)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if layers is not None:
            pulumi.set(__self__, "layers", layers)
        if range is not None:
            pulumi.set(__self__, "range", range)
        if sprite_column is not None:
            pulumi.set(__self__, "sprite_column", sprite_column)
        if step is not None:
            pulumi.set(__self__, "step", step)
        if stretch_mode is not None:
            pulumi.set(__self__, "stretch_mode", stretch_mode)
        if sync_mode is not None:
            pulumi.set(__self__, "sync_mode", sync_mode)

    @property
    @pulumi.getter
    def start(self) -> pulumi.Input[str]:
        """
        The position in the input video from where to start generating thumbnails. The value can be in ISO 8601 format (For example, `PT05S` to start at 5 seconds), or a frame count (For example, `10` to start at the 10th frame), or a relative value to stream duration (For example, `10%` to start at 10% of stream duration). Also supports a macro `{Best}`, which tells the encoder to select the best thumbnail from the first few seconds of the video and will only produce one thumbnail, no matter what other settings are for `step` and `range`.
        """
        return pulumi.get(self, "start")

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

    @property
    @pulumi.getter(name="keyFrameInterval")
    def key_frame_interval(self) -> Optional[pulumi.Input[str]]:
        """
        The distance between two key frames. The value should be non-zero in the range `0.5` to `20` seconds, specified in ISO 8601 format. Note that this setting is ignored if `sync_mode` is set to `Passthrough`, where the KeyFrameInterval value will follow the input source setting. Defaults to `PT2S`.
        """
        return pulumi.get(self, "key_frame_interval")

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

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the label for the codec. The label can be used to control muxing behavior.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter
    def layers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetCodecJpgImageLayerArgs']]]]:
        """
        One or more `layer` blocks as defined below.
        """
        return pulumi.get(self, "layers")

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

    @property
    @pulumi.getter
    def range(self) -> Optional[pulumi.Input[str]]:
        """
        The position relative to transform preset start time in the input video at which to stop generating thumbnails. The value can be in ISO 8601 format (For example, `PT5M30S` to stop at 5 minutes and 30 seconds from start time), or a frame count (For example, `300` to stop at the 300th frame from the frame at start time. If this value is `1`, it means only producing one thumbnail at start time), or a relative value to the stream duration (For example, `50%` to stop at half of stream duration from start time). The default value is `100%`, which means to stop at the end of the stream.
        """
        return pulumi.get(self, "range")

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

    @property
    @pulumi.getter(name="spriteColumn")
    def sprite_column(self) -> Optional[pulumi.Input[int]]:
        """
        Sets the number of columns used in thumbnail sprite image. The number of rows are automatically calculated and a VTT file is generated with the coordinate mappings for each thumbnail in the sprite. Note: this value should be a positive integer and a proper value is recommended so that the output image resolution will not go beyond JPEG maximum pixel resolution limit `65535x65535`.
        """
        return pulumi.get(self, "sprite_column")

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

    @property
    @pulumi.getter
    def step(self) -> Optional[pulumi.Input[str]]:
        """
        The intervals at which thumbnails are generated. The value can be in ISO 8601 format (For example, `PT05S` for one image every 5 seconds), or a frame count (For example, `30` for one image every 30 frames), or a relative value to stream duration (For example, `10%` for one image every 10% of stream duration). Note: Step value will affect the first generated thumbnail, which may not be exactly the one specified at transform preset start time. This is due to the encoder, which tries to select the best thumbnail between start time and Step position from start time as the first output. As the default value is `10%`, it means if stream has long duration, the first generated thumbnail might be far away from the one specified at start time. Try to select reasonable value for Step if the first thumbnail is expected close to start time, or set Range value at `1` if only one thumbnail is needed at start time.
        """
        return pulumi.get(self, "step")

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

    @property
    @pulumi.getter(name="stretchMode")
    def stretch_mode(self) -> Optional[pulumi.Input[str]]:
        """
        The resizing mode, which indicates how the input video will be resized to fit the desired output resolution(s). Possible values are `AutoFit`, `AutoSize` or `None`. Default to `AutoSize`.
        """
        return pulumi.get(self, "stretch_mode")

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

    @property
    @pulumi.getter(name="syncMode")
    def sync_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the synchronization mode for the video. Possible values are `Auto`, `Cfr`, `Passthrough` or `Vfr`. Default to `Auto`.
        """
        return pulumi.get(self, "sync_mode")

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


@pulumi.input_type
class TransformOutputCustomPresetCodecJpgImageLayerArgs:
    def __init__(__self__, *,
                 height: Optional[pulumi.Input[str]] = None,
                 label: Optional[pulumi.Input[str]] = None,
                 quality: Optional[pulumi.Input[int]] = None,
                 width: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] height: The height of the output video for this layer. The value can be absolute (in pixels) or relative (in percentage). For example `50%` means the output video has half as many pixels in height as the input.
        :param pulumi.Input[str] label: The alphanumeric label for this layer, which can be used in multiplexing different video and audio layers, or in naming the output file.
        :param pulumi.Input[int] quality: The compression quality of the JPEG output. Range is from `0` to `100` and the default is `70`.
        :param pulumi.Input[str] width: The width of the output video for this layer. The value can be absolute (in pixels) or relative (in percentage). For example `50%` means the output video has half as many pixels in width as the input.
        """
        if height is not None:
            pulumi.set(__self__, "height", height)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if quality is not None:
            pulumi.set(__self__, "quality", quality)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def height(self) -> Optional[pulumi.Input[str]]:
        """
        The height of the output video for this layer. The value can be absolute (in pixels) or relative (in percentage). For example `50%` means the output video has half as many pixels in height as the input.
        """
        return pulumi.get(self, "height")

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

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        The alphanumeric label for this layer, which can be used in multiplexing different video and audio layers, or in naming the output file.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter
    def quality(self) -> Optional[pulumi.Input[int]]:
        """
        The compression quality of the JPEG output. Range is from `0` to `100` and the default is `70`.
        """
        return pulumi.get(self, "quality")

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

    @property
    @pulumi.getter
    def width(self) -> Optional[pulumi.Input[str]]:
        """
        The width of the output video for this layer. The value can be absolute (in pixels) or relative (in percentage). For example `50%` means the output video has half as many pixels in width as the input.
        """
        return pulumi.get(self, "width")

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


@pulumi.input_type
class TransformOutputCustomPresetCodecPngImageArgs:
    def __init__(__self__, *,
                 start: pulumi.Input[str],
                 key_frame_interval: Optional[pulumi.Input[str]] = None,
                 label: Optional[pulumi.Input[str]] = None,
                 layers: Optional[pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetCodecPngImageLayerArgs']]]] = None,
                 range: Optional[pulumi.Input[str]] = None,
                 step: Optional[pulumi.Input[str]] = None,
                 stretch_mode: Optional[pulumi.Input[str]] = None,
                 sync_mode: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] start: The position in the input video from where to start generating thumbnails. The value can be in ISO 8601 format (For example, `PT05S` to start at 5 seconds), or a frame count (For example, `10` to start at the 10th frame), or a relative value to stream duration (For example, `10%` to start at 10% of stream duration). Also supports a macro `{Best}`, which tells the encoder to select the best thumbnail from the first few seconds of the video and will only produce one thumbnail, no matter what other settings are for `step` and `range`.
        :param pulumi.Input[str] key_frame_interval: The distance between two key frames. The value should be non-zero in the range `0.5` to `20` seconds, specified in ISO 8601 format. Note that this setting is ignored if `sync_mode` is set to `Passthrough`, where the KeyFrameInterval value will follow the input source setting. Defaults to `PT2S`.
        :param pulumi.Input[str] label: Specifies the label for the codec. The label can be used to control muxing behavior.
        :param pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetCodecPngImageLayerArgs']]] layers: One or more `layer` blocks as defined below.
        :param pulumi.Input[str] range: The position relative to transform preset start time in the input video at which to stop generating thumbnails. The value can be in ISO 8601 format (For example, `PT5M30S` to stop at `5` minutes and `30` seconds from start time), or a frame count (For example, `300` to stop at the 300th frame from the frame at start time. If this value is `1`, it means only producing one thumbnail at start time), or a relative value to the stream duration (For example, `50%` to stop at half of stream duration from start time). The default value is `100%`, which means to stop at the end of the stream.
        :param pulumi.Input[str] step: The intervals at which thumbnails are generated. The value can be in ISO 8601 format (For example, `PT05S` for one image every 5 seconds), or a frame count (For example, `30` for one image every 30 frames), or a relative value to stream duration (For example, `10%` for one image every 10% of stream duration). Note: Step value will affect the first generated thumbnail, which may not be exactly the one specified at transform preset start time. This is due to the encoder, which tries to select the best thumbnail between start time and Step position from start time as the first output. As the default value is `10%`, it means if stream has long duration, the first generated thumbnail might be far away from the one specified at start time. Try to select reasonable value for Step if the first thumbnail is expected close to start time, or set Range value at `1` if only one thumbnail is needed at start time.
        :param pulumi.Input[str] stretch_mode: The resizing mode, which indicates how the input video will be resized to fit the desired output resolution(s). Possible values are `AutoFit`, `AutoSize` or `None`. Default to `AutoSize`.
        :param pulumi.Input[str] sync_mode: Specifies the synchronization mode for the video. Possible values are `Auto`, `Cfr`, `Passthrough` or `Vfr`. Default to `Auto`.
        """
        pulumi.set(__self__, "start", start)
        if key_frame_interval is not None:
            pulumi.set(__self__, "key_frame_interval", key_frame_interval)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if layers is not None:
            pulumi.set(__self__, "layers", layers)
        if range is not None:
            pulumi.set(__self__, "range", range)
        if step is not None:
            pulumi.set(__self__, "step", step)
        if stretch_mode is not None:
            pulumi.set(__self__, "stretch_mode", stretch_mode)
        if sync_mode is not None:
            pulumi.set(__self__, "sync_mode", sync_mode)

    @property
    @pulumi.getter
    def start(self) -> pulumi.Input[str]:
        """
        The position in the input video from where to start generating thumbnails. The value can be in ISO 8601 format (For example, `PT05S` to start at 5 seconds), or a frame count (For example, `10` to start at the 10th frame), or a relative value to stream duration (For example, `10%` to start at 10% of stream duration). Also supports a macro `{Best}`, which tells the encoder to select the best thumbnail from the first few seconds of the video and will only produce one thumbnail, no matter what other settings are for `step` and `range`.
        """
        return pulumi.get(self, "start")

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

    @property
    @pulumi.getter(name="keyFrameInterval")
    def key_frame_interval(self) -> Optional[pulumi.Input[str]]:
        """
        The distance between two key frames. The value should be non-zero in the range `0.5` to `20` seconds, specified in ISO 8601 format. Note that this setting is ignored if `sync_mode` is set to `Passthrough`, where the KeyFrameInterval value will follow the input source setting. Defaults to `PT2S`.
        """
        return pulumi.get(self, "key_frame_interval")

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

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the label for the codec. The label can be used to control muxing behavior.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter
    def layers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetCodecPngImageLayerArgs']]]]:
        """
        One or more `layer` blocks as defined below.
        """
        return pulumi.get(self, "layers")

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

    @property
    @pulumi.getter
    def range(self) -> Optional[pulumi.Input[str]]:
        """
        The position relative to transform preset start time in the input video at which to stop generating thumbnails. The value can be in ISO 8601 format (For example, `PT5M30S` to stop at `5` minutes and `30` seconds from start time), or a frame count (For example, `300` to stop at the 300th frame from the frame at start time. If this value is `1`, it means only producing one thumbnail at start time), or a relative value to the stream duration (For example, `50%` to stop at half of stream duration from start time). The default value is `100%`, which means to stop at the end of the stream.
        """
        return pulumi.get(self, "range")

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

    @property
    @pulumi.getter
    def step(self) -> Optional[pulumi.Input[str]]:
        """
        The intervals at which thumbnails are generated. The value can be in ISO 8601 format (For example, `PT05S` for one image every 5 seconds), or a frame count (For example, `30` for one image every 30 frames), or a relative value to stream duration (For example, `10%` for one image every 10% of stream duration). Note: Step value will affect the first generated thumbnail, which may not be exactly the one specified at transform preset start time. This is due to the encoder, which tries to select the best thumbnail between start time and Step position from start time as the first output. As the default value is `10%`, it means if stream has long duration, the first generated thumbnail might be far away from the one specified at start time. Try to select reasonable value for Step if the first thumbnail is expected close to start time, or set Range value at `1` if only one thumbnail is needed at start time.
        """
        return pulumi.get(self, "step")

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

    @property
    @pulumi.getter(name="stretchMode")
    def stretch_mode(self) -> Optional[pulumi.Input[str]]:
        """
        The resizing mode, which indicates how the input video will be resized to fit the desired output resolution(s). Possible values are `AutoFit`, `AutoSize` or `None`. Default to `AutoSize`.
        """
        return pulumi.get(self, "stretch_mode")

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

    @property
    @pulumi.getter(name="syncMode")
    def sync_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the synchronization mode for the video. Possible values are `Auto`, `Cfr`, `Passthrough` or `Vfr`. Default to `Auto`.
        """
        return pulumi.get(self, "sync_mode")

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


@pulumi.input_type
class TransformOutputCustomPresetCodecPngImageLayerArgs:
    def __init__(__self__, *,
                 height: Optional[pulumi.Input[str]] = None,
                 label: Optional[pulumi.Input[str]] = None,
                 width: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] height: The height of the output video for this layer. The value can be absolute (in pixels) or relative (in percentage). For example `50%` means the output video has half as many pixels in height as the input.
        :param pulumi.Input[str] label: The alphanumeric label for this layer, which can be used in multiplexing different video and audio layers, or in naming the output file.
        :param pulumi.Input[str] width: The width of the output video for this layer. The value can be absolute (in pixels) or relative (in percentage). For example `50%` means the output video has half as many pixels in width as the input.
        """
        if height is not None:
            pulumi.set(__self__, "height", height)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def height(self) -> Optional[pulumi.Input[str]]:
        """
        The height of the output video for this layer. The value can be absolute (in pixels) or relative (in percentage). For example `50%` means the output video has half as many pixels in height as the input.
        """
        return pulumi.get(self, "height")

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

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        """
        The alphanumeric label for this layer, which can be used in multiplexing different video and audio layers, or in naming the output file.
        """
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter
    def width(self) -> Optional[pulumi.Input[str]]:
        """
        The width of the output video for this layer. The value can be absolute (in pixels) or relative (in percentage). For example `50%` means the output video has half as many pixels in width as the input.
        """
        return pulumi.get(self, "width")

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


@pulumi.input_type
class TransformOutputCustomPresetFilterArgs:
    def __init__(__self__, *,
                 crop_rectangle: Optional[pulumi.Input['TransformOutputCustomPresetFilterCropRectangleArgs']] = None,
                 deinterlace: Optional[pulumi.Input['TransformOutputCustomPresetFilterDeinterlaceArgs']] = None,
                 fade_in: Optional[pulumi.Input['TransformOutputCustomPresetFilterFadeInArgs']] = None,
                 fade_out: Optional[pulumi.Input['TransformOutputCustomPresetFilterFadeOutArgs']] = None,
                 overlays: Optional[pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetFilterOverlayArgs']]]] = None,
                 rotation: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input['TransformOutputCustomPresetFilterCropRectangleArgs'] crop_rectangle: A `crop_rectangle` block as defined above.
        :param pulumi.Input['TransformOutputCustomPresetFilterDeinterlaceArgs'] deinterlace: A `deinterlace` block as defined below.
        :param pulumi.Input['TransformOutputCustomPresetFilterFadeInArgs'] fade_in: A `fade_in` block as defined above.
        :param pulumi.Input['TransformOutputCustomPresetFilterFadeOutArgs'] fade_out: A `fade_out` block as defined above.
        :param pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetFilterOverlayArgs']]] overlays: One or more `overlay` blocks as defined below.
        :param pulumi.Input[str] rotation: The rotation to be applied to the input video before it is encoded. Possible values are `Auto`, `None`, `Rotate90`, `Rotate180`, `Rotate270`,or `Rotate0`. Default to `Auto`.
        """
        if crop_rectangle is not None:
            pulumi.set(__self__, "crop_rectangle", crop_rectangle)
        if deinterlace is not None:
            pulumi.set(__self__, "deinterlace", deinterlace)
        if fade_in is not None:
            pulumi.set(__self__, "fade_in", fade_in)
        if fade_out is not None:
            pulumi.set(__self__, "fade_out", fade_out)
        if overlays is not None:
            pulumi.set(__self__, "overlays", overlays)
        if rotation is not None:
            pulumi.set(__self__, "rotation", rotation)

    @property
    @pulumi.getter(name="cropRectangle")
    def crop_rectangle(self) -> Optional[pulumi.Input['TransformOutputCustomPresetFilterCropRectangleArgs']]:
        """
        A `crop_rectangle` block as defined above.
        """
        return pulumi.get(self, "crop_rectangle")

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

    @property
    @pulumi.getter
    def deinterlace(self) -> Optional[pulumi.Input['TransformOutputCustomPresetFilterDeinterlaceArgs']]:
        """
        A `deinterlace` block as defined below.
        """
        return pulumi.get(self, "deinterlace")

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

    @property
    @pulumi.getter(name="fadeIn")
    def fade_in(self) -> Optional[pulumi.Input['TransformOutputCustomPresetFilterFadeInArgs']]:
        """
        A `fade_in` block as defined above.
        """
        return pulumi.get(self, "fade_in")

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

    @property
    @pulumi.getter(name="fadeOut")
    def fade_out(self) -> Optional[pulumi.Input['TransformOutputCustomPresetFilterFadeOutArgs']]:
        """
        A `fade_out` block as defined above.
        """
        return pulumi.get(self, "fade_out")

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

    @property
    @pulumi.getter
    def overlays(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetFilterOverlayArgs']]]]:
        """
        One or more `overlay` blocks as defined below.
        """
        return pulumi.get(self, "overlays")

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

    @property
    @pulumi.getter
    def rotation(self) -> Optional[pulumi.Input[str]]:
        """
        The rotation to be applied to the input video before it is encoded. Possible values are `Auto`, `None`, `Rotate90`, `Rotate180`, `Rotate270`,or `Rotate0`. Default to `Auto`.
        """
        return pulumi.get(self, "rotation")

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


@pulumi.input_type
class TransformOutputCustomPresetFilterCropRectangleArgs:
    def __init__(__self__, *,
                 height: Optional[pulumi.Input[str]] = None,
                 left: Optional[pulumi.Input[str]] = None,
                 top: Optional[pulumi.Input[str]] = None,
                 width: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] height: The height of the rectangular region in pixels. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        :param pulumi.Input[str] left: The number of pixels from the left-margin. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        :param pulumi.Input[str] top: The number of pixels from the top-margin. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        :param pulumi.Input[str] width: The width of the rectangular region in pixels. This can be absolute pixel value (e.g` 100`), or relative to the size of the video (For example, `50%`).
        """
        if height is not None:
            pulumi.set(__self__, "height", height)
        if left is not None:
            pulumi.set(__self__, "left", left)
        if top is not None:
            pulumi.set(__self__, "top", top)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def height(self) -> Optional[pulumi.Input[str]]:
        """
        The height of the rectangular region in pixels. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        """
        return pulumi.get(self, "height")

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

    @property
    @pulumi.getter
    def left(self) -> Optional[pulumi.Input[str]]:
        """
        The number of pixels from the left-margin. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        """
        return pulumi.get(self, "left")

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

    @property
    @pulumi.getter
    def top(self) -> Optional[pulumi.Input[str]]:
        """
        The number of pixels from the top-margin. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        """
        return pulumi.get(self, "top")

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

    @property
    @pulumi.getter
    def width(self) -> Optional[pulumi.Input[str]]:
        """
        The width of the rectangular region in pixels. This can be absolute pixel value (e.g` 100`), or relative to the size of the video (For example, `50%`).
        """
        return pulumi.get(self, "width")

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


@pulumi.input_type
class TransformOutputCustomPresetFilterDeinterlaceArgs:
    def __init__(__self__, *,
                 mode: Optional[pulumi.Input[str]] = None,
                 parity: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] mode: The deinterlacing mode. Possible values are `AutoPixelAdaptive` or `Off`. Default to `AutoPixelAdaptive`.
        :param pulumi.Input[str] parity: The field parity to use for deinterlacing. Possible values are `Auto`, `TopFieldFirst` or `BottomFieldFirst`. Default to `Auto`.
        """
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if parity is not None:
            pulumi.set(__self__, "parity", parity)

    @property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[str]]:
        """
        The deinterlacing mode. Possible values are `AutoPixelAdaptive` or `Off`. Default to `AutoPixelAdaptive`.
        """
        return pulumi.get(self, "mode")

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

    @property
    @pulumi.getter
    def parity(self) -> Optional[pulumi.Input[str]]:
        """
        The field parity to use for deinterlacing. Possible values are `Auto`, `TopFieldFirst` or `BottomFieldFirst`. Default to `Auto`.
        """
        return pulumi.get(self, "parity")

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


@pulumi.input_type
class TransformOutputCustomPresetFilterFadeInArgs:
    def __init__(__self__, *,
                 duration: pulumi.Input[str],
                 fade_color: pulumi.Input[str],
                 start: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] duration: The duration of the fade effect in the video. The value can be in ISO 8601 format (For example, PT05S to fade In/Out a color during 5 seconds), or a frame count (For example, 10 to fade 10 frames from the start time), or a relative value to stream duration (For example, 10% to fade 10% of stream duration).
        :param pulumi.Input[str] fade_color: The color for the fade in/out. It can be on the [CSS Level1 colors](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value/color_keywords) or an RGB/hex value: e.g: `rgb(255,0,0)`, `0xFF0000` or `#FF0000`.
        :param pulumi.Input[str] start: The position in the input video from where to start fade. The value can be in ISO 8601 format (For example, `PT05S` to start at 5 seconds), or a frame count (For example, `10` to start at the 10th frame), or a relative value to stream duration (For example, `10%` to start at 10% of stream duration). Default to `0`.
        """
        pulumi.set(__self__, "duration", duration)
        pulumi.set(__self__, "fade_color", fade_color)
        if start is not None:
            pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter
    def duration(self) -> pulumi.Input[str]:
        """
        The duration of the fade effect in the video. The value can be in ISO 8601 format (For example, PT05S to fade In/Out a color during 5 seconds), or a frame count (For example, 10 to fade 10 frames from the start time), or a relative value to stream duration (For example, 10% to fade 10% of stream duration).
        """
        return pulumi.get(self, "duration")

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

    @property
    @pulumi.getter(name="fadeColor")
    def fade_color(self) -> pulumi.Input[str]:
        """
        The color for the fade in/out. It can be on the [CSS Level1 colors](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value/color_keywords) or an RGB/hex value: e.g: `rgb(255,0,0)`, `0xFF0000` or `#FF0000`.
        """
        return pulumi.get(self, "fade_color")

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

    @property
    @pulumi.getter
    def start(self) -> Optional[pulumi.Input[str]]:
        """
        The position in the input video from where to start fade. The value can be in ISO 8601 format (For example, `PT05S` to start at 5 seconds), or a frame count (For example, `10` to start at the 10th frame), or a relative value to stream duration (For example, `10%` to start at 10% of stream duration). Default to `0`.
        """
        return pulumi.get(self, "start")

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


@pulumi.input_type
class TransformOutputCustomPresetFilterFadeOutArgs:
    def __init__(__self__, *,
                 duration: pulumi.Input[str],
                 fade_color: pulumi.Input[str],
                 start: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] duration: The duration of the fade effect in the video. The value can be in ISO 8601 format (For example, PT05S to fade In/Out a color during 5 seconds), or a frame count (For example, 10 to fade 10 frames from the start time), or a relative value to stream duration (For example, 10% to fade 10% of stream duration).
        :param pulumi.Input[str] fade_color: The color for the fade in/out. It can be on the [CSS Level1 colors](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value/color_keywords) or an RGB/hex value: e.g: `rgb(255,0,0)`, `0xFF0000` or `#FF0000`.
        :param pulumi.Input[str] start: The position in the input video from where to start fade. The value can be in ISO 8601 format (For example, `PT05S` to start at 5 seconds), or a frame count (For example, `10` to start at the 10th frame), or a relative value to stream duration (For example, `10%` to start at 10% of stream duration). Default to `0`.
        """
        pulumi.set(__self__, "duration", duration)
        pulumi.set(__self__, "fade_color", fade_color)
        if start is not None:
            pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter
    def duration(self) -> pulumi.Input[str]:
        """
        The duration of the fade effect in the video. The value can be in ISO 8601 format (For example, PT05S to fade In/Out a color during 5 seconds), or a frame count (For example, 10 to fade 10 frames from the start time), or a relative value to stream duration (For example, 10% to fade 10% of stream duration).
        """
        return pulumi.get(self, "duration")

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

    @property
    @pulumi.getter(name="fadeColor")
    def fade_color(self) -> pulumi.Input[str]:
        """
        The color for the fade in/out. It can be on the [CSS Level1 colors](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value/color_keywords) or an RGB/hex value: e.g: `rgb(255,0,0)`, `0xFF0000` or `#FF0000`.
        """
        return pulumi.get(self, "fade_color")

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

    @property
    @pulumi.getter
    def start(self) -> Optional[pulumi.Input[str]]:
        """
        The position in the input video from where to start fade. The value can be in ISO 8601 format (For example, `PT05S` to start at 5 seconds), or a frame count (For example, `10` to start at the 10th frame), or a relative value to stream duration (For example, `10%` to start at 10% of stream duration). Default to `0`.
        """
        return pulumi.get(self, "start")

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


@pulumi.input_type
class TransformOutputCustomPresetFilterOverlayArgs:
    def __init__(__self__, *,
                 audio: Optional[pulumi.Input['TransformOutputCustomPresetFilterOverlayAudioArgs']] = None,
                 video: Optional[pulumi.Input['TransformOutputCustomPresetFilterOverlayVideoArgs']] = None):
        """
        :param pulumi.Input['TransformOutputCustomPresetFilterOverlayAudioArgs'] audio: An `audio` block as defined above.
        :param pulumi.Input['TransformOutputCustomPresetFilterOverlayVideoArgs'] video: A `video` block as defined below.
               
               > **NOTE:** Each overlay can only have one type: `audio` or `video`. If you need to apply different type you must create one overlay for each one.
        """
        if audio is not None:
            pulumi.set(__self__, "audio", audio)
        if video is not None:
            pulumi.set(__self__, "video", video)

    @property
    @pulumi.getter
    def audio(self) -> Optional[pulumi.Input['TransformOutputCustomPresetFilterOverlayAudioArgs']]:
        """
        An `audio` block as defined above.
        """
        return pulumi.get(self, "audio")

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

    @property
    @pulumi.getter
    def video(self) -> Optional[pulumi.Input['TransformOutputCustomPresetFilterOverlayVideoArgs']]:
        """
        A `video` block as defined below.

        > **NOTE:** Each overlay can only have one type: `audio` or `video`. If you need to apply different type you must create one overlay for each one.
        """
        return pulumi.get(self, "video")

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


@pulumi.input_type
class TransformOutputCustomPresetFilterOverlayAudioArgs:
    def __init__(__self__, *,
                 input_label: pulumi.Input[str],
                 audio_gain_level: Optional[pulumi.Input[float]] = None,
                 end: Optional[pulumi.Input[str]] = None,
                 fade_in_duration: Optional[pulumi.Input[str]] = None,
                 fade_out_duration: Optional[pulumi.Input[str]] = None,
                 start: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] input_label: The label of the job input which is to be used as an overlay. The input must specify exact one file. You can specify an image file in JPG, PNG, GIF or BMP format, or an audio file (such as a WAV, MP3, WMA or M4A file), or a video file.
        :param pulumi.Input[float] audio_gain_level: The gain level of audio in the overlay. The value should be in the range `0` to `1.0`. The default is `1.0`.
        :param pulumi.Input[str] end: The end position, with reference to the input video, at which the overlay ends. The value should be in ISO 8601 format. For example, `PT30S` to end the overlay at 30 seconds into the input video. If not specified or the value is greater than the input video duration, the overlay will be applied until the end of the input video if the overlay media duration is greater than the input video duration, else the overlay will last as long as the overlay media duration.
        :param pulumi.Input[str] fade_in_duration: The duration over which the overlay fades in onto the input video. The value should be in ISO 8601 duration format. If not specified the default behavior is to have no fade in (same as `PT0S`).
        :param pulumi.Input[str] fade_out_duration: The duration over which the overlay fades out of the input video. The value should be in ISO 8601 duration format. If not specified the default behavior is to have no fade out (same as `PT0S`).
        :param pulumi.Input[str] start: The start position, with reference to the input video, at which the overlay starts. The value should be in ISO 8601 format. For example, `PT05S` to start the overlay at 5 seconds into the input video. If not specified the overlay starts from the beginning of the input video.
        """
        pulumi.set(__self__, "input_label", input_label)
        if audio_gain_level is not None:
            pulumi.set(__self__, "audio_gain_level", audio_gain_level)
        if end is not None:
            pulumi.set(__self__, "end", end)
        if fade_in_duration is not None:
            pulumi.set(__self__, "fade_in_duration", fade_in_duration)
        if fade_out_duration is not None:
            pulumi.set(__self__, "fade_out_duration", fade_out_duration)
        if start is not None:
            pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter(name="inputLabel")
    def input_label(self) -> pulumi.Input[str]:
        """
        The label of the job input which is to be used as an overlay. The input must specify exact one file. You can specify an image file in JPG, PNG, GIF or BMP format, or an audio file (such as a WAV, MP3, WMA or M4A file), or a video file.
        """
        return pulumi.get(self, "input_label")

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

    @property
    @pulumi.getter(name="audioGainLevel")
    def audio_gain_level(self) -> Optional[pulumi.Input[float]]:
        """
        The gain level of audio in the overlay. The value should be in the range `0` to `1.0`. The default is `1.0`.
        """
        return pulumi.get(self, "audio_gain_level")

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

    @property
    @pulumi.getter
    def end(self) -> Optional[pulumi.Input[str]]:
        """
        The end position, with reference to the input video, at which the overlay ends. The value should be in ISO 8601 format. For example, `PT30S` to end the overlay at 30 seconds into the input video. If not specified or the value is greater than the input video duration, the overlay will be applied until the end of the input video if the overlay media duration is greater than the input video duration, else the overlay will last as long as the overlay media duration.
        """
        return pulumi.get(self, "end")

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

    @property
    @pulumi.getter(name="fadeInDuration")
    def fade_in_duration(self) -> Optional[pulumi.Input[str]]:
        """
        The duration over which the overlay fades in onto the input video. The value should be in ISO 8601 duration format. If not specified the default behavior is to have no fade in (same as `PT0S`).
        """
        return pulumi.get(self, "fade_in_duration")

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

    @property
    @pulumi.getter(name="fadeOutDuration")
    def fade_out_duration(self) -> Optional[pulumi.Input[str]]:
        """
        The duration over which the overlay fades out of the input video. The value should be in ISO 8601 duration format. If not specified the default behavior is to have no fade out (same as `PT0S`).
        """
        return pulumi.get(self, "fade_out_duration")

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

    @property
    @pulumi.getter
    def start(self) -> Optional[pulumi.Input[str]]:
        """
        The start position, with reference to the input video, at which the overlay starts. The value should be in ISO 8601 format. For example, `PT05S` to start the overlay at 5 seconds into the input video. If not specified the overlay starts from the beginning of the input video.
        """
        return pulumi.get(self, "start")

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


@pulumi.input_type
class TransformOutputCustomPresetFilterOverlayVideoArgs:
    def __init__(__self__, *,
                 input_label: pulumi.Input[str],
                 audio_gain_level: Optional[pulumi.Input[float]] = None,
                 crop_rectangle: Optional[pulumi.Input['TransformOutputCustomPresetFilterOverlayVideoCropRectangleArgs']] = None,
                 end: Optional[pulumi.Input[str]] = None,
                 fade_in_duration: Optional[pulumi.Input[str]] = None,
                 fade_out_duration: Optional[pulumi.Input[str]] = None,
                 opacity: Optional[pulumi.Input[float]] = None,
                 position: Optional[pulumi.Input['TransformOutputCustomPresetFilterOverlayVideoPositionArgs']] = None,
                 start: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] input_label: The label of the job input which is to be used as an overlay. The input must specify exact one file. You can specify an image file in JPG, PNG, GIF or BMP format, or an audio file (such as a WAV, MP3, WMA or M4A file), or a video file.
        :param pulumi.Input[float] audio_gain_level: The gain level of audio in the overlay. The value should be in range between `0` to `1.0`. The default is `1.0`.
        :param pulumi.Input['TransformOutputCustomPresetFilterOverlayVideoCropRectangleArgs'] crop_rectangle: A `crop_rectangle` block as defined above.
        :param pulumi.Input[str] end: The end position, with reference to the input video, at which the overlay ends. The value should be in ISO 8601 format. For example, `PT30S` to end the overlay at 30 seconds into the input video. If not specified or the value is greater than the input video duration, the overlay will be applied until the end of the input video if the overlay media duration is greater than the input video duration, else the overlay will last as long as the overlay media duration.
        :param pulumi.Input[str] fade_in_duration: The duration over which the overlay fades in onto the input video. The value should be in ISO 8601 duration format. If not specified the default behavior is to have no fade in (same as `PT0S`).
        :param pulumi.Input[str] fade_out_duration: The duration over which the overlay fades out of the input video. The value should be in ISO 8601 duration format. If not specified the default behavior is to have no fade out (same as `PT0S`).
        :param pulumi.Input[float] opacity: The opacity of the overlay. The value should be in the range between `0` to `1.0`. Default to `1.0`, which means the overlay is opaque.
        :param pulumi.Input['TransformOutputCustomPresetFilterOverlayVideoPositionArgs'] position: A `position` block as defined above.
        :param pulumi.Input[str] start: The start position, with reference to the input video, at which the overlay starts. The value should be in ISO 8601 format. For example, `PT05S` to start the overlay at 5 seconds into the input video. If not specified the overlay starts from the beginning of the input video.
        """
        pulumi.set(__self__, "input_label", input_label)
        if audio_gain_level is not None:
            pulumi.set(__self__, "audio_gain_level", audio_gain_level)
        if crop_rectangle is not None:
            pulumi.set(__self__, "crop_rectangle", crop_rectangle)
        if end is not None:
            pulumi.set(__self__, "end", end)
        if fade_in_duration is not None:
            pulumi.set(__self__, "fade_in_duration", fade_in_duration)
        if fade_out_duration is not None:
            pulumi.set(__self__, "fade_out_duration", fade_out_duration)
        if opacity is not None:
            pulumi.set(__self__, "opacity", opacity)
        if position is not None:
            pulumi.set(__self__, "position", position)
        if start is not None:
            pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter(name="inputLabel")
    def input_label(self) -> pulumi.Input[str]:
        """
        The label of the job input which is to be used as an overlay. The input must specify exact one file. You can specify an image file in JPG, PNG, GIF or BMP format, or an audio file (such as a WAV, MP3, WMA or M4A file), or a video file.
        """
        return pulumi.get(self, "input_label")

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

    @property
    @pulumi.getter(name="audioGainLevel")
    def audio_gain_level(self) -> Optional[pulumi.Input[float]]:
        """
        The gain level of audio in the overlay. The value should be in range between `0` to `1.0`. The default is `1.0`.
        """
        return pulumi.get(self, "audio_gain_level")

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

    @property
    @pulumi.getter(name="cropRectangle")
    def crop_rectangle(self) -> Optional[pulumi.Input['TransformOutputCustomPresetFilterOverlayVideoCropRectangleArgs']]:
        """
        A `crop_rectangle` block as defined above.
        """
        return pulumi.get(self, "crop_rectangle")

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

    @property
    @pulumi.getter
    def end(self) -> Optional[pulumi.Input[str]]:
        """
        The end position, with reference to the input video, at which the overlay ends. The value should be in ISO 8601 format. For example, `PT30S` to end the overlay at 30 seconds into the input video. If not specified or the value is greater than the input video duration, the overlay will be applied until the end of the input video if the overlay media duration is greater than the input video duration, else the overlay will last as long as the overlay media duration.
        """
        return pulumi.get(self, "end")

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

    @property
    @pulumi.getter(name="fadeInDuration")
    def fade_in_duration(self) -> Optional[pulumi.Input[str]]:
        """
        The duration over which the overlay fades in onto the input video. The value should be in ISO 8601 duration format. If not specified the default behavior is to have no fade in (same as `PT0S`).
        """
        return pulumi.get(self, "fade_in_duration")

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

    @property
    @pulumi.getter(name="fadeOutDuration")
    def fade_out_duration(self) -> Optional[pulumi.Input[str]]:
        """
        The duration over which the overlay fades out of the input video. The value should be in ISO 8601 duration format. If not specified the default behavior is to have no fade out (same as `PT0S`).
        """
        return pulumi.get(self, "fade_out_duration")

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

    @property
    @pulumi.getter
    def opacity(self) -> Optional[pulumi.Input[float]]:
        """
        The opacity of the overlay. The value should be in the range between `0` to `1.0`. Default to `1.0`, which means the overlay is opaque.
        """
        return pulumi.get(self, "opacity")

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

    @property
    @pulumi.getter
    def position(self) -> Optional[pulumi.Input['TransformOutputCustomPresetFilterOverlayVideoPositionArgs']]:
        """
        A `position` block as defined above.
        """
        return pulumi.get(self, "position")

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

    @property
    @pulumi.getter
    def start(self) -> Optional[pulumi.Input[str]]:
        """
        The start position, with reference to the input video, at which the overlay starts. The value should be in ISO 8601 format. For example, `PT05S` to start the overlay at 5 seconds into the input video. If not specified the overlay starts from the beginning of the input video.
        """
        return pulumi.get(self, "start")

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


@pulumi.input_type
class TransformOutputCustomPresetFilterOverlayVideoCropRectangleArgs:
    def __init__(__self__, *,
                 height: Optional[pulumi.Input[str]] = None,
                 left: Optional[pulumi.Input[str]] = None,
                 top: Optional[pulumi.Input[str]] = None,
                 width: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] height: The height of the rectangular region in pixels. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        :param pulumi.Input[str] left: The number of pixels from the left-margin. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        :param pulumi.Input[str] top: The number of pixels from the top-margin. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        :param pulumi.Input[str] width: The width of the rectangular region in pixels. This can be absolute pixel value (e.g` 100`), or relative to the size of the video (For example, `50%`).
        """
        if height is not None:
            pulumi.set(__self__, "height", height)
        if left is not None:
            pulumi.set(__self__, "left", left)
        if top is not None:
            pulumi.set(__self__, "top", top)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def height(self) -> Optional[pulumi.Input[str]]:
        """
        The height of the rectangular region in pixels. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        """
        return pulumi.get(self, "height")

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

    @property
    @pulumi.getter
    def left(self) -> Optional[pulumi.Input[str]]:
        """
        The number of pixels from the left-margin. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        """
        return pulumi.get(self, "left")

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

    @property
    @pulumi.getter
    def top(self) -> Optional[pulumi.Input[str]]:
        """
        The number of pixels from the top-margin. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        """
        return pulumi.get(self, "top")

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

    @property
    @pulumi.getter
    def width(self) -> Optional[pulumi.Input[str]]:
        """
        The width of the rectangular region in pixels. This can be absolute pixel value (e.g` 100`), or relative to the size of the video (For example, `50%`).
        """
        return pulumi.get(self, "width")

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


@pulumi.input_type
class TransformOutputCustomPresetFilterOverlayVideoPositionArgs:
    def __init__(__self__, *,
                 height: Optional[pulumi.Input[str]] = None,
                 left: Optional[pulumi.Input[str]] = None,
                 top: Optional[pulumi.Input[str]] = None,
                 width: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] height: The height of the rectangular region in pixels. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        :param pulumi.Input[str] left: The number of pixels from the left-margin. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        :param pulumi.Input[str] top: The number of pixels from the top-margin. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        :param pulumi.Input[str] width: The width of the rectangular region in pixels. This can be absolute pixel value (e.g` 100`), or relative to the size of the video (For example, `50%`).
        """
        if height is not None:
            pulumi.set(__self__, "height", height)
        if left is not None:
            pulumi.set(__self__, "left", left)
        if top is not None:
            pulumi.set(__self__, "top", top)
        if width is not None:
            pulumi.set(__self__, "width", width)

    @property
    @pulumi.getter
    def height(self) -> Optional[pulumi.Input[str]]:
        """
        The height of the rectangular region in pixels. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        """
        return pulumi.get(self, "height")

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

    @property
    @pulumi.getter
    def left(self) -> Optional[pulumi.Input[str]]:
        """
        The number of pixels from the left-margin. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        """
        return pulumi.get(self, "left")

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

    @property
    @pulumi.getter
    def top(self) -> Optional[pulumi.Input[str]]:
        """
        The number of pixels from the top-margin. This can be absolute pixel value (e.g `100`), or relative to the size of the video (For example, `50%`).
        """
        return pulumi.get(self, "top")

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

    @property
    @pulumi.getter
    def width(self) -> Optional[pulumi.Input[str]]:
        """
        The width of the rectangular region in pixels. This can be absolute pixel value (e.g` 100`), or relative to the size of the video (For example, `50%`).
        """
        return pulumi.get(self, "width")

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


@pulumi.input_type
class TransformOutputCustomPresetFormatArgs:
    def __init__(__self__, *,
                 jpg: Optional[pulumi.Input['TransformOutputCustomPresetFormatJpgArgs']] = None,
                 mp4: Optional[pulumi.Input['TransformOutputCustomPresetFormatMp4Args']] = None,
                 png: Optional[pulumi.Input['TransformOutputCustomPresetFormatPngArgs']] = None,
                 transport_stream: Optional[pulumi.Input['TransformOutputCustomPresetFormatTransportStreamArgs']] = None):
        """
        :param pulumi.Input['TransformOutputCustomPresetFormatJpgArgs'] jpg: A `jpg` block as defined below.
        :param pulumi.Input['TransformOutputCustomPresetFormatMp4Args'] mp4: A `mp4` block as defined below.
        :param pulumi.Input['TransformOutputCustomPresetFormatPngArgs'] png: A `png` block as defined below.
        :param pulumi.Input['TransformOutputCustomPresetFormatTransportStreamArgs'] transport_stream: A `transport_stream` block as defined below.
               
               > **NOTE:** Each format can only have one type: `jpg`, `mp4`, `png` or `transport_stream`. If you need to apply different type you must create one format for each one.
        """
        if jpg is not None:
            pulumi.set(__self__, "jpg", jpg)
        if mp4 is not None:
            pulumi.set(__self__, "mp4", mp4)
        if png is not None:
            pulumi.set(__self__, "png", png)
        if transport_stream is not None:
            pulumi.set(__self__, "transport_stream", transport_stream)

    @property
    @pulumi.getter
    def jpg(self) -> Optional[pulumi.Input['TransformOutputCustomPresetFormatJpgArgs']]:
        """
        A `jpg` block as defined below.
        """
        return pulumi.get(self, "jpg")

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

    @property
    @pulumi.getter
    def mp4(self) -> Optional[pulumi.Input['TransformOutputCustomPresetFormatMp4Args']]:
        """
        A `mp4` block as defined below.
        """
        return pulumi.get(self, "mp4")

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

    @property
    @pulumi.getter
    def png(self) -> Optional[pulumi.Input['TransformOutputCustomPresetFormatPngArgs']]:
        """
        A `png` block as defined below.
        """
        return pulumi.get(self, "png")

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

    @property
    @pulumi.getter(name="transportStream")
    def transport_stream(self) -> Optional[pulumi.Input['TransformOutputCustomPresetFormatTransportStreamArgs']]:
        """
        A `transport_stream` block as defined below.

        > **NOTE:** Each format can only have one type: `jpg`, `mp4`, `png` or `transport_stream`. If you need to apply different type you must create one format for each one.
        """
        return pulumi.get(self, "transport_stream")

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


@pulumi.input_type
class TransformOutputCustomPresetFormatJpgArgs:
    def __init__(__self__, *,
                 filename_pattern: pulumi.Input[str]):
        """
        :param pulumi.Input[str] filename_pattern: The file naming pattern used for the creation of output files. The following macros are supported in the file name: `{Basename}` - An expansion macro that will use the name of the input video file. If the base name(the file suffix is not included) of the input video file is less than 32 characters long, the base name of input video files will be used. If the length of base name of the input video file exceeds 32 characters, the base name is truncated to the first 32 characters in total length. `{Extension}` - The appropriate extension for this format. `{Label}` - The label assigned to the codec/layer. `{Index}` - A unique index for thumbnails. Only applicable to thumbnails. `{AudioStream}` - string "Audio" plus audio stream number(start from 1). `{Bitrate}` - The audio/video bitrate in kbps. Not applicable to thumbnails. `{Codec}` - The type of the audio/video codec. `{Resolution}` - The video resolution. Any unsubstituted macros will be collapsed and removed from the filename.
        """
        pulumi.set(__self__, "filename_pattern", filename_pattern)

    @property
    @pulumi.getter(name="filenamePattern")
    def filename_pattern(self) -> pulumi.Input[str]:
        """
        The file naming pattern used for the creation of output files. The following macros are supported in the file name: `{Basename}` - An expansion macro that will use the name of the input video file. If the base name(the file suffix is not included) of the input video file is less than 32 characters long, the base name of input video files will be used. If the length of base name of the input video file exceeds 32 characters, the base name is truncated to the first 32 characters in total length. `{Extension}` - The appropriate extension for this format. `{Label}` - The label assigned to the codec/layer. `{Index}` - A unique index for thumbnails. Only applicable to thumbnails. `{AudioStream}` - string "Audio" plus audio stream number(start from 1). `{Bitrate}` - The audio/video bitrate in kbps. Not applicable to thumbnails. `{Codec}` - The type of the audio/video codec. `{Resolution}` - The video resolution. Any unsubstituted macros will be collapsed and removed from the filename.
        """
        return pulumi.get(self, "filename_pattern")

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


@pulumi.input_type
class TransformOutputCustomPresetFormatMp4Args:
    def __init__(__self__, *,
                 filename_pattern: pulumi.Input[str],
                 output_files: Optional[pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetFormatMp4OutputFileArgs']]]] = None):
        """
        :param pulumi.Input[str] filename_pattern: The file naming pattern used for the creation of output files. The following macros are supported in the file name: `{Basename}` - An expansion macro that will use the name of the input video file. If the base name(the file suffix is not included) of the input video file is less than 32 characters long, the base name of input video files will be used. If the length of base name of the input video file exceeds 32 characters, the base name is truncated to the first 32 characters in total length. `{Extension}` - The appropriate extension for this format. `{Label}` - The label assigned to the codec/layer. `{Index}` - A unique index for thumbnails. Only applicable to thumbnails. `{AudioStream}` - string "Audio" plus audio stream number(start from 1). `{Bitrate}` - The audio/video bitrate in kbps. Not applicable to thumbnails. `{Codec}` - The type of the audio/video codec. `{Resolution}` - The video resolution. Any unsubstituted macros will be collapsed and removed from the filename.
        :param pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetFormatMp4OutputFileArgs']]] output_files: One or more `output_file` blocks as defined below.
        """
        pulumi.set(__self__, "filename_pattern", filename_pattern)
        if output_files is not None:
            pulumi.set(__self__, "output_files", output_files)

    @property
    @pulumi.getter(name="filenamePattern")
    def filename_pattern(self) -> pulumi.Input[str]:
        """
        The file naming pattern used for the creation of output files. The following macros are supported in the file name: `{Basename}` - An expansion macro that will use the name of the input video file. If the base name(the file suffix is not included) of the input video file is less than 32 characters long, the base name of input video files will be used. If the length of base name of the input video file exceeds 32 characters, the base name is truncated to the first 32 characters in total length. `{Extension}` - The appropriate extension for this format. `{Label}` - The label assigned to the codec/layer. `{Index}` - A unique index for thumbnails. Only applicable to thumbnails. `{AudioStream}` - string "Audio" plus audio stream number(start from 1). `{Bitrate}` - The audio/video bitrate in kbps. Not applicable to thumbnails. `{Codec}` - The type of the audio/video codec. `{Resolution}` - The video resolution. Any unsubstituted macros will be collapsed and removed from the filename.
        """
        return pulumi.get(self, "filename_pattern")

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

    @property
    @pulumi.getter(name="outputFiles")
    def output_files(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetFormatMp4OutputFileArgs']]]]:
        """
        One or more `output_file` blocks as defined below.
        """
        return pulumi.get(self, "output_files")

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


@pulumi.input_type
class TransformOutputCustomPresetFormatMp4OutputFileArgs:
    def __init__(__self__, *,
                 labels: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: The list of labels that describe how the encoder should multiplex video and audio into an output file. For example, if the encoder is producing two video layers with labels `v1` and `v2`, and one audio layer with label `a1`, then an array like `["v1", "a1"]` tells the encoder to produce an output file with the video track represented by `v1` and the audio track represented by `a1`.
        """
        pulumi.set(__self__, "labels", labels)

    @property
    @pulumi.getter
    def labels(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The list of labels that describe how the encoder should multiplex video and audio into an output file. For example, if the encoder is producing two video layers with labels `v1` and `v2`, and one audio layer with label `a1`, then an array like `["v1", "a1"]` tells the encoder to produce an output file with the video track represented by `v1` and the audio track represented by `a1`.
        """
        return pulumi.get(self, "labels")

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


@pulumi.input_type
class TransformOutputCustomPresetFormatPngArgs:
    def __init__(__self__, *,
                 filename_pattern: pulumi.Input[str]):
        """
        :param pulumi.Input[str] filename_pattern: The file naming pattern used for the creation of output files. The following macros are supported in the file name: `{Basename}` - An expansion macro that will use the name of the input video file. If the base name(the file suffix is not included) of the input video file is less than 32 characters long, the base name of input video files will be used. If the length of base name of the input video file exceeds 32 characters, the base name is truncated to the first 32 characters in total length. `{Extension}` - The appropriate extension for this format. `{Label}` - The label assigned to the codec/layer. `{Index}` - A unique index for thumbnails. Only applicable to thumbnails. `{AudioStream}` - string "Audio" plus audio stream number(start from 1). `{Bitrate}` - The audio/video bitrate in kbps. Not applicable to thumbnails. `{Codec}` - The type of the audio/video codec. `{Resolution}` - The video resolution. Any unsubstituted macros will be collapsed and removed from the filename.
        """
        pulumi.set(__self__, "filename_pattern", filename_pattern)

    @property
    @pulumi.getter(name="filenamePattern")
    def filename_pattern(self) -> pulumi.Input[str]:
        """
        The file naming pattern used for the creation of output files. The following macros are supported in the file name: `{Basename}` - An expansion macro that will use the name of the input video file. If the base name(the file suffix is not included) of the input video file is less than 32 characters long, the base name of input video files will be used. If the length of base name of the input video file exceeds 32 characters, the base name is truncated to the first 32 characters in total length. `{Extension}` - The appropriate extension for this format. `{Label}` - The label assigned to the codec/layer. `{Index}` - A unique index for thumbnails. Only applicable to thumbnails. `{AudioStream}` - string "Audio" plus audio stream number(start from 1). `{Bitrate}` - The audio/video bitrate in kbps. Not applicable to thumbnails. `{Codec}` - The type of the audio/video codec. `{Resolution}` - The video resolution. Any unsubstituted macros will be collapsed and removed from the filename.
        """
        return pulumi.get(self, "filename_pattern")

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


@pulumi.input_type
class TransformOutputCustomPresetFormatTransportStreamArgs:
    def __init__(__self__, *,
                 filename_pattern: pulumi.Input[str],
                 output_files: Optional[pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetFormatTransportStreamOutputFileArgs']]]] = None):
        """
        :param pulumi.Input[str] filename_pattern: The file naming pattern used for the creation of output files. The following macros are supported in the file name: `{Basename}` - An expansion macro that will use the name of the input video file. If the base name(the file suffix is not included) of the input video file is less than 32 characters long, the base name of input video files will be used. If the length of base name of the input video file exceeds 32 characters, the base name is truncated to the first 32 characters in total length. `{Extension}` - The appropriate extension for this format. `{Label}` - The label assigned to the codec/layer. `{Index}` - A unique index for thumbnails. Only applicable to thumbnails. `{AudioStream}` - string "Audio" plus audio stream number(start from 1). `{Bitrate}` - The audio/video bitrate in kbps. Not applicable to thumbnails. `{Codec}` - The type of the audio/video codec. `{Resolution}` - The video resolution. Any unsubstituted macros will be collapsed and removed from the filename.
        :param pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetFormatTransportStreamOutputFileArgs']]] output_files: One or more `output_file` blocks as defined above.
        """
        pulumi.set(__self__, "filename_pattern", filename_pattern)
        if output_files is not None:
            pulumi.set(__self__, "output_files", output_files)

    @property
    @pulumi.getter(name="filenamePattern")
    def filename_pattern(self) -> pulumi.Input[str]:
        """
        The file naming pattern used for the creation of output files. The following macros are supported in the file name: `{Basename}` - An expansion macro that will use the name of the input video file. If the base name(the file suffix is not included) of the input video file is less than 32 characters long, the base name of input video files will be used. If the length of base name of the input video file exceeds 32 characters, the base name is truncated to the first 32 characters in total length. `{Extension}` - The appropriate extension for this format. `{Label}` - The label assigned to the codec/layer. `{Index}` - A unique index for thumbnails. Only applicable to thumbnails. `{AudioStream}` - string "Audio" plus audio stream number(start from 1). `{Bitrate}` - The audio/video bitrate in kbps. Not applicable to thumbnails. `{Codec}` - The type of the audio/video codec. `{Resolution}` - The video resolution. Any unsubstituted macros will be collapsed and removed from the filename.
        """
        return pulumi.get(self, "filename_pattern")

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

    @property
    @pulumi.getter(name="outputFiles")
    def output_files(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TransformOutputCustomPresetFormatTransportStreamOutputFileArgs']]]]:
        """
        One or more `output_file` blocks as defined above.
        """
        return pulumi.get(self, "output_files")

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


@pulumi.input_type
class TransformOutputCustomPresetFormatTransportStreamOutputFileArgs:
    def __init__(__self__, *,
                 labels: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] labels: The list of labels that describe how the encoder should multiplex video and audio into an output file. For example, if the encoder is producing two video layers with labels `v1` and `v2`, and one audio layer with label `a1`, then an array like `["v1", "a1"]` tells the encoder to produce an output file with the video track represented by `v1` and the audio track represented by `a1`.
        """
        pulumi.set(__self__, "labels", labels)

    @property
    @pulumi.getter
    def labels(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The list of labels that describe how the encoder should multiplex video and audio into an output file. For example, if the encoder is producing two video layers with labels `v1` and `v2`, and one audio layer with label `a1`, then an array like `["v1", "a1"]` tells the encoder to produce an output file with the video track represented by `v1` and the audio track represented by `a1`.
        """
        return pulumi.get(self, "labels")

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


@pulumi.input_type
class TransformOutputFaceDetectorPresetArgs:
    def __init__(__self__, *,
                 analysis_resolution: Optional[pulumi.Input[str]] = None,
                 blur_type: Optional[pulumi.Input[str]] = None,
                 experimental_options: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 face_redactor_mode: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] analysis_resolution: Possible values are `SourceResolution` or `StandardDefinition`. Specifies the maximum resolution at which your video is analyzed. which will keep the input video at its original resolution when analyzed. Using `StandardDefinition` will resize input videos to standard definition while preserving the appropriate aspect ratio. It will only resize if the video is of higher resolution. For example, a 1920x1080 input would be scaled to 640x360 before processing. Switching to `StandardDefinition` will reduce the time it takes to process high resolution video. It may also reduce the cost of using this component (see <https://azure.microsoft.com/en-us/pricing/details/media-services/#analytics> for details). However, faces that end up being too small in the resized video may not be detected. Default to `SourceResolution`.
        :param pulumi.Input[str] blur_type: Specifies the type of blur to apply to faces in the output video. Possible values are `Black`, `Box`, `High`, `Low`,and `Med`.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] experimental_options: Dictionary containing key value pairs for parameters not exposed in the preset itself.
        :param pulumi.Input[str] face_redactor_mode: This mode provides the ability to choose between the following settings: 1) `Analyze` - For detection only. This mode generates a metadata JSON file marking appearances of faces throughout the video. Where possible, appearances of the same person are assigned the same ID. 2) `Combined` - Additionally redacts(blurs) detected faces. 3) `Redact` - This enables a 2-pass process, allowing for selective redaction of a subset of detected faces. It takes in the metadata file from a prior analyze pass, along with the source video, and a user-selected subset of IDs that require redaction. Default to `Analyze`.
        """
        if analysis_resolution is not None:
            pulumi.set(__self__, "analysis_resolution", analysis_resolution)
        if blur_type is not None:
            pulumi.set(__self__, "blur_type", blur_type)
        if experimental_options is not None:
            pulumi.set(__self__, "experimental_options", experimental_options)
        if face_redactor_mode is not None:
            pulumi.set(__self__, "face_redactor_mode", face_redactor_mode)

    @property
    @pulumi.getter(name="analysisResolution")
    def analysis_resolution(self) -> Optional[pulumi.Input[str]]:
        """
        Possible values are `SourceResolution` or `StandardDefinition`. Specifies the maximum resolution at which your video is analyzed. which will keep the input video at its original resolution when analyzed. Using `StandardDefinition` will resize input videos to standard definition while preserving the appropriate aspect ratio. It will only resize if the video is of higher resolution. For example, a 1920x1080 input would be scaled to 640x360 before processing. Switching to `StandardDefinition` will reduce the time it takes to process high resolution video. It may also reduce the cost of using this component (see <https://azure.microsoft.com/en-us/pricing/details/media-services/#analytics> for details). However, faces that end up being too small in the resized video may not be detected. Default to `SourceResolution`.
        """
        return pulumi.get(self, "analysis_resolution")

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

    @property
    @pulumi.getter(name="blurType")
    def blur_type(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the type of blur to apply to faces in the output video. Possible values are `Black`, `Box`, `High`, `Low`,and `Med`.
        """
        return pulumi.get(self, "blur_type")

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

    @property
    @pulumi.getter(name="experimentalOptions")
    def experimental_options(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Dictionary containing key value pairs for parameters not exposed in the preset itself.
        """
        return pulumi.get(self, "experimental_options")

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

    @property
    @pulumi.getter(name="faceRedactorMode")
    def face_redactor_mode(self) -> Optional[pulumi.Input[str]]:
        """
        This mode provides the ability to choose between the following settings: 1) `Analyze` - For detection only. This mode generates a metadata JSON file marking appearances of faces throughout the video. Where possible, appearances of the same person are assigned the same ID. 2) `Combined` - Additionally redacts(blurs) detected faces. 3) `Redact` - This enables a 2-pass process, allowing for selective redaction of a subset of detected faces. It takes in the metadata file from a prior analyze pass, along with the source video, and a user-selected subset of IDs that require redaction. Default to `Analyze`.
        """
        return pulumi.get(self, "face_redactor_mode")

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


@pulumi.input_type
class TransformOutputVideoAnalyzerPresetArgs:
    def __init__(__self__, *,
                 audio_analysis_mode: Optional[pulumi.Input[str]] = None,
                 audio_language: Optional[pulumi.Input[str]] = None,
                 experimental_options: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                 insights_type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] audio_analysis_mode: Possible values are `Basic` or `Standard`. Determines the set of audio analysis operations to be performed. Default to `Standard`.
        :param pulumi.Input[str] audio_language: The language for the audio payload in the input using the BCP-47 format of 'language tag-region' (e.g: 'en-US'). If you know the language of your content, it is recommended that you specify it. The language must be specified explicitly for AudioAnalysisMode:Basic, since automatic language detection is not included in basic mode. If the language isn't specified, automatic language detection will choose the first language detected and process with the selected language for the duration of the file. It does not currently support dynamically switching between languages after the first language is detected. The automatic detection works best with audio recordings with clearly discernible speech. If automatic detection fails to find the language, transcription would fall back to `en-US`. The list of supported languages is available here: <https://go.microsoft.com/fwlink/?linkid=2109463>.
        :param pulumi.Input[Mapping[str, pulumi.Input[str]]] experimental_options: Dictionary containing key value pairs for parameters not exposed in the preset itself.
        :param pulumi.Input[str] insights_type: Defines the type of insights that you want the service to generate. The allowed values are `AudioInsightsOnly`, `VideoInsightsOnly`, and `AllInsights`. If you set this to `AllInsights` and the input is audio only, then only audio insights are generated. Similarly, if the input is video only, then only video insights are generated. It is recommended that you not use `AudioInsightsOnly` if you expect some of your inputs to be video only; or use `VideoInsightsOnly` if you expect some of your inputs to be audio only. Your Jobs in such conditions would error out. Default to `AllInsights`.
        """
        if audio_analysis_mode is not None:
            pulumi.set(__self__, "audio_analysis_mode", audio_analysis_mode)
        if audio_language is not None:
            pulumi.set(__self__, "audio_language", audio_language)
        if experimental_options is not None:
            pulumi.set(__self__, "experimental_options", experimental_options)
        if insights_type is not None:
            pulumi.set(__self__, "insights_type", insights_type)

    @property
    @pulumi.getter(name="audioAnalysisMode")
    def audio_analysis_mode(self) -> Optional[pulumi.Input[str]]:
        """
        Possible values are `Basic` or `Standard`. Determines the set of audio analysis operations to be performed. Default to `Standard`.
        """
        return pulumi.get(self, "audio_analysis_mode")

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

    @property
    @pulumi.getter(name="audioLanguage")
    def audio_language(self) -> Optional[pulumi.Input[str]]:
        """
        The language for the audio payload in the input using the BCP-47 format of 'language tag-region' (e.g: 'en-US'). If you know the language of your content, it is recommended that you specify it. The language must be specified explicitly for AudioAnalysisMode:Basic, since automatic language detection is not included in basic mode. If the language isn't specified, automatic language detection will choose the first language detected and process with the selected language for the duration of the file. It does not currently support dynamically switching between languages after the first language is detected. The automatic detection works best with audio recordings with clearly discernible speech. If automatic detection fails to find the language, transcription would fall back to `en-US`. The list of supported languages is available here: <https://go.microsoft.com/fwlink/?linkid=2109463>.
        """
        return pulumi.get(self, "audio_language")

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

    @property
    @pulumi.getter(name="experimentalOptions")
    def experimental_options(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
        """
        Dictionary containing key value pairs for parameters not exposed in the preset itself.
        """
        return pulumi.get(self, "experimental_options")

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

    @property
    @pulumi.getter(name="insightsType")
    def insights_type(self) -> Optional[pulumi.Input[str]]:
        """
        Defines the type of insights that you want the service to generate. The allowed values are `AudioInsightsOnly`, `VideoInsightsOnly`, and `AllInsights`. If you set this to `AllInsights` and the input is audio only, then only audio insights are generated. Similarly, if the input is video only, then only video insights are generated. It is recommended that you not use `AudioInsightsOnly` if you expect some of your inputs to be video only; or use `VideoInsightsOnly` if you expect some of your inputs to be audio only. Your Jobs in such conditions would error out. Default to `AllInsights`.
        """
        return pulumi.get(self, "insights_type")

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


