# 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 warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'AssetFilterPresentationTimeRangeArgs',
    'AssetFilterTrackSelectionArgs',
    'AssetFilterTrackSelectionConditionArgs',
    'ContentKeyPolicyPolicyOptionArgs',
    'ContentKeyPolicyPolicyOptionFairplayConfigurationArgs',
    'ContentKeyPolicyPolicyOptionFairplayConfigurationOfflineRentalConfigurationArgs',
    'ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicenseArgs',
    'ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRightArgs',
    'ContentKeyPolicyPolicyOptionTokenRestrictionArgs',
    'ContentKeyPolicyPolicyOptionTokenRestrictionRequiredClaimArgs',
    'JobInputAssetArgs',
    'JobOutputAssetArgs',
    'LiveEventCrossSiteAccessPolicyArgs',
    'LiveEventEncodingArgs',
    'LiveEventInputArgs',
    'LiveEventInputEndpointArgs',
    'LiveEventInputIpAccessControlAllowArgs',
    'LiveEventPreviewArgs',
    'LiveEventPreviewEndpointArgs',
    'LiveEventPreviewIpAccessControlAllowArgs',
    'ServiceAccountIdentityArgs',
    'ServiceAccountKeyDeliveryAccessControlArgs',
    'ServiceAccountStorageAccountArgs',
    'StreamingEndpointAccessControlArgs',
    'StreamingEndpointAccessControlAkamaiSignatureHeaderAuthenticationKeyArgs',
    'StreamingEndpointAccessControlIpAllowArgs',
    'StreamingEndpointCrossSiteAccessPolicyArgs',
    'StreamingLocatorContentKeyArgs',
    'StreamingPolicyCommonEncryptionCbcsArgs',
    'StreamingPolicyCommonEncryptionCbcsDefaultContentKeyArgs',
    'StreamingPolicyCommonEncryptionCbcsDrmFairplayArgs',
    'StreamingPolicyCommonEncryptionCbcsEnabledProtocolsArgs',
    'StreamingPolicyCommonEncryptionCencArgs',
    'StreamingPolicyCommonEncryptionCencDefaultContentKeyArgs',
    'StreamingPolicyCommonEncryptionCencDrmPlayreadyArgs',
    'StreamingPolicyCommonEncryptionCencEnabledProtocolsArgs',
    'StreamingPolicyNoEncryptionEnabledProtocolsArgs',
    'TransformOutputArgs',
    'TransformOutputAudioAnalyzerPresetArgs',
    'TransformOutputBuiltinPresetArgs',
    'TransformOutputFaceDetectorPresetArgs',
    'TransformOutputVideoAnalyzerPresetArgs',
]

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

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

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

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

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

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

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


