# 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
from . import outputs

__all__ = [
    'AccountFilterPresentationTimeRange',
    'AccountFilterTrackSelection',
    'AccountFilterTrackSelectionCondition',
    'AssetFilterPresentationTimeRange',
    'AssetFilterTrackSelection',
    'AssetFilterTrackSelectionCondition',
    'ContentKeyPolicyPolicyOption',
    'ContentKeyPolicyPolicyOptionFairplayConfiguration',
    'ContentKeyPolicyPolicyOptionFairplayConfigurationOfflineRentalConfiguration',
    'ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicense',
    'ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRight',
    'ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightExplicitAnalogTelevisionOutputRestriction',
    'ContentKeyPolicyPolicyOptionTokenRestriction',
    'ContentKeyPolicyPolicyOptionTokenRestrictionAlternateKey',
    'ContentKeyPolicyPolicyOptionTokenRestrictionRequiredClaim',
    'JobInputAsset',
    'JobOutputAsset',
    'LiveEventCrossSiteAccessPolicy',
    'LiveEventEncoding',
    'LiveEventInput',
    'LiveEventInputEndpoint',
    'LiveEventInputIpAccessControlAllow',
    'LiveEventPreview',
    'LiveEventPreviewEndpoint',
    'LiveEventPreviewIpAccessControlAllow',
    'ServiceAccountEncryption',
    'ServiceAccountEncryptionManagedIdentity',
    'ServiceAccountIdentity',
    'ServiceAccountKeyDeliveryAccessControl',
    'ServiceAccountStorageAccount',
    'ServiceAccountStorageAccountManagedIdentity',
    'StreamingEndpointAccessControl',
    'StreamingEndpointAccessControlAkamaiSignatureHeaderAuthenticationKey',
    'StreamingEndpointAccessControlIpAllow',
    'StreamingEndpointCrossSiteAccessPolicy',
    'StreamingEndpointSkus',
    'StreamingLocatorContentKey',
    'StreamingPolicyCommonEncryptionCbcs',
    'StreamingPolicyCommonEncryptionCbcsClearKeyEncryption',
    'StreamingPolicyCommonEncryptionCbcsDefaultContentKey',
    'StreamingPolicyCommonEncryptionCbcsDrmFairplay',
    'StreamingPolicyCommonEncryptionCbcsEnabledProtocols',
    'StreamingPolicyCommonEncryptionCenc',
    'StreamingPolicyCommonEncryptionCencClearKeyEncryption',
    'StreamingPolicyCommonEncryptionCencClearTrack',
    'StreamingPolicyCommonEncryptionCencClearTrackCondition',
    'StreamingPolicyCommonEncryptionCencContentKeyToTrackMapping',
    'StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrack',
    'StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrackCondition',
    'StreamingPolicyCommonEncryptionCencDefaultContentKey',
    'StreamingPolicyCommonEncryptionCencDrmPlayready',
    'StreamingPolicyCommonEncryptionCencEnabledProtocols',
    'StreamingPolicyEnvelopeEncryption',
    'StreamingPolicyEnvelopeEncryptionDefaultContentKey',
    'StreamingPolicyEnvelopeEncryptionEnabledProtocols',
    'StreamingPolicyNoEncryptionEnabledProtocols',
    'TransformOutput',
    'TransformOutputAudioAnalyzerPreset',
    'TransformOutputBuiltinPreset',
    'TransformOutputBuiltinPresetPresetConfiguration',
    'TransformOutputCustomPreset',
    'TransformOutputCustomPresetCodec',
    'TransformOutputCustomPresetCodecAacAudio',
    'TransformOutputCustomPresetCodecCopyAudio',
    'TransformOutputCustomPresetCodecCopyVideo',
    'TransformOutputCustomPresetCodecDdAudio',
    'TransformOutputCustomPresetCodecH264Video',
    'TransformOutputCustomPresetCodecH264VideoLayer',
    'TransformOutputCustomPresetCodecH265Video',
    'TransformOutputCustomPresetCodecH265VideoLayer',
    'TransformOutputCustomPresetCodecJpgImage',
    'TransformOutputCustomPresetCodecJpgImageLayer',
    'TransformOutputCustomPresetCodecPngImage',
    'TransformOutputCustomPresetCodecPngImageLayer',
    'TransformOutputCustomPresetFilter',
    'TransformOutputCustomPresetFilterCropRectangle',
    'TransformOutputCustomPresetFilterDeinterlace',
    'TransformOutputCustomPresetFilterFadeIn',
    'TransformOutputCustomPresetFilterFadeOut',
    'TransformOutputCustomPresetFilterOverlay',
    'TransformOutputCustomPresetFilterOverlayAudio',
    'TransformOutputCustomPresetFilterOverlayVideo',
    'TransformOutputCustomPresetFilterOverlayVideoCropRectangle',
    'TransformOutputCustomPresetFilterOverlayVideoPosition',
    'TransformOutputCustomPresetFormat',
    'TransformOutputCustomPresetFormatJpg',
    'TransformOutputCustomPresetFormatMp4',
    'TransformOutputCustomPresetFormatMp4OutputFile',
    'TransformOutputCustomPresetFormatPng',
    'TransformOutputCustomPresetFormatTransportStream',
    'TransformOutputCustomPresetFormatTransportStreamOutputFile',
    'TransformOutputFaceDetectorPreset',
    'TransformOutputVideoAnalyzerPreset',
]

@pulumi.output_type
class AccountFilterPresentationTimeRange(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "unitTimescaleInMilliseconds":
            suggest = "unit_timescale_in_milliseconds"
        elif key == "endInUnits":
            suggest = "end_in_units"
        elif key == "forceEnd":
            suggest = "force_end"
        elif key == "liveBackoffInUnits":
            suggest = "live_backoff_in_units"
        elif key == "presentationWindowInUnits":
            suggest = "presentation_window_in_units"
        elif key == "startInUnits":
            suggest = "start_in_units"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AccountFilterPresentationTimeRange. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AccountFilterPresentationTimeRange.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AccountFilterPresentationTimeRange.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 unit_timescale_in_milliseconds: int,
                 end_in_units: Optional[int] = None,
                 force_end: Optional[bool] = None,
                 live_backoff_in_units: Optional[int] = None,
                 presentation_window_in_units: Optional[int] = None,
                 start_in_units: Optional[int] = None):
        """
        :param 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 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 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 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 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 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) -> 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")

    @property
    @pulumi.getter(name="endInUnits")
    def end_in_units(self) -> Optional[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")

    @property
    @pulumi.getter(name="forceEnd")
    def force_end(self) -> Optional[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")

    @property
    @pulumi.getter(name="liveBackoffInUnits")
    def live_backoff_in_units(self) -> Optional[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")

    @property
    @pulumi.getter(name="presentationWindowInUnits")
    def presentation_window_in_units(self) -> Optional[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")

    @property
    @pulumi.getter(name="startInUnits")
    def start_in_units(self) -> Optional[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")


@pulumi.output_type
class AccountFilterTrackSelection(dict):
    def __init__(__self__, *,
                 conditions: Sequence['outputs.AccountFilterTrackSelectionCondition']):
        """
        :param Sequence['AccountFilterTrackSelectionConditionArgs'] conditions: One or more `selection` blocks as defined above.
        """
        pulumi.set(__self__, "conditions", conditions)

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


@pulumi.output_type
class AccountFilterTrackSelectionCondition(dict):
    def __init__(__self__, *,
                 operation: str,
                 property: str,
                 value: str):
        """
        :param str operation: The condition operation to test a track property against. Supported values are `Equal` and `NotEqual`.
        :param 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 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) -> str:
        """
        The condition operation to test a track property against. Supported values are `Equal` and `NotEqual`.
        """
        return pulumi.get(self, "operation")

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

    @property
    @pulumi.getter
    def property(self) -> 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")


@pulumi.output_type
class AssetFilterPresentationTimeRange(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endInUnits":
            suggest = "end_in_units"
        elif key == "forceEnd":
            suggest = "force_end"
        elif key == "liveBackoffInUnits":
            suggest = "live_backoff_in_units"
        elif key == "presentationWindowInUnits":
            suggest = "presentation_window_in_units"
        elif key == "startInUnits":
            suggest = "start_in_units"
        elif key == "unitTimescaleInMiliseconds":
            suggest = "unit_timescale_in_miliseconds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in AssetFilterPresentationTimeRange. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        AssetFilterPresentationTimeRange.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        AssetFilterPresentationTimeRange.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 end_in_units: Optional[int] = None,
                 force_end: Optional[bool] = None,
                 live_backoff_in_units: Optional[int] = None,
                 presentation_window_in_units: Optional[int] = None,
                 start_in_units: Optional[int] = None,
                 unit_timescale_in_miliseconds: Optional[int] = None):
        """
        :param 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 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 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 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 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 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[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")

    @property
    @pulumi.getter(name="forceEnd")
    def force_end(self) -> Optional[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")

    @property
    @pulumi.getter(name="liveBackoffInUnits")
    def live_backoff_in_units(self) -> Optional[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")

    @property
    @pulumi.getter(name="presentationWindowInUnits")
    def presentation_window_in_units(self) -> Optional[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")

    @property
    @pulumi.getter(name="startInUnits")
    def start_in_units(self) -> Optional[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")

    @property
    @pulumi.getter(name="unitTimescaleInMiliseconds")
    def unit_timescale_in_miliseconds(self) -> Optional[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")


@pulumi.output_type
class AssetFilterTrackSelection(dict):
    def __init__(__self__, *,
                 conditions: Sequence['outputs.AssetFilterTrackSelectionCondition']):
        """
        :param Sequence['AssetFilterTrackSelectionConditionArgs'] conditions: One or more `condition` blocks as defined above.
        """
        pulumi.set(__self__, "conditions", conditions)

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


@pulumi.output_type
class AssetFilterTrackSelectionCondition(dict):
    def __init__(__self__, *,
                 operation: Optional[str] = None,
                 property: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str operation: The condition operation to test a track property against. Supported values are `Equal` and `NotEqual`.
        :param 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 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[str]:
        """
        The condition operation to test a track property against. Supported values are `Equal` and `NotEqual`.
        """
        return pulumi.get(self, "operation")

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

    @property
    @pulumi.getter
    def property(self) -> Optional[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")


@pulumi.output_type
class ContentKeyPolicyPolicyOption(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clearKeyConfigurationEnabled":
            suggest = "clear_key_configuration_enabled"
        elif key == "fairplayConfiguration":
            suggest = "fairplay_configuration"
        elif key == "openRestrictionEnabled":
            suggest = "open_restriction_enabled"
        elif key == "playreadyConfigurationLicenses":
            suggest = "playready_configuration_licenses"
        elif key == "playreadyResponseCustomData":
            suggest = "playready_response_custom_data"
        elif key == "tokenRestriction":
            suggest = "token_restriction"
        elif key == "widevineConfigurationTemplate":
            suggest = "widevine_configuration_template"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ContentKeyPolicyPolicyOption. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ContentKeyPolicyPolicyOption.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ContentKeyPolicyPolicyOption.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 name: str,
                 clear_key_configuration_enabled: Optional[bool] = None,
                 fairplay_configuration: Optional['outputs.ContentKeyPolicyPolicyOptionFairplayConfiguration'] = None,
                 open_restriction_enabled: Optional[bool] = None,
                 playready_configuration_licenses: Optional[Sequence['outputs.ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicense']] = None,
                 playready_response_custom_data: Optional[str] = None,
                 token_restriction: Optional['outputs.ContentKeyPolicyPolicyOptionTokenRestriction'] = None,
                 widevine_configuration_template: Optional[str] = None):
        """
        :param str name: The name which should be used for this Policy Option.
        :param bool clear_key_configuration_enabled: Enable a configuration for non-DRM keys.
        :param '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 bool open_restriction_enabled: Enable an open restriction. License or key will be delivered on every request.
        :param Sequence['ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicenseArgs'] playready_configuration_licenses: One or more `playready_configuration_license` blocks as defined above.
        :param str playready_response_custom_data: The custom response data of the PlayReady configuration. This only applies when `playready_configuration_license` is specified.
        :param 'ContentKeyPolicyPolicyOptionTokenRestrictionArgs' token_restriction: A `token_restriction` block as defined below.
        :param 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) -> str:
        """
        The name which should be used for this Policy Option.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter(name="fairplayConfiguration")
    def fairplay_configuration(self) -> Optional['outputs.ContentKeyPolicyPolicyOptionFairplayConfiguration']:
        """
        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")

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

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

    @property
    @pulumi.getter(name="playreadyResponseCustomData")
    def playready_response_custom_data(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="widevineConfigurationTemplate")
    def widevine_configuration_template(self) -> Optional[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")


@pulumi.output_type
class ContentKeyPolicyPolicyOptionFairplayConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "offlineRentalConfiguration":
            suggest = "offline_rental_configuration"
        elif key == "pfxPassword":
            suggest = "pfx_password"
        elif key == "rentalAndLeaseKeyType":
            suggest = "rental_and_lease_key_type"
        elif key == "rentalDurationSeconds":
            suggest = "rental_duration_seconds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ContentKeyPolicyPolicyOptionFairplayConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ContentKeyPolicyPolicyOptionFairplayConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ContentKeyPolicyPolicyOptionFairplayConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ask: Optional[str] = None,
                 offline_rental_configuration: Optional['outputs.ContentKeyPolicyPolicyOptionFairplayConfigurationOfflineRentalConfiguration'] = None,
                 pfx: Optional[str] = None,
                 pfx_password: Optional[str] = None,
                 rental_and_lease_key_type: Optional[str] = None,
                 rental_duration_seconds: Optional[int] = None):
        """
        :param str ask: The key that must be used as FairPlay Application Secret key.
        :param 'ContentKeyPolicyPolicyOptionFairplayConfigurationOfflineRentalConfigurationArgs' offline_rental_configuration: A `offline_rental_configuration` block as defined below.
        :param str pfx: The Base64 representation of FairPlay certificate in PKCS 12 (pfx) format (including private key).
        :param str pfx_password: The password encrypting FairPlay certificate in PKCS 12 (pfx) format.
        :param str rental_and_lease_key_type: The rental and lease key type. Supported values are `DualExpiry`, `PersistentLimited`, `PersistentUnlimited` or `Undefined`.
        :param 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[str]:
        """
        The key that must be used as FairPlay Application Secret key.
        """
        return pulumi.get(self, "ask")

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

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

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

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

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


@pulumi.output_type
class ContentKeyPolicyPolicyOptionFairplayConfigurationOfflineRentalConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "playbackDurationSeconds":
            suggest = "playback_duration_seconds"
        elif key == "storageDurationSeconds":
            suggest = "storage_duration_seconds"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ContentKeyPolicyPolicyOptionFairplayConfigurationOfflineRentalConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ContentKeyPolicyPolicyOptionFairplayConfigurationOfflineRentalConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ContentKeyPolicyPolicyOptionFairplayConfigurationOfflineRentalConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 playback_duration_seconds: Optional[int] = None,
                 storage_duration_seconds: Optional[int] = None):
        """
        :param int playback_duration_seconds: Playback duration.
        :param 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[int]:
        """
        Playback duration.
        """
        return pulumi.get(self, "playback_duration_seconds")

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