@pulumi.input_type
class ContentKeyPolicyPolicyOptionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 clear_key_configuration_enabled: Optional[pulumi.Input[bool]] = None,
                 fairplay_configuration: Optional[pulumi.Input['ContentKeyPolicyPolicyOptionFairplayConfigurationArgs']] = None,
                 open_restriction_enabled: Optional[pulumi.Input[bool]] = None,
                 playready_configuration_licenses: Optional[pulumi.Input[Sequence[pulumi.Input['ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicenseArgs']]]] = None,
                 token_restriction: Optional[pulumi.Input['ContentKeyPolicyPolicyOptionTokenRestrictionArgs']] = None,
                 widevine_configuration_template: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] name: The name which should be used for this Policy Option.
        :param pulumi.Input[bool] clear_key_configuration_enabled: Enable a configuration for non-DRM keys.
        :param pulumi.Input['ContentKeyPolicyPolicyOptionFairplayConfigurationArgs'] fairplay_configuration: A `fairplay_configuration` block as defined above. Check license requirements here https://docs.microsoft.com/azure/media-services/latest/fairplay-license-overview.
        :param pulumi.Input[bool] open_restriction_enabled: Enable an open restriction. License or key will be delivered on every request.
        :param pulumi.Input[Sequence[pulumi.Input['ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicenseArgs']]] playready_configuration_licenses: One or more `playready_configuration_license` blocks as defined above.
        :param pulumi.Input['ContentKeyPolicyPolicyOptionTokenRestrictionArgs'] token_restriction: A `token_restriction` block as defined below.
        :param pulumi.Input[str] widevine_configuration_template: The Widevine template.
        """
        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 token_restriction is not None:
            pulumi.set(__self__, "token_restriction", token_restriction)
        if widevine_configuration_template is not None:
            pulumi.set(__self__, "widevine_configuration_template", widevine_configuration_template)

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class ContentKeyPolicyPolicyOptionTokenRestrictionArgs:
    def __init__(__self__, *,
                 audience: Optional[pulumi.Input[str]] = None,
                 issuer: Optional[pulumi.Input[str]] = None,
                 open_id_connect_discovery_document: Optional[pulumi.Input[str]] = None,
                 primary_rsa_token_key_exponent: Optional[pulumi.Input[str]] = None,
                 primary_rsa_token_key_modulus: Optional[pulumi.Input[str]] = None,
                 primary_symmetric_token_key: Optional[pulumi.Input[str]] = None,
                 primary_x509_token_key_raw: Optional[pulumi.Input[str]] = None,
                 required_claims: Optional[pulumi.Input[Sequence[pulumi.Input['ContentKeyPolicyPolicyOptionTokenRestrictionRequiredClaimArgs']]]] = None,
                 token_type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] audience: The audience for the token.
        :param pulumi.Input[str] issuer: The token issuer.
        :param pulumi.Input[str] open_id_connect_discovery_document: The OpenID connect discovery document.
        :param pulumi.Input[str] primary_rsa_token_key_exponent: The RSA Parameter exponent.
        :param pulumi.Input[str] primary_rsa_token_key_modulus: The RSA Parameter modulus.
        :param pulumi.Input[str] primary_symmetric_token_key: The key value of the key. Specifies a symmetric key for token validation.
        :param pulumi.Input[str] primary_x509_token_key_raw: The raw data field of a certificate in PKCS 12 format (X509Certificate2 in .NET). Specifies a certificate for token validation.
        :param pulumi.Input[Sequence[pulumi.Input['ContentKeyPolicyPolicyOptionTokenRestrictionRequiredClaimArgs']]] required_claims: One or more `required_claim` blocks as defined above.
        :param pulumi.Input[str] token_type: The type of token. Supported values are `Jwt` or `Swt`.
        """
        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
    def audience(self) -> Optional[pulumi.Input[str]]:
        """
        The audience for the token.
        """
        return pulumi.get(self, "audience")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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

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

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


@pulumi.input_type
class LiveEventEncodingArgs:
    def __init__(__self__, *,
                 key_frame_interval: Optional[pulumi.Input[str]] = None,
                 preset_name: Optional[pulumi.Input[str]] = None,
                 stretch_mode: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] key_frame_interval: Use an `ISO 8601` time value between 0.5 to 20 seconds to specify the output fragment length for the video and audio tracks of an encoding live event. For example, use `PT2S` to indicate 2 seconds. For the video track it also defines the key frame interval, or the length of a GoP (group of pictures). If this value is not set for an encoding live event, the fragment duration defaults to 2 seconds. The value cannot be set for pass-through live events.
        :param pulumi.Input[str] preset_name: The optional encoding preset name, used when `type` is not `None`. If the `type` is set to `Standard`, then the default preset name is `Default720p`. Else if the `type` is set to `Premium1080p`, the default preset is `Default1080p`. Changing this forces a new resource to be created.
        :param pulumi.Input[str] stretch_mode: Specifies how the input video will be resized to fit the desired output resolution(s). Allowed values are `None`, `AutoFit` or `AutoSize`. Default is `None`.
        :param pulumi.Input[str] type: Live event type. Allowed values are `None`, `Premium1080p` or `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.
        """
        if key_frame_interval is not None:
            pulumi.set(__self__, "key_frame_interval", key_frame_interval)
        if preset_name is not None:
            pulumi.set(__self__, "preset_name", preset_name)
        if stretch_mode is not None:
            pulumi.set(__self__, "stretch_mode", stretch_mode)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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

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

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

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

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

    @property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[str]]:
        """
        Live event type. Allowed values are `None`, `Premium1080p` or `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.
        """
        return pulumi.get(self, "type")

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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

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


@pulumi.input_type
class ServiceAccountIdentityArgs:
    def __init__(__self__, *,
                 type: pulumi.Input[str],
                 principal_id: Optional[pulumi.Input[str]] = None,
                 tenant_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] type: Specifies the type of Managed Service Identity that should be configured on this Media Services Account. Possible value is  `SystemAssigned`.
        :param pulumi.Input[str] principal_id: The Principal ID associated with this Managed Service Identity.
        :param pulumi.Input[str] tenant_id: The Tenant ID associated with this Managed Service Identity.
        """
        pulumi.set(__self__, "type", type)
        if principal_id is not None:
            pulumi.set(__self__, "principal_id", principal_id)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)

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

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

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

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

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

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


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

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

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

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

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


@pulumi.input_type
class ServiceAccountStorageAccountArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 is_primary: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] id: Specifies the ID of the Storage Account that will be associated with the Media Services instance.
        :param pulumi.Input[bool] is_primary: Specifies whether the storage account should be the primary account or not. Defaults to `false`.
        """
        pulumi.set(__self__, "id", id)
        if is_primary is not None:
            pulumi.set(__self__, "is_primary", is_primary)

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCbcsArgs:
    def __init__(__self__, *,
                 default_content_key: Optional[pulumi.Input['StreamingPolicyCommonEncryptionCbcsDefaultContentKeyArgs']] = None,
                 drm_fairplay: Optional[pulumi.Input['StreamingPolicyCommonEncryptionCbcsDrmFairplayArgs']] = None,
                 enabled_protocols: Optional[pulumi.Input['StreamingPolicyCommonEncryptionCbcsEnabledProtocolsArgs']] = None):
        """
        :param pulumi.Input['StreamingPolicyCommonEncryptionCbcsDefaultContentKeyArgs'] default_content_key: A `default_content_key` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input['StreamingPolicyCommonEncryptionCbcsDrmFairplayArgs'] drm_fairplay: A `drm_fairplay` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input['StreamingPolicyCommonEncryptionCbcsEnabledProtocolsArgs'] enabled_protocols: A `enabled_protocols` block as defined below. Changing this forces a new Streaming Policy to be created.
        """
        if 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="defaultContentKey")
    def default_content_key(self) -> Optional[pulumi.Input['StreamingPolicyCommonEncryptionCbcsDefaultContentKeyArgs']]:
        """
        A `default_content_key` block as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "default_content_key")

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

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

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

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

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


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

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

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

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

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCbcsDrmFairplayArgs:
    def __init__(__self__, *,
                 allow_persistent_license: Optional[pulumi.Input[bool]] = None,
                 custom_license_acquisition_url_template: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] allow_persistent_license: All license to be persistent or not. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[str] custom_license_acquisition_url_template: Template for the URL of the custom service delivering licenses to end user players. Not required when using Azure Media Services for issuing licenses. The template supports replaceable tokens that the service will update at runtime with the value specific to the request. The currently supported token values are `{AlternativeMediaId}`, which is replaced with the value of `StreamingLocatorId.AlternativeMediaId`, and `{ContentKeyId}`, which is replaced with the value of identifier of the key being requested. Changing this forces a new Streaming Policy to be created.
        """
        if allow_persistent_license is not None:
            pulumi.set(__self__, "allow_persistent_license", allow_persistent_license)
        if custom_license_acquisition_url_template is not None:
            pulumi.set(__self__, "custom_license_acquisition_url_template", custom_license_acquisition_url_template)

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

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

    @property
    @pulumi.getter(name="customLicenseAcquisitionUrlTemplate")
    def custom_license_acquisition_url_template(self) -> Optional[pulumi.Input[str]]:
        """
        Template for the URL of the custom service delivering licenses to end user players. Not required when using Azure Media Services for issuing licenses. The template supports replaceable tokens that the service will update at runtime with the value specific to the request. The currently supported token values are `{AlternativeMediaId}`, which is replaced with the value of `StreamingLocatorId.AlternativeMediaId`, and `{ContentKeyId}`, which is replaced with the value of identifier of the key being requested. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "custom_license_acquisition_url_template")

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


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

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

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

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

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

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

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

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

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCencArgs:
    def __init__(__self__, *,
                 default_content_key: Optional[pulumi.Input['StreamingPolicyCommonEncryptionCencDefaultContentKeyArgs']] = None,
                 drm_playready: Optional[pulumi.Input['StreamingPolicyCommonEncryptionCencDrmPlayreadyArgs']] = None,
                 drm_widevine_custom_license_acquisition_url_template: Optional[pulumi.Input[str]] = None,
                 enabled_protocols: Optional[pulumi.Input['StreamingPolicyCommonEncryptionCencEnabledProtocolsArgs']] = None):
        """
        :param pulumi.Input['StreamingPolicyCommonEncryptionCencDefaultContentKeyArgs'] default_content_key: A `default_content_key` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input['StreamingPolicyCommonEncryptionCencDrmPlayreadyArgs'] drm_playready: A `drm_playready` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[str] drm_widevine_custom_license_acquisition_url_template: Template for the URL of the custom service delivering licenses to end user players. Not required when using Azure Media Services for issuing licenses. The template supports replaceable tokens that the service will update at runtime with the value specific to the request. The currently supported token values are `{AlternativeMediaId}`, which is replaced with the value of `StreamingLocatorId.AlternativeMediaId`, and `{ContentKeyId}`, which is replaced with the value of identifier of the key being requested. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input['StreamingPolicyCommonEncryptionCencEnabledProtocolsArgs'] enabled_protocols: A `enabled_protocols` block as defined below. Changing this forces a new Streaming Policy to be created.
        """
        if 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="defaultContentKey")
    def default_content_key(self) -> Optional[pulumi.Input['StreamingPolicyCommonEncryptionCencDefaultContentKeyArgs']]:
        """
        A `default_content_key` block as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "default_content_key")

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

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

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

    @property
    @pulumi.getter(name="drmWidevineCustomLicenseAcquisitionUrlTemplate")
    def drm_widevine_custom_license_acquisition_url_template(self) -> Optional[pulumi.Input[str]]:
        """
        Template for the URL of the custom service delivering licenses to end user players. Not required when using Azure Media Services for issuing licenses. The template supports replaceable tokens that the service will update at runtime with the value specific to the request. The currently supported token values are `{AlternativeMediaId}`, which is replaced with the value of `StreamingLocatorId.AlternativeMediaId`, and `{ContentKeyId}`, which is replaced with the value of identifier of the key being requested. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "drm_widevine_custom_license_acquisition_url_template")

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

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

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


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

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

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

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

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