@pulumi.output_type
class ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicense(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowTestDevices":
            suggest = "allow_test_devices"
        elif key == "beginDate":
            suggest = "begin_date"
        elif key == "contentKeyLocationFromHeaderEnabled":
            suggest = "content_key_location_from_header_enabled"
        elif key == "contentKeyLocationFromKeyId":
            suggest = "content_key_location_from_key_id"
        elif key == "contentType":
            suggest = "content_type"
        elif key == "expirationDate":
            suggest = "expiration_date"
        elif key == "gracePeriod":
            suggest = "grace_period"
        elif key == "licenseType":
            suggest = "license_type"
        elif key == "playRight":
            suggest = "play_right"
        elif key == "relativeBeginDate":
            suggest = "relative_begin_date"
        elif key == "relativeExpirationDate":
            suggest = "relative_expiration_date"
        elif key == "securityLevel":
            suggest = "security_level"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicense. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicense.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicense.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allow_test_devices: Optional[bool] = None,
                 begin_date: Optional[str] = None,
                 content_key_location_from_header_enabled: Optional[bool] = None,
                 content_key_location_from_key_id: Optional[str] = None,
                 content_type: Optional[str] = None,
                 expiration_date: Optional[str] = None,
                 grace_period: Optional[str] = None,
                 license_type: Optional[str] = None,
                 play_right: Optional['outputs.ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRight'] = None,
                 relative_begin_date: Optional[str] = None,
                 relative_expiration_date: Optional[str] = None,
                 security_level: Optional[str] = None):
        """
        :param bool allow_test_devices: A flag indicating whether test devices can use the license.
        :param str begin_date: The begin date of license.
        :param bool content_key_location_from_header_enabled: Specifies that the content key ID is in the PlayReady header.
        :param 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 str content_type: The PlayReady content type. Supported values are `UltraVioletDownload`, `UltraVioletStreaming` or `Unspecified`.
        :param str expiration_date: The expiration date of license.
        :param str grace_period: The grace period of license.
        :param str license_type: The license type. Supported values are `NonPersistent` or `Persistent`.
        :param 'ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightArgs' play_right: A `play_right` block as defined above.
        :param str relative_begin_date: The relative begin date of license.
        :param str relative_expiration_date: The relative expiration date of license.
        :param 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[bool]:
        """
        A flag indicating whether test devices can use the license.
        """
        return pulumi.get(self, "allow_test_devices")

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

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

    @property
    @pulumi.getter(name="contentKeyLocationFromKeyId")
    def content_key_location_from_key_id(self) -> Optional[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")

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="securityLevel")
    def security_level(self) -> Optional[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")


@pulumi.output_type
class ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRight(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "agcAndColorStripeRestriction":
            suggest = "agc_and_color_stripe_restriction"
        elif key == "allowPassingVideoContentToUnknownOutput":
            suggest = "allow_passing_video_content_to_unknown_output"
        elif key == "analogVideoOpl":
            suggest = "analog_video_opl"
        elif key == "compressedDigitalAudioOpl":
            suggest = "compressed_digital_audio_opl"
        elif key == "compressedDigitalVideoOpl":
            suggest = "compressed_digital_video_opl"
        elif key == "digitalVideoOnlyContentRestriction":
            suggest = "digital_video_only_content_restriction"
        elif key == "explicitAnalogTelevisionOutputRestriction":
            suggest = "explicit_analog_television_output_restriction"
        elif key == "firstPlayExpiration":
            suggest = "first_play_expiration"
        elif key == "imageConstraintForAnalogComponentVideoRestriction":
            suggest = "image_constraint_for_analog_component_video_restriction"
        elif key == "imageConstraintForAnalogComputerMonitorRestriction":
            suggest = "image_constraint_for_analog_computer_monitor_restriction"
        elif key == "scmsRestriction":
            suggest = "scms_restriction"
        elif key == "uncompressedDigitalAudioOpl":
            suggest = "uncompressed_digital_audio_opl"
        elif key == "uncompressedDigitalVideoOpl":
            suggest = "uncompressed_digital_video_opl"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRight. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRight.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRight.__key_warning(key)
        return super().get(key, default)

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

    @property
    @pulumi.getter(name="allowPassingVideoContentToUnknownOutput")
    def allow_passing_video_content_to_unknown_output(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="compressedDigitalAudioOpl")
    def compressed_digital_audio_opl(self) -> Optional[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")

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

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

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

    @property
    @pulumi.getter(name="firstPlayExpiration")
    def first_play_expiration(self) -> Optional[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")

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

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

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

    @property
    @pulumi.getter(name="uncompressedDigitalAudioOpl")
    def uncompressed_digital_audio_opl(self) -> Optional[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")

    @property
    @pulumi.getter(name="uncompressedDigitalVideoOpl")
    def uncompressed_digital_video_opl(self) -> Optional[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")


@pulumi.output_type
class ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightExplicitAnalogTelevisionOutputRestriction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "controlBits":
            suggest = "control_bits"
        elif key == "bestEffortEnforced":
            suggest = "best_effort_enforced"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightExplicitAnalogTelevisionOutputRestriction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightExplicitAnalogTelevisionOutputRestriction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightExplicitAnalogTelevisionOutputRestriction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 control_bits: int,
                 best_effort_enforced: Optional[bool] = None):
        """
        :param int control_bits: The restriction control bits. Possible value is integer between `0` and `3` inclusive.
        :param 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) -> int:
        """
        The restriction control bits. Possible value is integer between `0` and `3` inclusive.
        """
        return pulumi.get(self, "control_bits")

    @property
    @pulumi.getter(name="bestEffortEnforced")
    def best_effort_enforced(self) -> Optional[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")


@pulumi.output_type
class ContentKeyPolicyPolicyOptionTokenRestriction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "alternateKeys":
            suggest = "alternate_keys"
        elif key == "openIdConnectDiscoveryDocument":
            suggest = "open_id_connect_discovery_document"
        elif key == "primaryRsaTokenKeyExponent":
            suggest = "primary_rsa_token_key_exponent"
        elif key == "primaryRsaTokenKeyModulus":
            suggest = "primary_rsa_token_key_modulus"
        elif key == "primarySymmetricTokenKey":
            suggest = "primary_symmetric_token_key"
        elif key == "primaryX509TokenKeyRaw":
            suggest = "primary_x509_token_key_raw"
        elif key == "requiredClaims":
            suggest = "required_claims"
        elif key == "tokenType":
            suggest = "token_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ContentKeyPolicyPolicyOptionTokenRestriction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ContentKeyPolicyPolicyOptionTokenRestriction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ContentKeyPolicyPolicyOptionTokenRestriction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 alternate_keys: Optional[Sequence['outputs.ContentKeyPolicyPolicyOptionTokenRestrictionAlternateKey']] = None,
                 audience: Optional[str] = None,
                 issuer: Optional[str] = None,
                 open_id_connect_discovery_document: Optional[str] = None,
                 primary_rsa_token_key_exponent: Optional[str] = None,
                 primary_rsa_token_key_modulus: Optional[str] = None,
                 primary_symmetric_token_key: Optional[str] = None,
                 primary_x509_token_key_raw: Optional[str] = None,
                 required_claims: Optional[Sequence['outputs.ContentKeyPolicyPolicyOptionTokenRestrictionRequiredClaim']] = None,
                 token_type: Optional[str] = None):
        """
        :param Sequence['ContentKeyPolicyPolicyOptionTokenRestrictionAlternateKeyArgs'] alternate_keys: One or more `alternate_key` block as defined above.
        :param str audience: The audience for the token.
        :param str issuer: The token issuer.
        :param str open_id_connect_discovery_document: The OpenID connect discovery document.
        :param str primary_rsa_token_key_exponent: The RSA parameter exponent.
        :param str primary_rsa_token_key_modulus: The RSA parameter modulus.
        :param str primary_symmetric_token_key: The key value of the key. Specifies a symmetric key for token validation.
        :param 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 Sequence['ContentKeyPolicyPolicyOptionTokenRestrictionRequiredClaimArgs'] required_claims: One or more `required_claim` blocks as defined above.
        :param 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[Sequence['outputs.ContentKeyPolicyPolicyOptionTokenRestrictionAlternateKey']]:
        """
        One or more `alternate_key` block as defined above.
        """
        return pulumi.get(self, "alternate_keys")

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

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

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

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

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

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

    @property
    @pulumi.getter(name="primaryX509TokenKeyRaw")
    def primary_x509_token_key_raw(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="tokenType")
    def token_type(self) -> Optional[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")


@pulumi.output_type
class ContentKeyPolicyPolicyOptionTokenRestrictionAlternateKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rsaTokenKeyExponent":
            suggest = "rsa_token_key_exponent"
        elif key == "rsaTokenKeyModulus":
            suggest = "rsa_token_key_modulus"
        elif key == "symmetricTokenKey":
            suggest = "symmetric_token_key"
        elif key == "x509TokenKeyRaw":
            suggest = "x509_token_key_raw"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ContentKeyPolicyPolicyOptionTokenRestrictionAlternateKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ContentKeyPolicyPolicyOptionTokenRestrictionAlternateKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ContentKeyPolicyPolicyOptionTokenRestrictionAlternateKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 rsa_token_key_exponent: Optional[str] = None,
                 rsa_token_key_modulus: Optional[str] = None,
                 symmetric_token_key: Optional[str] = None,
                 x509_token_key_raw: Optional[str] = None):
        """
        :param str rsa_token_key_exponent: The RSA parameter exponent.
        :param str rsa_token_key_modulus: The RSA parameter modulus.
        :param str symmetric_token_key: The key value of the key. Specifies a symmetric key for token validation.
        :param 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[str]:
        """
        The RSA parameter exponent.
        """
        return pulumi.get(self, "rsa_token_key_exponent")

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

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

    @property
    @pulumi.getter(name="x509TokenKeyRaw")
    def x509_token_key_raw(self) -> Optional[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")


@pulumi.output_type
class ContentKeyPolicyPolicyOptionTokenRestrictionRequiredClaim(dict):
    def __init__(__self__, *,
                 type: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str type: Token claim type.
        :param 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[str]:
        """
        Token claim type.
        """
        return pulumi.get(self, "type")

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


@pulumi.output_type
class JobInputAsset(dict):
    def __init__(__self__, *,
                 name: str,
                 label: Optional[str] = None):
        """
        :param str name: The name of the input Asset. Changing this forces a new Media Job to be created.
        :param 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) -> str:
        """
        The name of the input Asset. Changing this forces a new Media Job to be created.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def label(self) -> Optional[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")


@pulumi.output_type
class JobOutputAsset(dict):
    def __init__(__self__, *,
                 name: str,
                 label: Optional[str] = None):
        """
        :param str name: The name of the output Asset. Changing this forces a new Media Job to be created.
        :param 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) -> str:
        """
        The name of the output Asset. Changing this forces a new Media Job to be created.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def label(self) -> Optional[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")


@pulumi.output_type
class LiveEventCrossSiteAccessPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientAccessPolicy":
            suggest = "client_access_policy"
        elif key == "crossDomainPolicy":
            suggest = "cross_domain_policy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveEventCrossSiteAccessPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveEventCrossSiteAccessPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveEventCrossSiteAccessPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 client_access_policy: Optional[str] = None,
                 cross_domain_policy: Optional[str] = None):
        """
        :param str client_access_policy: The content of clientaccesspolicy.xml used by Silverlight.
        :param 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[str]:
        """
        The content of clientaccesspolicy.xml used by Silverlight.
        """
        return pulumi.get(self, "client_access_policy")

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


@pulumi.output_type
class LiveEventEncoding(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyFrameInterval":
            suggest = "key_frame_interval"
        elif key == "presetName":
            suggest = "preset_name"
        elif key == "stretchMode":
            suggest = "stretch_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveEventEncoding. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveEventEncoding.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveEventEncoding.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 key_frame_interval: Optional[str] = None,
                 preset_name: Optional[str] = None,
                 stretch_mode: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param 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 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 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 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[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")

    @property
    @pulumi.getter(name="presetName")
    def preset_name(self) -> Optional[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")

    @property
    @pulumi.getter(name="stretchMode")
    def stretch_mode(self) -> Optional[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")

    @property
    @pulumi.getter
    def type(self) -> Optional[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")


@pulumi.output_type
class LiveEventInput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessToken":
            suggest = "access_token"
        elif key == "ipAccessControlAllows":
            suggest = "ip_access_control_allows"
        elif key == "keyFrameIntervalDuration":
            suggest = "key_frame_interval_duration"
        elif key == "streamingProtocol":
            suggest = "streaming_protocol"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveEventInput. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveEventInput.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveEventInput.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 access_token: Optional[str] = None,
                 endpoints: Optional[Sequence['outputs.LiveEventInputEndpoint']] = None,
                 ip_access_control_allows: Optional[Sequence['outputs.LiveEventInputIpAccessControlAllow']] = None,
                 key_frame_interval_duration: Optional[str] = None,
                 streaming_protocol: Optional[str] = None):
        """
        :param 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 Sequence['LiveEventInputIpAccessControlAllowArgs'] ip_access_control_allows: One or more `ip_access_control_allow` blocks as defined below.
        :param 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 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[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")

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

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

    @property
    @pulumi.getter(name="keyFrameIntervalDuration")
    def key_frame_interval_duration(self) -> Optional[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")

    @property
    @pulumi.getter(name="streamingProtocol")
    def streaming_protocol(self) -> Optional[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")


@pulumi.output_type
class LiveEventInputEndpoint(dict):
    def __init__(__self__, *,
                 protocol: Optional[str] = None,
                 url: Optional[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[str]:
        return pulumi.get(self, "protocol")

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


@pulumi.output_type
class LiveEventInputIpAccessControlAllow(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subnetPrefixLength":
            suggest = "subnet_prefix_length"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveEventInputIpAccessControlAllow. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveEventInputIpAccessControlAllow.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveEventInputIpAccessControlAllow.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 address: Optional[str] = None,
                 name: Optional[str] = None,
                 subnet_prefix_length: Optional[int] = None):
        """
        :param str address: The IP address or CIDR range.
        :param str name: The friendly name for the IP address range.
        :param 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[str]:
        """
        The IP address or CIDR range.
        """
        return pulumi.get(self, "address")

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

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


@pulumi.output_type
class LiveEventPreview(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "alternativeMediaId":
            suggest = "alternative_media_id"
        elif key == "ipAccessControlAllows":
            suggest = "ip_access_control_allows"
        elif key == "previewLocator":
            suggest = "preview_locator"
        elif key == "streamingPolicyName":
            suggest = "streaming_policy_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveEventPreview. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveEventPreview.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveEventPreview.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 alternative_media_id: Optional[str] = None,
                 endpoints: Optional[Sequence['outputs.LiveEventPreviewEndpoint']] = None,
                 ip_access_control_allows: Optional[Sequence['outputs.LiveEventPreviewIpAccessControlAllow']] = None,
                 preview_locator: Optional[str] = None,
                 streaming_policy_name: Optional[str] = None):
        """
        :param 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 Sequence['LiveEventPreviewIpAccessControlAllowArgs'] ip_access_control_allows: One or more `ip_access_control_allow` blocks as defined above.
        :param 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 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[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")

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

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

    @property
    @pulumi.getter(name="previewLocator")
    def preview_locator(self) -> Optional[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")

    @property
    @pulumi.getter(name="streamingPolicyName")
    def streaming_policy_name(self) -> Optional[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")


@pulumi.output_type
class LiveEventPreviewEndpoint(dict):
    def __init__(__self__, *,
                 protocol: Optional[str] = None,
                 url: Optional[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[str]:
        return pulumi.get(self, "protocol")

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


@pulumi.output_type
class LiveEventPreviewIpAccessControlAllow(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subnetPrefixLength":
            suggest = "subnet_prefix_length"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in LiveEventPreviewIpAccessControlAllow. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        LiveEventPreviewIpAccessControlAllow.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        LiveEventPreviewIpAccessControlAllow.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 address: Optional[str] = None,
                 name: Optional[str] = None,
                 subnet_prefix_length: Optional[int] = None):
        """
        :param str address: The IP address or CIDR range.
        :param str name: The friendly name for the IP address range.
        :param 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[str]:
        """
        The IP address or CIDR range.
        """
        return pulumi.get(self, "address")

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

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


@pulumi.output_type
class ServiceAccountEncryption(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "currentKeyIdentifier":
            suggest = "current_key_identifier"
        elif key == "keyVaultKeyIdentifier":
            suggest = "key_vault_key_identifier"
        elif key == "managedIdentity":
            suggest = "managed_identity"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ServiceAccountEncryption. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ServiceAccountEncryption.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ServiceAccountEncryption.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 current_key_identifier: Optional[str] = None,
                 key_vault_key_identifier: Optional[str] = None,
                 managed_identity: Optional['outputs.ServiceAccountEncryptionManagedIdentity'] = None,
                 type: Optional[str] = None):
        """
        :param str current_key_identifier: The current key used to encrypt the Media Services Account, including the key version.
        :param 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 'ServiceAccountEncryptionManagedIdentityArgs' managed_identity: A `managed_identity` block as defined below.
        :param 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[str]:
        """
        The current key used to encrypt the Media Services Account, including the key version.
        """
        return pulumi.get(self, "current_key_identifier")

    @property
    @pulumi.getter(name="keyVaultKeyIdentifier")
    def key_vault_key_identifier(self) -> Optional[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")

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

    @property
    @pulumi.getter
    def type(self) -> Optional[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")


@pulumi.output_type
class ServiceAccountEncryptionManagedIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "useSystemAssignedIdentity":
            suggest = "use_system_assigned_identity"
        elif key == "userAssignedIdentityId":
            suggest = "user_assigned_identity_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ServiceAccountEncryptionManagedIdentity. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ServiceAccountEncryptionManagedIdentity.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ServiceAccountEncryptionManagedIdentity.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 use_system_assigned_identity: Optional[bool] = None,
                 user_assigned_identity_id: Optional[str] = None):
        """
        :param bool use_system_assigned_identity: Whether to use System Assigned Identity. Possible Values are `true` and `false`.
        :param 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[bool]:
        """
        Whether to use System Assigned Identity. Possible Values are `true` and `false`.
        """
        return pulumi.get(self, "use_system_assigned_identity")

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> Optional[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")


@pulumi.output_type
class ServiceAccountIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "identityIds":
            suggest = "identity_ids"
        elif key == "principalId":
            suggest = "principal_id"
        elif key == "tenantId":
            suggest = "tenant_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ServiceAccountIdentity. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ServiceAccountIdentity.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ServiceAccountIdentity.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 type: str,
                 identity_ids: Optional[Sequence[str]] = None,
                 principal_id: Optional[str] = None,
                 tenant_id: Optional[str] = None):
        """
        :param 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 Sequence[str] identity_ids: Specifies a list of User Assigned Managed Identity IDs to be assigned to this Media Services Account.
        :param str principal_id: The Principal ID associated with this Managed Service Identity.
        :param 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) -> 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")

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

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

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


@pulumi.output_type
class ServiceAccountKeyDeliveryAccessControl(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultAction":
            suggest = "default_action"
        elif key == "ipAllowLists":
            suggest = "ip_allow_lists"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ServiceAccountKeyDeliveryAccessControl. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ServiceAccountKeyDeliveryAccessControl.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ServiceAccountKeyDeliveryAccessControl.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 default_action: Optional[str] = None,
                 ip_allow_lists: Optional[Sequence[str]] = None):
        """
        :param str default_action: The Default Action to use when no rules match from `ip_allow_list`. Possible values are `Allow` and `Deny`.
        :param Sequence[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[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")

    @property
    @pulumi.getter(name="ipAllowLists")
    def ip_allow_lists(self) -> Optional[Sequence[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")


@pulumi.output_type
class ServiceAccountStorageAccount(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isPrimary":
            suggest = "is_primary"
        elif key == "managedIdentity":
            suggest = "managed_identity"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ServiceAccountStorageAccount. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ServiceAccountStorageAccount.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ServiceAccountStorageAccount.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 id: str,
                 is_primary: Optional[bool] = None,
                 managed_identity: Optional['outputs.ServiceAccountStorageAccountManagedIdentity'] = None):
        """
        :param str id: Specifies the ID of the Storage Account that will be associated with the Media Services instance.
        :param 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 '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) -> str:
        """
        Specifies the ID of the Storage Account that will be associated with the Media Services instance.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="isPrimary")
    def is_primary(self) -> Optional[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")

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


@pulumi.output_type
class ServiceAccountStorageAccountManagedIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "useSystemAssignedIdentity":
            suggest = "use_system_assigned_identity"
        elif key == "userAssignedIdentityId":
            suggest = "user_assigned_identity_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ServiceAccountStorageAccountManagedIdentity. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ServiceAccountStorageAccountManagedIdentity.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ServiceAccountStorageAccountManagedIdentity.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 use_system_assigned_identity: Optional[bool] = None,
                 user_assigned_identity_id: Optional[str] = None):
        """
        :param bool use_system_assigned_identity: Whether to use System Assigned Identity. Possible Values are `true` and `false`.
        :param 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[bool]:
        """
        Whether to use System Assigned Identity. Possible Values are `true` and `false`.
        """
        return pulumi.get(self, "use_system_assigned_identity")

    @property
    @pulumi.getter(name="userAssignedIdentityId")
    def user_assigned_identity_id(self) -> Optional[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")


@pulumi.output_type
class StreamingEndpointAccessControl(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "akamaiSignatureHeaderAuthenticationKeys":
            suggest = "akamai_signature_header_authentication_keys"
        elif key == "ipAllows":
            suggest = "ip_allows"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingEndpointAccessControl. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingEndpointAccessControl.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingEndpointAccessControl.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 akamai_signature_header_authentication_keys: Optional[Sequence['outputs.StreamingEndpointAccessControlAkamaiSignatureHeaderAuthenticationKey']] = None,
                 ip_allows: Optional[Sequence['outputs.StreamingEndpointAccessControlIpAllow']] = None):
        """
        :param Sequence['StreamingEndpointAccessControlAkamaiSignatureHeaderAuthenticationKeyArgs'] akamai_signature_header_authentication_keys: One or more `akamai_signature_header_authentication_key` blocks as defined below.
        :param Sequence['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[Sequence['outputs.StreamingEndpointAccessControlAkamaiSignatureHeaderAuthenticationKey']]:
        """
        One or more `akamai_signature_header_authentication_key` blocks as defined below.
        """
        return pulumi.get(self, "akamai_signature_header_authentication_keys")

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


@pulumi.output_type
class StreamingEndpointAccessControlAkamaiSignatureHeaderAuthenticationKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "base64Key":
            suggest = "base64_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingEndpointAccessControlAkamaiSignatureHeaderAuthenticationKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingEndpointAccessControlAkamaiSignatureHeaderAuthenticationKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingEndpointAccessControlAkamaiSignatureHeaderAuthenticationKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 base64_key: Optional[str] = None,
                 expiration: Optional[str] = None,
                 identifier: Optional[str] = None):
        """
        :param str base64_key: Authentication key.
        :param str expiration: The expiration time of the authentication key.
        :param 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[str]:
        """
        Authentication key.
        """
        return pulumi.get(self, "base64_key")

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

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


@pulumi.output_type
class StreamingEndpointAccessControlIpAllow(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "subnetPrefixLength":
            suggest = "subnet_prefix_length"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingEndpointAccessControlIpAllow. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingEndpointAccessControlIpAllow.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingEndpointAccessControlIpAllow.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 address: Optional[str] = None,
                 name: Optional[str] = None,
                 subnet_prefix_length: Optional[int] = None):
        """
        :param str address: The IP address to allow.
        :param str name: The friendly name for the IP address range.
        :param 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[str]:
        """
        The IP address to allow.
        """
        return pulumi.get(self, "address")

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

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


@pulumi.output_type
class StreamingEndpointCrossSiteAccessPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientAccessPolicy":
            suggest = "client_access_policy"
        elif key == "crossDomainPolicy":
            suggest = "cross_domain_policy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingEndpointCrossSiteAccessPolicy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingEndpointCrossSiteAccessPolicy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingEndpointCrossSiteAccessPolicy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 client_access_policy: Optional[str] = None,
                 cross_domain_policy: Optional[str] = None):
        """
        :param str client_access_policy: The content of `clientaccesspolicy.xml` used by Silverlight.
        :param 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[str]:
        """
        The content of `clientaccesspolicy.xml` used by Silverlight.
        """
        return pulumi.get(self, "client_access_policy")

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


@pulumi.output_type
class StreamingEndpointSkus(dict):
    def __init__(__self__, *,
                 capacity: Optional[int] = None,
                 name: Optional[str] = None):
        """
        :param int capacity: The sku capacity of Streaming Endpoint.
        :param 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[int]:
        """
        The sku capacity of Streaming Endpoint.
        """
        return pulumi.get(self, "capacity")

    @property
    @pulumi.getter
    def name(self) -> Optional[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")


@pulumi.output_type
class StreamingLocatorContentKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "contentKeyId":
            suggest = "content_key_id"
        elif key == "labelReferenceInStreamingPolicy":
            suggest = "label_reference_in_streaming_policy"
        elif key == "policyName":
            suggest = "policy_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingLocatorContentKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingLocatorContentKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingLocatorContentKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 content_key_id: Optional[str] = None,
                 label_reference_in_streaming_policy: Optional[str] = None,
                 policy_name: Optional[str] = None,
                 type: Optional[str] = None,
                 value: Optional[str] = None):
        """
        :param str content_key_id: ID of Content Key. Changing this forces a new Streaming Locator to be created.
        :param 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 str policy_name: Content Key Policy used by Content Key. Changing this forces a new Streaming Locator to be created.
        :param 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 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[str]:
        """
        ID of Content Key. Changing this forces a new Streaming Locator to be created.
        """
        return pulumi.get(self, "content_key_id")

    @property
    @pulumi.getter(name="labelReferenceInStreamingPolicy")
    def label_reference_in_streaming_policy(self) -> Optional[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")

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

    @property
    @pulumi.getter
    def type(self) -> Optional[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")

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


@pulumi.output_type
class StreamingPolicyCommonEncryptionCbcs(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clearKeyEncryption":
            suggest = "clear_key_encryption"
        elif key == "defaultContentKey":
            suggest = "default_content_key"
        elif key == "drmFairplay":
            suggest = "drm_fairplay"
        elif key == "enabledProtocols":
            suggest = "enabled_protocols"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingPolicyCommonEncryptionCbcs. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingPolicyCommonEncryptionCbcs.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingPolicyCommonEncryptionCbcs.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 clear_key_encryption: Optional['outputs.StreamingPolicyCommonEncryptionCbcsClearKeyEncryption'] = None,
                 default_content_key: Optional['outputs.StreamingPolicyCommonEncryptionCbcsDefaultContentKey'] = None,
                 drm_fairplay: Optional['outputs.StreamingPolicyCommonEncryptionCbcsDrmFairplay'] = None,
                 enabled_protocols: Optional['outputs.StreamingPolicyCommonEncryptionCbcsEnabledProtocols'] = None):
        """
        :param 'StreamingPolicyCommonEncryptionCbcsClearKeyEncryptionArgs' clear_key_encryption: A `clear_key_encryption` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param 'StreamingPolicyCommonEncryptionCbcsDefaultContentKeyArgs' default_content_key: A `default_content_key` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param 'StreamingPolicyCommonEncryptionCbcsDrmFairplayArgs' drm_fairplay: A `drm_fairplay` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param '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['outputs.StreamingPolicyCommonEncryptionCbcsClearKeyEncryption']:
        """
        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")

    @property
    @pulumi.getter(name="defaultContentKey")
    def default_content_key(self) -> Optional['outputs.StreamingPolicyCommonEncryptionCbcsDefaultContentKey']:
        """
        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")

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

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


@pulumi.output_type
class StreamingPolicyCommonEncryptionCbcsClearKeyEncryption(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customKeysAcquisitionUrlTemplate":
            suggest = "custom_keys_acquisition_url_template"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingPolicyCommonEncryptionCbcsClearKeyEncryption. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingPolicyCommonEncryptionCbcsClearKeyEncryption.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingPolicyCommonEncryptionCbcsClearKeyEncryption.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 custom_keys_acquisition_url_template: str):
        """
        :param 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) -> 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")


@pulumi.output_type
class StreamingPolicyCommonEncryptionCbcsDefaultContentKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "policyName":
            suggest = "policy_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingPolicyCommonEncryptionCbcsDefaultContentKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingPolicyCommonEncryptionCbcsDefaultContentKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingPolicyCommonEncryptionCbcsDefaultContentKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 label: Optional[str] = None,
                 policy_name: Optional[str] = None):
        """
        :param 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 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[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")

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


@pulumi.output_type
class StreamingPolicyCommonEncryptionCbcsDrmFairplay(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowPersistentLicense":
            suggest = "allow_persistent_license"
        elif key == "customLicenseAcquisitionUrlTemplate":
            suggest = "custom_license_acquisition_url_template"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingPolicyCommonEncryptionCbcsDrmFairplay. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingPolicyCommonEncryptionCbcsDrmFairplay.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingPolicyCommonEncryptionCbcsDrmFairplay.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allow_persistent_license: Optional[bool] = None,
                 custom_license_acquisition_url_template: Optional[str] = None):
        """
        :param bool allow_persistent_license: All license to be persistent or not. Changing this forces a new Streaming Policy to be created.
        :param 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[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")

    @property
    @pulumi.getter(name="customLicenseAcquisitionUrlTemplate")
    def custom_license_acquisition_url_template(self) -> Optional[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")


@pulumi.output_type
class StreamingPolicyCommonEncryptionCbcsEnabledProtocols(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "smoothStreaming":
            suggest = "smooth_streaming"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingPolicyCommonEncryptionCbcsEnabledProtocols. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingPolicyCommonEncryptionCbcsEnabledProtocols.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingPolicyCommonEncryptionCbcsEnabledProtocols.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 dash: Optional[bool] = None,
                 download: Optional[bool] = None,
                 hls: Optional[bool] = None,
                 smooth_streaming: Optional[bool] = None):
        """
        :param bool dash: Enable DASH protocol or not. Changing this forces a new Streaming Policy to be created.
        :param bool download: Enable Download protocol or not. Changing this forces a new Streaming Policy to be created.
        :param bool hls: Enable HLS protocol or not. Changing this forces a new Streaming Policy to be created.
        :param 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[bool]:
        """
        Enable DASH protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "dash")

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

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

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


@pulumi.output_type
class StreamingPolicyCommonEncryptionCenc(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clearKeyEncryption":
            suggest = "clear_key_encryption"
        elif key == "clearTracks":
            suggest = "clear_tracks"
        elif key == "contentKeyToTrackMappings":
            suggest = "content_key_to_track_mappings"
        elif key == "defaultContentKey":
            suggest = "default_content_key"
        elif key == "drmPlayready":
            suggest = "drm_playready"
        elif key == "drmWidevineCustomLicenseAcquisitionUrlTemplate":
            suggest = "drm_widevine_custom_license_acquisition_url_template"
        elif key == "enabledProtocols":
            suggest = "enabled_protocols"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingPolicyCommonEncryptionCenc. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingPolicyCommonEncryptionCenc.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingPolicyCommonEncryptionCenc.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 clear_key_encryption: Optional['outputs.StreamingPolicyCommonEncryptionCencClearKeyEncryption'] = None,
                 clear_tracks: Optional[Sequence['outputs.StreamingPolicyCommonEncryptionCencClearTrack']] = None,
                 content_key_to_track_mappings: Optional[Sequence['outputs.StreamingPolicyCommonEncryptionCencContentKeyToTrackMapping']] = None,
                 default_content_key: Optional['outputs.StreamingPolicyCommonEncryptionCencDefaultContentKey'] = None,
                 drm_playready: Optional['outputs.StreamingPolicyCommonEncryptionCencDrmPlayready'] = None,
                 drm_widevine_custom_license_acquisition_url_template: Optional[str] = None,
                 enabled_protocols: Optional['outputs.StreamingPolicyCommonEncryptionCencEnabledProtocols'] = None):
        """
        :param 'StreamingPolicyCommonEncryptionCencClearKeyEncryptionArgs' clear_key_encryption: A `clear_key_encryption` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param Sequence['StreamingPolicyCommonEncryptionCencClearTrackArgs'] clear_tracks: One or more `clear_track` blocks as defined below. Changing this forces a new Streaming Policy to be created.
        :param Sequence['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 'StreamingPolicyCommonEncryptionCencDefaultContentKeyArgs' default_content_key: A `default_content_key` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param 'StreamingPolicyCommonEncryptionCencDrmPlayreadyArgs' drm_playready: A `drm_playready` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param 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 '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['outputs.StreamingPolicyCommonEncryptionCencClearKeyEncryption']:
        """
        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")

    @property
    @pulumi.getter(name="clearTracks")
    def clear_tracks(self) -> Optional[Sequence['outputs.StreamingPolicyCommonEncryptionCencClearTrack']]:
        """
        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")

    @property
    @pulumi.getter(name="contentKeyToTrackMappings")
    def content_key_to_track_mappings(self) -> Optional[Sequence['outputs.StreamingPolicyCommonEncryptionCencContentKeyToTrackMapping']]:
        """
        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")

    @property
    @pulumi.getter(name="defaultContentKey")
    def default_content_key(self) -> Optional['outputs.StreamingPolicyCommonEncryptionCencDefaultContentKey']:
        """
        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")

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

    @property
    @pulumi.getter(name="drmWidevineCustomLicenseAcquisitionUrlTemplate")
    def drm_widevine_custom_license_acquisition_url_template(self) -> Optional[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")

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


@pulumi.output_type
class StreamingPolicyCommonEncryptionCencClearKeyEncryption(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customKeysAcquisitionUrlTemplate":
            suggest = "custom_keys_acquisition_url_template"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingPolicyCommonEncryptionCencClearKeyEncryption. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingPolicyCommonEncryptionCencClearKeyEncryption.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingPolicyCommonEncryptionCencClearKeyEncryption.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 custom_keys_acquisition_url_template: str):
        """
        :param 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) -> 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")


@pulumi.output_type
class StreamingPolicyCommonEncryptionCencClearTrack(dict):
    def __init__(__self__, *,
                 conditions: Sequence['outputs.StreamingPolicyCommonEncryptionCencClearTrackCondition']):
        """
        :param Sequence['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) -> Sequence['outputs.StreamingPolicyCommonEncryptionCencClearTrackCondition']:
        """
        One or more `condition` blocks as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "conditions")


@pulumi.output_type
class StreamingPolicyCommonEncryptionCencClearTrackCondition(dict):
    def __init__(__self__, *,
                 operation: str,
                 property: str,
                 value: str):
        """
        :param str operation: The track property condition operation. Possible value is `Equal`. Changing this forces a new Streaming Policy to be created.
        :param str property: The track property type. Possible value is `FourCC`. Changing this forces a new Streaming Policy to be created.
        :param 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) -> 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")

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

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


@pulumi.output_type
class StreamingPolicyCommonEncryptionCencContentKeyToTrackMapping(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "policyName":
            suggest = "policy_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingPolicyCommonEncryptionCencContentKeyToTrackMapping. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingPolicyCommonEncryptionCencContentKeyToTrackMapping.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingPolicyCommonEncryptionCencContentKeyToTrackMapping.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 tracks: Sequence['outputs.StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrack'],
                 label: Optional[str] = None,
                 policy_name: Optional[str] = None):
        """
        :param Sequence['StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrackArgs'] tracks: One or more `track` blocks as defined below. Changing this forces a new Streaming Policy to be created.
        :param str label: Specifies the content key when creating a Streaming Locator. Changing this forces a new Streaming Policy to be created.
        :param 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) -> Sequence['outputs.StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrack']:
        """
        One or more `track` blocks as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "tracks")

    @property
    @pulumi.getter
    def label(self) -> Optional[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")

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


@pulumi.output_type
class StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrack(dict):
    def __init__(__self__, *,
                 conditions: Sequence['outputs.StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrackCondition']):
        """
        :param Sequence['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) -> Sequence['outputs.StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrackCondition']:
        """
        One or more `condition` blocks as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "conditions")


@pulumi.output_type
class StreamingPolicyCommonEncryptionCencContentKeyToTrackMappingTrackCondition(dict):
    def __init__(__self__, *,
                 operation: str,
                 property: str,
                 value: str):
        """
        :param str operation: The track property condition operation. Possible value is `Equal`. Changing this forces a new Streaming Policy to be created.
        :param str property: The track property type. Possible value is `FourCC`. Changing this forces a new Streaming Policy to be created.
        :param 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) -> 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")

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

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


@pulumi.output_type
class StreamingPolicyCommonEncryptionCencDefaultContentKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "policyName":
            suggest = "policy_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingPolicyCommonEncryptionCencDefaultContentKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingPolicyCommonEncryptionCencDefaultContentKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingPolicyCommonEncryptionCencDefaultContentKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 label: Optional[str] = None,
                 policy_name: Optional[str] = None):
        """
        :param 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 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[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")

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


@pulumi.output_type
class StreamingPolicyCommonEncryptionCencDrmPlayready(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customAttributes":
            suggest = "custom_attributes"
        elif key == "customLicenseAcquisitionUrlTemplate":
            suggest = "custom_license_acquisition_url_template"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingPolicyCommonEncryptionCencDrmPlayready. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingPolicyCommonEncryptionCencDrmPlayready.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingPolicyCommonEncryptionCencDrmPlayready.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 custom_attributes: Optional[str] = None,
                 custom_license_acquisition_url_template: Optional[str] = None):
        """
        :param str custom_attributes: Custom attributes for PlayReady. Changing this forces a new Streaming Policy to be created.
        :param 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[str]:
        """
        Custom attributes for PlayReady. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "custom_attributes")

    @property
    @pulumi.getter(name="customLicenseAcquisitionUrlTemplate")
    def custom_license_acquisition_url_template(self) -> Optional[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")


@pulumi.output_type
class StreamingPolicyCommonEncryptionCencEnabledProtocols(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "smoothStreaming":
            suggest = "smooth_streaming"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingPolicyCommonEncryptionCencEnabledProtocols. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingPolicyCommonEncryptionCencEnabledProtocols.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingPolicyCommonEncryptionCencEnabledProtocols.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 dash: Optional[bool] = None,
                 download: Optional[bool] = None,
                 hls: Optional[bool] = None,
                 smooth_streaming: Optional[bool] = None):
        """
        :param bool dash: Enable DASH protocol or not. Changing this forces a new Streaming Policy to be created.
        :param bool download: Enable Download protocol or not. Changing this forces a new Streaming Policy to be created.
        :param bool hls: Enable HLS protocol or not. Changing this forces a new Streaming Policy to be created.
        :param 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[bool]:
        """
        Enable DASH protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "dash")

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

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

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


@pulumi.output_type
class StreamingPolicyEnvelopeEncryption(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customKeysAcquisitionUrlTemplate":
            suggest = "custom_keys_acquisition_url_template"
        elif key == "defaultContentKey":
            suggest = "default_content_key"
        elif key == "enabledProtocols":
            suggest = "enabled_protocols"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingPolicyEnvelopeEncryption. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingPolicyEnvelopeEncryption.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingPolicyEnvelopeEncryption.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 custom_keys_acquisition_url_template: Optional[str] = None,
                 default_content_key: Optional['outputs.StreamingPolicyEnvelopeEncryptionDefaultContentKey'] = None,
                 enabled_protocols: Optional['outputs.StreamingPolicyEnvelopeEncryptionEnabledProtocols'] = None):
        """
        :param 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 'StreamingPolicyEnvelopeEncryptionDefaultContentKeyArgs' default_content_key: A `default_content_key` block as defined above. Changing this forces a new Streaming Policy to be created.
        :param '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[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")

    @property
    @pulumi.getter(name="defaultContentKey")
    def default_content_key(self) -> Optional['outputs.StreamingPolicyEnvelopeEncryptionDefaultContentKey']:
        """
        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")

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


@pulumi.output_type
class StreamingPolicyEnvelopeEncryptionDefaultContentKey(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "policyName":
            suggest = "policy_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingPolicyEnvelopeEncryptionDefaultContentKey. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingPolicyEnvelopeEncryptionDefaultContentKey.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingPolicyEnvelopeEncryptionDefaultContentKey.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 label: Optional[str] = None,
                 policy_name: Optional[str] = None):
        """
        :param 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 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[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")

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


@pulumi.output_type
class StreamingPolicyEnvelopeEncryptionEnabledProtocols(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "smoothStreaming":
            suggest = "smooth_streaming"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingPolicyEnvelopeEncryptionEnabledProtocols. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingPolicyEnvelopeEncryptionEnabledProtocols.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingPolicyEnvelopeEncryptionEnabledProtocols.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 dash: Optional[bool] = None,
                 download: Optional[bool] = None,
                 hls: Optional[bool] = None,
                 smooth_streaming: Optional[bool] = None):
        """
        :param bool dash: Enable DASH protocol or not. Changing this forces a new Streaming Policy to be created.
        :param bool download: Enable Download protocol or not. Changing this forces a new Streaming Policy to be created.
        :param bool hls: Enable HLS protocol or not. Changing this forces a new Streaming Policy to be created.
        :param 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[bool]:
        """
        Enable DASH protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "dash")

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

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

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


@pulumi.output_type
class StreamingPolicyNoEncryptionEnabledProtocols(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "smoothStreaming":
            suggest = "smooth_streaming"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in StreamingPolicyNoEncryptionEnabledProtocols. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        StreamingPolicyNoEncryptionEnabledProtocols.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        StreamingPolicyNoEncryptionEnabledProtocols.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 dash: Optional[bool] = None,
                 download: Optional[bool] = None,
                 hls: Optional[bool] = None,
                 smooth_streaming: Optional[bool] = None):
        """
        :param bool dash: Enable DASH protocol or not. Changing this forces a new Streaming Policy to be created.
        :param bool download: Enable Download protocol or not. Changing this forces a new Streaming Policy to be created.
        :param bool hls: Enable HLS protocol or not. Changing this forces a new Streaming Policy to be created.
        :param 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[bool]:
        """
        Enable DASH protocol or not. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "dash")

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

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

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


@pulumi.output_type
class TransformOutput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "audioAnalyzerPreset":
            suggest = "audio_analyzer_preset"
        elif key == "builtinPreset":
            suggest = "builtin_preset"
        elif key == "customPreset":
            suggest = "custom_preset"
        elif key == "faceDetectorPreset":
            suggest = "face_detector_preset"
        elif key == "onErrorAction":
            suggest = "on_error_action"
        elif key == "relativePriority":
            suggest = "relative_priority"
        elif key == "videoAnalyzerPreset":
            suggest = "video_analyzer_preset"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutput. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutput.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutput.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 audio_analyzer_preset: Optional['outputs.TransformOutputAudioAnalyzerPreset'] = None,
                 builtin_preset: Optional['outputs.TransformOutputBuiltinPreset'] = None,
                 custom_preset: Optional['outputs.TransformOutputCustomPreset'] = None,
                 face_detector_preset: Optional['outputs.TransformOutputFaceDetectorPreset'] = None,
                 on_error_action: Optional[str] = None,
                 relative_priority: Optional[str] = None,
                 video_analyzer_preset: Optional['outputs.TransformOutputVideoAnalyzerPreset'] = None):
        """
        :param 'TransformOutputAudioAnalyzerPresetArgs' audio_analyzer_preset: An `audio_analyzer_preset` block as defined above.
        :param 'TransformOutputBuiltinPresetArgs' builtin_preset: A `builtin_preset` block as defined above.
        :param 'TransformOutputCustomPresetArgs' custom_preset: A `custom_preset` block as defined above.
        :param 'TransformOutputFaceDetectorPresetArgs' face_detector_preset: A `face_detector_preset` block as defined above.
        :param 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 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 '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:
            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:
            pulumi.set(__self__, "video_analyzer_preset", video_analyzer_preset)

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

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

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

    @property
    @pulumi.getter(name="faceDetectorPreset")
    def face_detector_preset(self) -> Optional['outputs.TransformOutputFaceDetectorPreset']:
        """
        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")

    @property
    @pulumi.getter(name="onErrorAction")
    def on_error_action(self) -> Optional[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")

    @property
    @pulumi.getter(name="relativePriority")
    def relative_priority(self) -> Optional[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")

    @property
    @pulumi.getter(name="videoAnalyzerPreset")
    def video_analyzer_preset(self) -> Optional['outputs.TransformOutputVideoAnalyzerPreset']:
        """
        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")


@pulumi.output_type
class TransformOutputAudioAnalyzerPreset(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "audioAnalysisMode":
            suggest = "audio_analysis_mode"
        elif key == "audioLanguage":
            suggest = "audio_language"
        elif key == "experimentalOptions":
            suggest = "experimental_options"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputAudioAnalyzerPreset. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputAudioAnalyzerPreset.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputAudioAnalyzerPreset.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 audio_analysis_mode: Optional[str] = None,
                 audio_language: Optional[str] = None,
                 experimental_options: Optional[Mapping[str, str]] = None):
        """
        :param str audio_analysis_mode: Possible values are `Basic` or `Standard`. Determines the set of audio analysis operations to be performed. Default to `Standard`.
        :param 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 Mapping[str, 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[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")

    @property
    @pulumi.getter(name="audioLanguage")
    def audio_language(self) -> Optional[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")

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


@pulumi.output_type
class TransformOutputBuiltinPreset(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "presetName":
            suggest = "preset_name"
        elif key == "presetConfiguration":
            suggest = "preset_configuration"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputBuiltinPreset. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputBuiltinPreset.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputBuiltinPreset.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 preset_name: str,
                 preset_configuration: Optional['outputs.TransformOutputBuiltinPresetPresetConfiguration'] = None):
        """
        :param 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 '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) -> 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")

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


@pulumi.output_type
class TransformOutputBuiltinPresetPresetConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "interleaveOutput":
            suggest = "interleave_output"
        elif key == "keyFrameIntervalInSeconds":
            suggest = "key_frame_interval_in_seconds"
        elif key == "maxBitrateBps":
            suggest = "max_bitrate_bps"
        elif key == "maxHeight":
            suggest = "max_height"
        elif key == "maxLayers":
            suggest = "max_layers"
        elif key == "minBitrateBps":
            suggest = "min_bitrate_bps"
        elif key == "minHeight":
            suggest = "min_height"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputBuiltinPresetPresetConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputBuiltinPresetPresetConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputBuiltinPresetPresetConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 complexity: Optional[str] = None,
                 interleave_output: Optional[str] = None,
                 key_frame_interval_in_seconds: Optional[float] = None,
                 max_bitrate_bps: Optional[int] = None,
                 max_height: Optional[int] = None,
                 max_layers: Optional[int] = None,
                 min_bitrate_bps: Optional[int] = None,
                 min_height: Optional[int] = None):
        """
        :param str complexity: The complexity of the encoding. Possible values are `Balanced`, `Speed` or `Quality`.
        :param 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 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 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 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 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 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 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[str]:
        """
        The complexity of the encoding. Possible values are `Balanced`, `Speed` or `Quality`.
        """
        return pulumi.get(self, "complexity")

    @property
    @pulumi.getter(name="interleaveOutput")
    def interleave_output(self) -> Optional[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")

    @property
    @pulumi.getter(name="keyFrameIntervalInSeconds")
    def key_frame_interval_in_seconds(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxBitrateBps")
    def max_bitrate_bps(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxHeight")
    def max_height(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxLayers")
    def max_layers(self) -> Optional[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")

    @property
    @pulumi.getter(name="minBitrateBps")
    def min_bitrate_bps(self) -> Optional[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")

    @property
    @pulumi.getter(name="minHeight")
    def min_height(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPreset(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "experimentalOptions":
            suggest = "experimental_options"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPreset. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPreset.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPreset.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 codecs: Sequence['outputs.TransformOutputCustomPresetCodec'],
                 formats: Sequence['outputs.TransformOutputCustomPresetFormat'],
                 experimental_options: Optional[Mapping[str, str]] = None,
                 filter: Optional['outputs.TransformOutputCustomPresetFilter'] = None):
        """
        :param Sequence['TransformOutputCustomPresetCodecArgs'] codecs: One or more `codec` blocks as defined above.
        :param Sequence['TransformOutputCustomPresetFormatArgs'] formats: One or more `format` blocks as defined below.
        :param Mapping[str, str] experimental_options: Dictionary containing key value pairs for parameters not exposed in the preset itself.
        :param '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) -> Sequence['outputs.TransformOutputCustomPresetCodec']:
        """
        One or more `codec` blocks as defined above.
        """
        return pulumi.get(self, "codecs")

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

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

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


@pulumi.output_type
class TransformOutputCustomPresetCodec(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aacAudio":
            suggest = "aac_audio"
        elif key == "copyAudio":
            suggest = "copy_audio"
        elif key == "copyVideo":
            suggest = "copy_video"
        elif key == "ddAudio":
            suggest = "dd_audio"
        elif key == "h264Video":
            suggest = "h264_video"
        elif key == "h265Video":
            suggest = "h265_video"
        elif key == "jpgImage":
            suggest = "jpg_image"
        elif key == "pngImage":
            suggest = "png_image"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetCodec. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetCodec.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetCodec.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 aac_audio: Optional['outputs.TransformOutputCustomPresetCodecAacAudio'] = None,
                 copy_audio: Optional['outputs.TransformOutputCustomPresetCodecCopyAudio'] = None,
                 copy_video: Optional['outputs.TransformOutputCustomPresetCodecCopyVideo'] = None,
                 dd_audio: Optional['outputs.TransformOutputCustomPresetCodecDdAudio'] = None,
                 h264_video: Optional['outputs.TransformOutputCustomPresetCodecH264Video'] = None,
                 h265_video: Optional['outputs.TransformOutputCustomPresetCodecH265Video'] = None,
                 jpg_image: Optional['outputs.TransformOutputCustomPresetCodecJpgImage'] = None,
                 png_image: Optional['outputs.TransformOutputCustomPresetCodecPngImage'] = None):
        """
        :param 'TransformOutputCustomPresetCodecAacAudioArgs' aac_audio: A `aac_audio` block as defined above.
        :param 'TransformOutputCustomPresetCodecCopyAudioArgs' copy_audio: A `copy_audio` block as defined below.
        :param 'TransformOutputCustomPresetCodecCopyVideoArgs' copy_video: A `copy_video` block as defined below.
        :param 'TransformOutputCustomPresetCodecDdAudioArgs' dd_audio: A `dd_audio` block as defined below.
        :param 'TransformOutputCustomPresetCodecH264VideoArgs' h264_video: A `h264_video` block as defined below.
        :param 'TransformOutputCustomPresetCodecH265VideoArgs' h265_video: A `h265_video` block as defined below.
        :param 'TransformOutputCustomPresetCodecJpgImageArgs' jpg_image: A `jpg_image` block as defined below.
        :param '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['outputs.TransformOutputCustomPresetCodecAacAudio']:
        """
        A `aac_audio` block as defined above.
        """
        return pulumi.get(self, "aac_audio")

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

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

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

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

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

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

    @property
    @pulumi.getter(name="pngImage")
    def png_image(self) -> Optional['outputs.TransformOutputCustomPresetCodecPngImage']:
        """
        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")


@pulumi.output_type
class TransformOutputCustomPresetCodecAacAudio(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "samplingRate":
            suggest = "sampling_rate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetCodecAacAudio. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetCodecAacAudio.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetCodecAacAudio.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bitrate: Optional[int] = None,
                 channels: Optional[int] = None,
                 label: Optional[str] = None,
                 profile: Optional[str] = None,
                 sampling_rate: Optional[int] = None):
        """
        :param int bitrate: The bitrate of the audio in bits per second. Default to `128000`.
        :param int channels: The number of audio channels. Default to `2`.
        :param str label: Specifies the label for the codec. The label can be used to control muxing behavior.
        :param str profile: The encoding profile to be used when encoding audio with AAC. Possible values are `AacLc`, `HeAacV1`,and `HeAacV2`. Default to `AacLc`.
        :param 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[int]:
        """
        The bitrate of the audio in bits per second. Default to `128000`.
        """
        return pulumi.get(self, "bitrate")

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

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

    @property
    @pulumi.getter
    def profile(self) -> Optional[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")

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


@pulumi.output_type
class TransformOutputCustomPresetCodecCopyAudio(dict):
    def __init__(__self__, *,
                 label: Optional[str] = None):
        """
        :param 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[str]:
        """
        Specifies the label for the codec. The label can be used to control muxing behavior.
        """
        return pulumi.get(self, "label")


@pulumi.output_type
class TransformOutputCustomPresetCodecCopyVideo(dict):
    def __init__(__self__, *,
                 label: Optional[str] = None):
        """
        :param 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[str]:
        """
        Specifies the label for the codec. The label can be used to control muxing behavior.
        """
        return pulumi.get(self, "label")


@pulumi.output_type
class TransformOutputCustomPresetCodecDdAudio(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "samplingRate":
            suggest = "sampling_rate"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetCodecDdAudio. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetCodecDdAudio.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetCodecDdAudio.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bitrate: Optional[int] = None,
                 channels: Optional[int] = None,
                 label: Optional[str] = None,
                 sampling_rate: Optional[int] = None):
        """
        :param int bitrate: The bitrate of the audio in bits per second. Default to `192000`.
        :param int channels: The number of audio channels. Default to `2`.
        :param str label: Specifies the label for the codec. The label can be used to control muxing behavior.
        :param 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[int]:
        """
        The bitrate of the audio in bits per second. Default to `192000`.
        """
        return pulumi.get(self, "bitrate")

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

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

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


@pulumi.output_type
class TransformOutputCustomPresetCodecH264Video(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyFrameInterval":
            suggest = "key_frame_interval"
        elif key == "rateControlMode":
            suggest = "rate_control_mode"
        elif key == "sceneChangeDetectionEnabled":
            suggest = "scene_change_detection_enabled"
        elif key == "stretchMode":
            suggest = "stretch_mode"
        elif key == "syncMode":
            suggest = "sync_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetCodecH264Video. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetCodecH264Video.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetCodecH264Video.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 complexity: Optional[str] = None,
                 key_frame_interval: Optional[str] = None,
                 label: Optional[str] = None,
                 layers: Optional[Sequence['outputs.TransformOutputCustomPresetCodecH264VideoLayer']] = None,
                 rate_control_mode: Optional[str] = None,
                 scene_change_detection_enabled: Optional[bool] = None,
                 stretch_mode: Optional[str] = None,
                 sync_mode: Optional[str] = None):
        """
        :param str complexity: The complexity of the encoding. Possible values are `Balanced`, `Speed` or `Quality`. Default to `Balanced`.
        :param 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 str label: Specifies the label for the codec. The label can be used to control muxing behavior.
        :param Sequence['TransformOutputCustomPresetCodecH264VideoLayerArgs'] layers: One or more `layer` blocks as defined below.
        :param str rate_control_mode: The rate control mode. Possible values are `ABR`, `CBR` or `CRF`. Default to `ABR`.
        :param 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 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 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[str]:
        """
        The complexity of the encoding. Possible values are `Balanced`, `Speed` or `Quality`. Default to `Balanced`.
        """
        return pulumi.get(self, "complexity")

    @property
    @pulumi.getter(name="keyFrameInterval")
    def key_frame_interval(self) -> Optional[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")

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

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

    @property
    @pulumi.getter(name="rateControlMode")
    def rate_control_mode(self) -> Optional[str]:
        """
        The rate control mode. Possible values are `ABR`, `CBR` or `CRF`. Default to `ABR`.
        """
        return pulumi.get(self, "rate_control_mode")

    @property
    @pulumi.getter(name="sceneChangeDetectionEnabled")
    def scene_change_detection_enabled(self) -> Optional[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")

    @property
    @pulumi.getter(name="stretchMode")
    def stretch_mode(self) -> Optional[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")

    @property
    @pulumi.getter(name="syncMode")
    def sync_mode(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPresetCodecH264VideoLayer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "adaptiveBFrameEnabled":
            suggest = "adaptive_b_frame_enabled"
        elif key == "bFrames":
            suggest = "b_frames"
        elif key == "bufferWindow":
            suggest = "buffer_window"
        elif key == "entropyMode":
            suggest = "entropy_mode"
        elif key == "frameRate":
            suggest = "frame_rate"
        elif key == "maxBitrate":
            suggest = "max_bitrate"
        elif key == "referenceFrames":
            suggest = "reference_frames"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetCodecH264VideoLayer. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetCodecH264VideoLayer.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetCodecH264VideoLayer.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bitrate: int,
                 adaptive_b_frame_enabled: Optional[bool] = None,
                 b_frames: Optional[int] = None,
                 buffer_window: Optional[str] = None,
                 crf: Optional[float] = None,
                 entropy_mode: Optional[str] = None,
                 frame_rate: Optional[str] = None,
                 height: Optional[str] = None,
                 label: Optional[str] = None,
                 level: Optional[str] = None,
                 max_bitrate: Optional[int] = None,
                 profile: Optional[str] = None,
                 reference_frames: Optional[int] = None,
                 slices: Optional[int] = None,
                 width: Optional[str] = None):
        """
        :param int bitrate: The average bitrate in bits per second at which to encode the input video when generating this layer.
        :param 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 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 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 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 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 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 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 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 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 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 str profile: The H.264 profile. Possible values are `Auto`, `Main` and `Main10`. Default to `Auto`.
        :param 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 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 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) -> int:
        """
        The average bitrate in bits per second at which to encode the input video when generating this layer.
        """
        return pulumi.get(self, "bitrate")

    @property
    @pulumi.getter(name="adaptiveBFrameEnabled")
    def adaptive_b_frame_enabled(self) -> Optional[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")

    @property
    @pulumi.getter(name="bFrames")
    def b_frames(self) -> Optional[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")

    @property
    @pulumi.getter(name="bufferWindow")
    def buffer_window(self) -> Optional[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")

    @property
    @pulumi.getter
    def crf(self) -> Optional[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")

    @property
    @pulumi.getter(name="entropyMode")
    def entropy_mode(self) -> Optional[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")

    @property
    @pulumi.getter(name="frameRate")
    def frame_rate(self) -> Optional[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")

    @property
    @pulumi.getter
    def height(self) -> Optional[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")

    @property
    @pulumi.getter
    def label(self) -> Optional[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")

    @property
    @pulumi.getter
    def level(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxBitrate")
    def max_bitrate(self) -> Optional[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")

    @property
    @pulumi.getter
    def profile(self) -> Optional[str]:
        """
        The H.264 profile. Possible values are `Auto`, `Main` and `Main10`. Default to `Auto`.
        """
        return pulumi.get(self, "profile")

    @property
    @pulumi.getter(name="referenceFrames")
    def reference_frames(self) -> Optional[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")

    @property
    @pulumi.getter
    def slices(self) -> Optional[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")

    @property
    @pulumi.getter
    def width(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPresetCodecH265Video(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyFrameInterval":
            suggest = "key_frame_interval"
        elif key == "sceneChangeDetectionEnabled":
            suggest = "scene_change_detection_enabled"
        elif key == "stretchMode":
            suggest = "stretch_mode"
        elif key == "syncMode":
            suggest = "sync_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetCodecH265Video. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetCodecH265Video.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetCodecH265Video.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 complexity: Optional[str] = None,
                 key_frame_interval: Optional[str] = None,
                 label: Optional[str] = None,
                 layers: Optional[Sequence['outputs.TransformOutputCustomPresetCodecH265VideoLayer']] = None,
                 scene_change_detection_enabled: Optional[bool] = None,
                 stretch_mode: Optional[str] = None,
                 sync_mode: Optional[str] = None):
        """
        :param str complexity: The complexity of the encoding. Possible values are `Balanced`, `Speed` or `Quality`. Default to `Balanced`.
        :param 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 str label: Specifies the label for the codec. The label can be used to control muxing behavior.
        :param Sequence['TransformOutputCustomPresetCodecH265VideoLayerArgs'] layers: One or more `layer` blocks as defined below.
        :param 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 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 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[str]:
        """
        The complexity of the encoding. Possible values are `Balanced`, `Speed` or `Quality`. Default to `Balanced`.
        """
        return pulumi.get(self, "complexity")

    @property
    @pulumi.getter(name="keyFrameInterval")
    def key_frame_interval(self) -> Optional[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")

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

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

    @property
    @pulumi.getter(name="sceneChangeDetectionEnabled")
    def scene_change_detection_enabled(self) -> Optional[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")

    @property
    @pulumi.getter(name="stretchMode")
    def stretch_mode(self) -> Optional[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")

    @property
    @pulumi.getter(name="syncMode")
    def sync_mode(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPresetCodecH265VideoLayer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "adaptiveBFrameEnabled":
            suggest = "adaptive_b_frame_enabled"
        elif key == "bFrames":
            suggest = "b_frames"
        elif key == "bufferWindow":
            suggest = "buffer_window"
        elif key == "frameRate":
            suggest = "frame_rate"
        elif key == "maxBitrate":
            suggest = "max_bitrate"
        elif key == "referenceFrames":
            suggest = "reference_frames"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetCodecH265VideoLayer. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetCodecH265VideoLayer.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetCodecH265VideoLayer.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bitrate: int,
                 adaptive_b_frame_enabled: Optional[bool] = None,
                 b_frames: Optional[int] = None,
                 buffer_window: Optional[str] = None,
                 crf: Optional[float] = None,
                 frame_rate: Optional[str] = None,
                 height: Optional[str] = None,
                 label: Optional[str] = None,
                 level: Optional[str] = None,
                 max_bitrate: Optional[int] = None,
                 profile: Optional[str] = None,
                 reference_frames: Optional[int] = None,
                 slices: Optional[int] = None,
                 width: Optional[str] = None):
        """
        :param int bitrate: The average bitrate in bits per second at which to encode the input video when generating this layer.
        :param 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 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 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 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 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 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 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 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 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 str profile: The H.264 profile. Possible values are `Auto`, `Main` and `Main10`. Default to `Auto`.
        :param 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 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 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) -> int:
        """
        The average bitrate in bits per second at which to encode the input video when generating this layer.
        """
        return pulumi.get(self, "bitrate")

    @property
    @pulumi.getter(name="adaptiveBFrameEnabled")
    def adaptive_b_frame_enabled(self) -> Optional[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")

    @property
    @pulumi.getter(name="bFrames")
    def b_frames(self) -> Optional[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")

    @property
    @pulumi.getter(name="bufferWindow")
    def buffer_window(self) -> Optional[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")

    @property
    @pulumi.getter
    def crf(self) -> Optional[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")

    @property
    @pulumi.getter(name="frameRate")
    def frame_rate(self) -> Optional[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")

    @property
    @pulumi.getter
    def height(self) -> Optional[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")

    @property
    @pulumi.getter
    def label(self) -> Optional[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")

    @property
    @pulumi.getter
    def level(self) -> Optional[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")

    @property
    @pulumi.getter(name="maxBitrate")
    def max_bitrate(self) -> Optional[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")

    @property
    @pulumi.getter
    def profile(self) -> Optional[str]:
        """
        The H.264 profile. Possible values are `Auto`, `Main` and `Main10`. Default to `Auto`.
        """
        return pulumi.get(self, "profile")

    @property
    @pulumi.getter(name="referenceFrames")
    def reference_frames(self) -> Optional[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")

    @property
    @pulumi.getter
    def slices(self) -> Optional[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")

    @property
    @pulumi.getter
    def width(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPresetCodecJpgImage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyFrameInterval":
            suggest = "key_frame_interval"
        elif key == "spriteColumn":
            suggest = "sprite_column"
        elif key == "stretchMode":
            suggest = "stretch_mode"
        elif key == "syncMode":
            suggest = "sync_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetCodecJpgImage. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetCodecJpgImage.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetCodecJpgImage.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 start: str,
                 key_frame_interval: Optional[str] = None,
                 label: Optional[str] = None,
                 layers: Optional[Sequence['outputs.TransformOutputCustomPresetCodecJpgImageLayer']] = None,
                 range: Optional[str] = None,
                 sprite_column: Optional[int] = None,
                 step: Optional[str] = None,
                 stretch_mode: Optional[str] = None,
                 sync_mode: Optional[str] = None):
        """
        :param 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 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 str label: Specifies the label for the codec. The label can be used to control muxing behavior.
        :param Sequence['TransformOutputCustomPresetCodecJpgImageLayerArgs'] layers: One or more `layer` blocks as defined below.
        :param 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 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 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 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 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) -> 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")

    @property
    @pulumi.getter(name="keyFrameInterval")
    def key_frame_interval(self) -> Optional[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")

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

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

    @property
    @pulumi.getter
    def range(self) -> Optional[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")

    @property
    @pulumi.getter(name="spriteColumn")
    def sprite_column(self) -> Optional[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")

    @property
    @pulumi.getter
    def step(self) -> Optional[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")

    @property
    @pulumi.getter(name="stretchMode")
    def stretch_mode(self) -> Optional[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")

    @property
    @pulumi.getter(name="syncMode")
    def sync_mode(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPresetCodecJpgImageLayer(dict):
    def __init__(__self__, *,
                 height: Optional[str] = None,
                 label: Optional[str] = None,
                 quality: Optional[int] = None,
                 width: Optional[str] = None):
        """
        :param 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 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 int quality: The compression quality of the JPEG output. Range is from `0` to `100` and the default is `70`.
        :param 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[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")

    @property
    @pulumi.getter
    def label(self) -> Optional[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")

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

    @property
    @pulumi.getter
    def width(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPresetCodecPngImage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyFrameInterval":
            suggest = "key_frame_interval"
        elif key == "stretchMode":
            suggest = "stretch_mode"
        elif key == "syncMode":
            suggest = "sync_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetCodecPngImage. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetCodecPngImage.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetCodecPngImage.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 start: str,
                 key_frame_interval: Optional[str] = None,
                 label: Optional[str] = None,
                 layers: Optional[Sequence['outputs.TransformOutputCustomPresetCodecPngImageLayer']] = None,
                 range: Optional[str] = None,
                 step: Optional[str] = None,
                 stretch_mode: Optional[str] = None,
                 sync_mode: Optional[str] = None):
        """
        :param 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 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 str label: Specifies the label for the codec. The label can be used to control muxing behavior.
        :param Sequence['TransformOutputCustomPresetCodecPngImageLayerArgs'] layers: One or more `layer` blocks as defined below.
        :param 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 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 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 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) -> 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")

    @property
    @pulumi.getter(name="keyFrameInterval")
    def key_frame_interval(self) -> Optional[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")

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

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

    @property
    @pulumi.getter
    def range(self) -> Optional[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")

    @property
    @pulumi.getter
    def step(self) -> Optional[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")

    @property
    @pulumi.getter(name="stretchMode")
    def stretch_mode(self) -> Optional[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")

    @property
    @pulumi.getter(name="syncMode")
    def sync_mode(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPresetCodecPngImageLayer(dict):
    def __init__(__self__, *,
                 height: Optional[str] = None,
                 label: Optional[str] = None,
                 width: Optional[str] = None):
        """
        :param 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 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 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[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")

    @property
    @pulumi.getter
    def label(self) -> Optional[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")

    @property
    @pulumi.getter
    def width(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPresetFilter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cropRectangle":
            suggest = "crop_rectangle"
        elif key == "fadeIn":
            suggest = "fade_in"
        elif key == "fadeOut":
            suggest = "fade_out"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetFilter. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetFilter.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetFilter.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 crop_rectangle: Optional['outputs.TransformOutputCustomPresetFilterCropRectangle'] = None,
                 deinterlace: Optional['outputs.TransformOutputCustomPresetFilterDeinterlace'] = None,
                 fade_in: Optional['outputs.TransformOutputCustomPresetFilterFadeIn'] = None,
                 fade_out: Optional['outputs.TransformOutputCustomPresetFilterFadeOut'] = None,
                 overlays: Optional[Sequence['outputs.TransformOutputCustomPresetFilterOverlay']] = None,
                 rotation: Optional[str] = None):
        """
        :param 'TransformOutputCustomPresetFilterCropRectangleArgs' crop_rectangle: A `crop_rectangle` block as defined above.
        :param 'TransformOutputCustomPresetFilterDeinterlaceArgs' deinterlace: A `deinterlace` block as defined below.
        :param 'TransformOutputCustomPresetFilterFadeInArgs' fade_in: A `fade_in` block as defined above.
        :param 'TransformOutputCustomPresetFilterFadeOutArgs' fade_out: A `fade_out` block as defined above.
        :param Sequence['TransformOutputCustomPresetFilterOverlayArgs'] overlays: One or more `overlay` blocks as defined below.
        :param 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['outputs.TransformOutputCustomPresetFilterCropRectangle']:
        """
        A `crop_rectangle` block as defined above.
        """
        return pulumi.get(self, "crop_rectangle")

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

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

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

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

    @property
    @pulumi.getter
    def rotation(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPresetFilterCropRectangle(dict):
    def __init__(__self__, *,
                 height: Optional[str] = None,
                 left: Optional[str] = None,
                 top: Optional[str] = None,
                 width: Optional[str] = None):
        """
        :param 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 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 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 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[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")

    @property
    @pulumi.getter
    def left(self) -> Optional[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")

    @property
    @pulumi.getter
    def top(self) -> Optional[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")

    @property
    @pulumi.getter
    def width(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPresetFilterDeinterlace(dict):
    def __init__(__self__, *,
                 mode: Optional[str] = None,
                 parity: Optional[str] = None):
        """
        :param str mode: The deinterlacing mode. Possible values are `AutoPixelAdaptive` or `Off`. Default to `AutoPixelAdaptive`.
        :param 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[str]:
        """
        The deinterlacing mode. Possible values are `AutoPixelAdaptive` or `Off`. Default to `AutoPixelAdaptive`.
        """
        return pulumi.get(self, "mode")

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


@pulumi.output_type
class TransformOutputCustomPresetFilterFadeIn(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fadeColor":
            suggest = "fade_color"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetFilterFadeIn. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetFilterFadeIn.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetFilterFadeIn.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 duration: str,
                 fade_color: str,
                 start: Optional[str] = None):
        """
        :param 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 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 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) -> 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")

    @property
    @pulumi.getter(name="fadeColor")
    def fade_color(self) -> 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")

    @property
    @pulumi.getter
    def start(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPresetFilterFadeOut(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fadeColor":
            suggest = "fade_color"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetFilterFadeOut. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetFilterFadeOut.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetFilterFadeOut.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 duration: str,
                 fade_color: str,
                 start: Optional[str] = None):
        """
        :param 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 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 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) -> 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")

    @property
    @pulumi.getter(name="fadeColor")
    def fade_color(self) -> 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")

    @property
    @pulumi.getter
    def start(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPresetFilterOverlay(dict):
    def __init__(__self__, *,
                 audio: Optional['outputs.TransformOutputCustomPresetFilterOverlayAudio'] = None,
                 video: Optional['outputs.TransformOutputCustomPresetFilterOverlayVideo'] = None):
        """
        :param 'TransformOutputCustomPresetFilterOverlayAudioArgs' audio: An `audio` block as defined above.
        :param '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['outputs.TransformOutputCustomPresetFilterOverlayAudio']:
        """
        An `audio` block as defined above.
        """
        return pulumi.get(self, "audio")

    @property
    @pulumi.getter
    def video(self) -> Optional['outputs.TransformOutputCustomPresetFilterOverlayVideo']:
        """
        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")


@pulumi.output_type
class TransformOutputCustomPresetFilterOverlayAudio(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "inputLabel":
            suggest = "input_label"
        elif key == "audioGainLevel":
            suggest = "audio_gain_level"
        elif key == "fadeInDuration":
            suggest = "fade_in_duration"
        elif key == "fadeOutDuration":
            suggest = "fade_out_duration"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetFilterOverlayAudio. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetFilterOverlayAudio.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetFilterOverlayAudio.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 input_label: str,
                 audio_gain_level: Optional[float] = None,
                 end: Optional[str] = None,
                 fade_in_duration: Optional[str] = None,
                 fade_out_duration: Optional[str] = None,
                 start: Optional[str] = None):
        """
        :param 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 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 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 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 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 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) -> 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")

    @property
    @pulumi.getter(name="audioGainLevel")
    def audio_gain_level(self) -> Optional[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")

    @property
    @pulumi.getter
    def end(self) -> Optional[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")

    @property
    @pulumi.getter(name="fadeInDuration")
    def fade_in_duration(self) -> Optional[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")

    @property
    @pulumi.getter(name="fadeOutDuration")
    def fade_out_duration(self) -> Optional[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")

    @property
    @pulumi.getter
    def start(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPresetFilterOverlayVideo(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "inputLabel":
            suggest = "input_label"
        elif key == "audioGainLevel":
            suggest = "audio_gain_level"
        elif key == "cropRectangle":
            suggest = "crop_rectangle"
        elif key == "fadeInDuration":
            suggest = "fade_in_duration"
        elif key == "fadeOutDuration":
            suggest = "fade_out_duration"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetFilterOverlayVideo. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetFilterOverlayVideo.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetFilterOverlayVideo.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 input_label: str,
                 audio_gain_level: Optional[float] = None,
                 crop_rectangle: Optional['outputs.TransformOutputCustomPresetFilterOverlayVideoCropRectangle'] = None,
                 end: Optional[str] = None,
                 fade_in_duration: Optional[str] = None,
                 fade_out_duration: Optional[str] = None,
                 opacity: Optional[float] = None,
                 position: Optional['outputs.TransformOutputCustomPresetFilterOverlayVideoPosition'] = None,
                 start: Optional[str] = None):
        """
        :param 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 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 'TransformOutputCustomPresetFilterOverlayVideoCropRectangleArgs' crop_rectangle: A `crop_rectangle` block as defined above.
        :param 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 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 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 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 'TransformOutputCustomPresetFilterOverlayVideoPositionArgs' position: A `position` block as defined above.
        :param 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) -> 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")

    @property
    @pulumi.getter(name="audioGainLevel")
    def audio_gain_level(self) -> Optional[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")

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

    @property
    @pulumi.getter
    def end(self) -> Optional[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")

    @property
    @pulumi.getter(name="fadeInDuration")
    def fade_in_duration(self) -> Optional[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")

    @property
    @pulumi.getter(name="fadeOutDuration")
    def fade_out_duration(self) -> Optional[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")

    @property
    @pulumi.getter
    def opacity(self) -> Optional[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")

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

    @property
    @pulumi.getter
    def start(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPresetFilterOverlayVideoCropRectangle(dict):
    def __init__(__self__, *,
                 height: Optional[str] = None,
                 left: Optional[str] = None,
                 top: Optional[str] = None,
                 width: Optional[str] = None):
        """
        :param 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 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 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 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[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")

    @property
    @pulumi.getter
    def left(self) -> Optional[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")

    @property
    @pulumi.getter
    def top(self) -> Optional[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")

    @property
    @pulumi.getter
    def width(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPresetFilterOverlayVideoPosition(dict):
    def __init__(__self__, *,
                 height: Optional[str] = None,
                 left: Optional[str] = None,
                 top: Optional[str] = None,
                 width: Optional[str] = None):
        """
        :param 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 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 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 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[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")

    @property
    @pulumi.getter
    def left(self) -> Optional[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")

    @property
    @pulumi.getter
    def top(self) -> Optional[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")

    @property
    @pulumi.getter
    def width(self) -> Optional[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")


@pulumi.output_type
class TransformOutputCustomPresetFormat(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "transportStream":
            suggest = "transport_stream"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetFormat. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetFormat.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetFormat.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 jpg: Optional['outputs.TransformOutputCustomPresetFormatJpg'] = None,
                 mp4: Optional['outputs.TransformOutputCustomPresetFormatMp4'] = None,
                 png: Optional['outputs.TransformOutputCustomPresetFormatPng'] = None,
                 transport_stream: Optional['outputs.TransformOutputCustomPresetFormatTransportStream'] = None):
        """
        :param 'TransformOutputCustomPresetFormatJpgArgs' jpg: A `jpg` block as defined below.
        :param 'TransformOutputCustomPresetFormatMp4Args' mp4: A `mp4` block as defined below.
        :param 'TransformOutputCustomPresetFormatPngArgs' png: A `png` block as defined below.
        :param '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['outputs.TransformOutputCustomPresetFormatJpg']:
        """
        A `jpg` block as defined below.
        """
        return pulumi.get(self, "jpg")

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

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

    @property
    @pulumi.getter(name="transportStream")
    def transport_stream(self) -> Optional['outputs.TransformOutputCustomPresetFormatTransportStream']:
        """
        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")


@pulumi.output_type
class TransformOutputCustomPresetFormatJpg(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "filenamePattern":
            suggest = "filename_pattern"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetFormatJpg. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetFormatJpg.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetFormatJpg.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 filename_pattern: str):
        """
        :param 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) -> 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")


@pulumi.output_type
class TransformOutputCustomPresetFormatMp4(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "filenamePattern":
            suggest = "filename_pattern"
        elif key == "outputFiles":
            suggest = "output_files"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetFormatMp4. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetFormatMp4.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetFormatMp4.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 filename_pattern: str,
                 output_files: Optional[Sequence['outputs.TransformOutputCustomPresetFormatMp4OutputFile']] = None):
        """
        :param 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 Sequence['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) -> 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")

    @property
    @pulumi.getter(name="outputFiles")
    def output_files(self) -> Optional[Sequence['outputs.TransformOutputCustomPresetFormatMp4OutputFile']]:
        """
        One or more `output_file` blocks as defined below.
        """
        return pulumi.get(self, "output_files")


@pulumi.output_type
class TransformOutputCustomPresetFormatMp4OutputFile(dict):
    def __init__(__self__, *,
                 labels: Sequence[str]):
        """
        :param Sequence[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) -> Sequence[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")


@pulumi.output_type
class TransformOutputCustomPresetFormatPng(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "filenamePattern":
            suggest = "filename_pattern"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetFormatPng. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetFormatPng.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetFormatPng.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 filename_pattern: str):
        """
        :param 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) -> 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")


@pulumi.output_type
class TransformOutputCustomPresetFormatTransportStream(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "filenamePattern":
            suggest = "filename_pattern"
        elif key == "outputFiles":
            suggest = "output_files"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputCustomPresetFormatTransportStream. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputCustomPresetFormatTransportStream.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputCustomPresetFormatTransportStream.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 filename_pattern: str,
                 output_files: Optional[Sequence['outputs.TransformOutputCustomPresetFormatTransportStreamOutputFile']] = None):
        """
        :param 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 Sequence['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) -> 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")

    @property
    @pulumi.getter(name="outputFiles")
    def output_files(self) -> Optional[Sequence['outputs.TransformOutputCustomPresetFormatTransportStreamOutputFile']]:
        """
        One or more `output_file` blocks as defined above.
        """
        return pulumi.get(self, "output_files")


@pulumi.output_type
class TransformOutputCustomPresetFormatTransportStreamOutputFile(dict):
    def __init__(__self__, *,
                 labels: Sequence[str]):
        """
        :param Sequence[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) -> Sequence[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")


@pulumi.output_type
class TransformOutputFaceDetectorPreset(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "analysisResolution":
            suggest = "analysis_resolution"
        elif key == "blurType":
            suggest = "blur_type"
        elif key == "experimentalOptions":
            suggest = "experimental_options"
        elif key == "faceRedactorMode":
            suggest = "face_redactor_mode"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputFaceDetectorPreset. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputFaceDetectorPreset.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputFaceDetectorPreset.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 analysis_resolution: Optional[str] = None,
                 blur_type: Optional[str] = None,
                 experimental_options: Optional[Mapping[str, str]] = None,
                 face_redactor_mode: Optional[str] = None):
        """
        :param 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 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 Mapping[str, str] experimental_options: Dictionary containing key value pairs for parameters not exposed in the preset itself.
        :param 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[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")

    @property
    @pulumi.getter(name="blurType")
    def blur_type(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="faceRedactorMode")
    def face_redactor_mode(self) -> Optional[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")


@pulumi.output_type
class TransformOutputVideoAnalyzerPreset(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "audioAnalysisMode":
            suggest = "audio_analysis_mode"
        elif key == "audioLanguage":
            suggest = "audio_language"
        elif key == "experimentalOptions":
            suggest = "experimental_options"
        elif key == "insightsType":
            suggest = "insights_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TransformOutputVideoAnalyzerPreset. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TransformOutputVideoAnalyzerPreset.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TransformOutputVideoAnalyzerPreset.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 audio_analysis_mode: Optional[str] = None,
                 audio_language: Optional[str] = None,
                 experimental_options: Optional[Mapping[str, str]] = None,
                 insights_type: Optional[str] = None):
        """
        :param str audio_analysis_mode: Possible values are `Basic` or `Standard`. Determines the set of audio analysis operations to be performed. Default to `Standard`.
        :param 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 Mapping[str, str] experimental_options: Dictionary containing key value pairs for parameters not exposed in the preset itself.
        :param 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[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")

    @property
    @pulumi.getter(name="audioLanguage")
    def audio_language(self) -> Optional[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")

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

    @property
    @pulumi.getter(name="insightsType")
    def insights_type(self) -> Optional[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")