@pulumi.input_type
class StreamingPolicyCommonEncryptionCencDrmPlayreadyArgs:
    def __init__(__self__, *,
                 custom_attributes: Optional[pulumi.Input[str]] = None,
                 custom_license_acquisition_url_template: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] custom_attributes: Custom attributes for PlayReady. Changing this forces a new Streaming Policy to be created.
        :param pulumi.Input[str] custom_license_acquisition_url_template: Template for the URL of the custom service delivering licenses to end user players. Not required when using Azure Media Services for issuing licenses. The template supports replaceable tokens that the service will update at runtime with the value specific to the request. The currently supported token values are `{AlternativeMediaId}`, which is replaced with the value of `StreamingLocatorId.AlternativeMediaId`, and `{ContentKeyId}`, which is replaced with the value of identifier of the key being requested. Changing this forces a new Streaming Policy to be created.
        """
        if custom_attributes is not None:
            pulumi.set(__self__, "custom_attributes", custom_attributes)
        if custom_license_acquisition_url_template is not None:
            pulumi.set(__self__, "custom_license_acquisition_url_template", custom_license_acquisition_url_template)

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

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

    @property
    @pulumi.getter(name="customLicenseAcquisitionUrlTemplate")
    def custom_license_acquisition_url_template(self) -> Optional[pulumi.Input[str]]:
        """
        Template for the URL of the custom service delivering licenses to end user players. Not required when using Azure Media Services for issuing licenses. The template supports replaceable tokens that the service will update at runtime with the value specific to the request. The currently supported token values are `{AlternativeMediaId}`, which is replaced with the value of `StreamingLocatorId.AlternativeMediaId`, and `{ContentKeyId}`, which is replaced with the value of identifier of the key being requested. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "custom_license_acquisition_url_template")

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


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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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


@pulumi.input_type
class TransformOutputArgs:
    def __init__(__self__, *,
                 audio_analyzer_preset: Optional[pulumi.Input['TransformOutputAudioAnalyzerPresetArgs']] = None,
                 builtin_preset: Optional[pulumi.Input['TransformOutputBuiltinPresetArgs']] = None,
                 face_detector_preset: Optional[pulumi.Input['TransformOutputFaceDetectorPresetArgs']] = None,
                 on_error_action: Optional[pulumi.Input[str]] = None,
                 relative_priority: Optional[pulumi.Input[str]] = None,
                 video_analyzer_preset: Optional[pulumi.Input['TransformOutputVideoAnalyzerPresetArgs']] = None):
        """
        :param pulumi.Input['TransformOutputAudioAnalyzerPresetArgs'] audio_analyzer_preset: A `audio_analyzer_preset` block as defined below.
        :param pulumi.Input['TransformOutputBuiltinPresetArgs'] builtin_preset: A `builtin_preset` block as defined below.
        :param pulumi.Input['TransformOutputFaceDetectorPresetArgs'] face_detector_preset: A `face_detector_preset` block as defined below.
        :param pulumi.Input[str] on_error_action: A Transform can define more than one outputs. This property defines what the service should do when one output fails - either continue to produce other outputs, or, stop the other outputs. The overall Job state will not reflect failures of outputs that are specified with `ContinueJob`. Possibles value are `StopProcessingJob` or `ContinueJob`.
        :param pulumi.Input[str] relative_priority: Sets the relative priority of the TransformOutputs within a Transform. This sets the priority that the service uses for processing Transform Outputs. Possibles value are `High`, `Normal` or `Low`.
        :param pulumi.Input['TransformOutputVideoAnalyzerPresetArgs'] video_analyzer_preset: A `video_analyzer_preset` block as defined below.
        """
        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 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[pulumi.Input['TransformOutputAudioAnalyzerPresetArgs']]:
        """
        A `audio_analyzer_preset` block as defined below.
        """
        return pulumi.get(self, "audio_analyzer_preset")

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


@pulumi.input_type
class TransformOutputBuiltinPresetArgs:
    def __init__(__self__, *,
                 preset_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] preset_name: The built-in preset to be used for encoding videos. The allowed values are `AACGoodQualityAudio`, `AdaptiveStreaming`,`ContentAwareEncoding`, `ContentAwareEncodingExperimental`,`CopyAllBitrateNonInterleaved`, `H264MultipleBitrate1080p`,`H264MultipleBitrate720p`, `H264MultipleBitrateSD`,`H264SingleBitrate1080p`, `H264SingleBitrate720p` and `H264SingleBitrateSD`.
        """
        if preset_name is not None:
            pulumi.set(__self__, "preset_name", preset_name)

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

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


@pulumi.input_type
class TransformOutputFaceDetectorPresetArgs:
    def __init__(__self__, *,
                 analysis_resolution: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] analysis_resolution: Possibles value are `SourceResolution` or `StandardDefinition`. Specifies the maximum resolution at which your video is analyzed. The default behavior is `SourceResolution` 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.
        """
        if analysis_resolution is not None:
            pulumi.set(__self__, "analysis_resolution", analysis_resolution)

    @property
    @pulumi.getter(name="analysisResolution")
    def analysis_resolution(self) -> Optional[pulumi.Input[str]]:
        """
        Possibles value are `SourceResolution` or `StandardDefinition`. Specifies the maximum resolution at which your video is analyzed. The default behavior is `SourceResolution` 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.
        """
        return pulumi.get(self, "analysis_resolution")

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


@pulumi.input_type
class TransformOutputVideoAnalyzerPresetArgs:
    def __init__(__self__, *,
                 audio_analysis_mode: Optional[pulumi.Input[str]] = None,
                 audio_language: Optional[pulumi.Input[str]] = None,
                 insights_type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] audio_analysis_mode: Possibles value are `Basic` or `Standard`. Determines the set of audio analysis operations to be performed.
        :param pulumi.Input[str] audio_language: The language for the audio payload in the input using the BCP-47 format of 'language tag-region' (e.g: 'en-US'). If you know the language of your content, it is recommended that you specify it. The language must be specified explicitly for AudioAnalysisMode:Basic, since automatic language detection is not included in basic mode. If the language isn't specified, automatic language detection will choose the first language detected and process with the selected language for the duration of the file. It does not currently support dynamically switching between languages after the first language is detected. The automatic detection works best with audio recordings with clearly discernible speech. If automatic detection fails to find the language, transcription would fallback to 'en-US'." The list of supported languages is available here: https://go.microsoft.com/fwlink/?linkid=2109463.
        :param pulumi.Input[str] insights_type: Defines the type of insights that you want the service to generate. The allowed values are `AudioInsightsOnly`, `VideoInsightsOnly`, and `AllInsights`. If you set this to `AllInsights` and the input is audio only, then only audio insights are generated. Similarly if the input is video only, then only video insights are generated. It is recommended that you not use `AudioInsightsOnly` if you expect some of your inputs to be video only; or use `VideoInsightsOnly` if you expect some of your inputs to be audio only. Your Jobs in such conditions would error out.
        """
        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 insights_type is not None:
            pulumi.set(__self__, "insights_type", insights_type)

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

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

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

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

    @property
    @pulumi.getter(name="insightsType")
    def insights_type(self) -> Optional[pulumi.Input[str]]:
        """
        Defines the type of insights that you want the service to generate. The allowed values are `AudioInsightsOnly`, `VideoInsightsOnly`, and `AllInsights`. If you set this to `AllInsights` and the input is audio only, then only audio insights are generated. Similarly if the input is video only, then only video insights are generated. It is recommended that you not use `AudioInsightsOnly` if you expect some of your inputs to be video only; or use `VideoInsightsOnly` if you expect some of your inputs to be audio only. Your Jobs in such conditions would error out.
        """
        return pulumi.get(self, "insights_type")

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


