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

__all__ = [
    'AssetFilterPresentationTimeRange',
    'AssetFilterTrackSelection',
    'AssetFilterTrackSelectionCondition',
    'ContentKeyPolicyPolicyOption',
    'ContentKeyPolicyPolicyOptionFairplayConfiguration',
    'ContentKeyPolicyPolicyOptionFairplayConfigurationOfflineRentalConfiguration',
    'ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicense',
    'ContentKeyPolicyPolicyOptionPlayreadyConfigurationLicensePlayRight',
    'ContentKeyPolicyPolicyOptionTokenRestriction',
    'ContentKeyPolicyPolicyOptionTokenRestrictionRequiredClaim',
    'JobInputAsset',
    'JobOutputAsset',
    'LiveEventCrossSiteAccessPolicy',
    'LiveEventEncoding',
    'LiveEventInput',
    'LiveEventInputEndpoint',
    'LiveEventInputIpAccessControlAllow',
    'LiveEventPreview',
    'LiveEventPreviewEndpoint',
    'LiveEventPreviewIpAccessControlAllow',
    'ServiceAccountIdentity',
    'ServiceAccountKeyDeliveryAccessControl',
    'ServiceAccountStorageAccount',
    'StreamingEndpointAccessControl',
    'StreamingEndpointAccessControlAkamaiSignatureHeaderAuthenticationKey',
    'StreamingEndpointAccessControlIpAllow',
    'StreamingEndpointCrossSiteAccessPolicy',
    'StreamingLocatorContentKey',
    'StreamingPolicyCommonEncryptionCbcs',
    'StreamingPolicyCommonEncryptionCbcsDefaultContentKey',
    'StreamingPolicyCommonEncryptionCbcsDrmFairplay',
    'StreamingPolicyCommonEncryptionCbcsEnabledProtocols',
    'StreamingPolicyCommonEncryptionCenc',
    'StreamingPolicyCommonEncryptionCencDefaultContentKey',
    'StreamingPolicyCommonEncryptionCencDrmPlayready',
    'StreamingPolicyCommonEncryptionCencEnabledProtocols',
    'StreamingPolicyNoEncryptionEnabledProtocols',
    'TransformOutput',
    'TransformOutputAudioAnalyzerPreset',
    'TransformOutputBuiltinPreset',
    'TransformOutputFaceDetectorPreset',
    'TransformOutputVideoAnalyzerPreset',
]

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

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

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

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

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

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

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

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

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

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

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


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

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


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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

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

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


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

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

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


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

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 key_frame_interval: Optional[str] = None,
                 preset_name: Optional[str] = None,
                 stretch_mode: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param str key_frame_interval: Use an `ISO 8601` time value between 0.5 to 20 seconds to specify the output fragment length for the video and audio tracks of an encoding live event. For example, use `PT2S` to indicate 2 seconds. For the video track it also defines the key frame interval, or the length of a GoP (group of pictures). 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 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 str stretch_mode: Specifies how the input video will be resized to fit the desired output resolution(s). Allowed values are `None`, `AutoFit` or `AutoSize`. Default is `None`.
        :param str type: Live event type. 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[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")

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

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

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


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

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

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

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

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

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

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

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

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

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


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

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

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


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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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


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

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

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


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

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

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 principal_id: Optional[str] = None,
                 tenant_id: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param str principal_id: The Principal ID associated with this Managed Service Identity.
        :param str tenant_id: The Tenant ID associated with this Managed Service Identity.
        :param str type: Specifies the type of Managed Service Identity that should be configured on this Media Services Account. Possible value is  `SystemAssigned`.
        """
        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)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 default_content_key: Optional['outputs.StreamingPolicyCommonEncryptionCencDefaultContentKey'] = None,
                 drm_playready: Optional['outputs.StreamingPolicyCommonEncryptionCencDrmPlayready'] = None,
                 drm_widevine_custom_license_acquisition_url_template: Optional[str] = None,
                 enabled_protocols: Optional['outputs.StreamingPolicyCommonEncryptionCencEnabledProtocols'] = None):
        """
        :param 'StreamingPolicyCommonEncryptionCencDefaultContentKeyArgs' default_content_key: A `default_content_key` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param 'StreamingPolicyCommonEncryptionCencDrmPlayreadyArgs' drm_playready: A `drm_playready` block as defined below. Changing this forces a new Streaming Policy to be created.
        :param str drm_widevine_custom_license_acquisition_url_template: 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 '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['outputs.StreamingPolicyCommonEncryptionCencDefaultContentKey']:
        """
        A `default_content_key` block as defined below. Changing this forces a new Streaming Policy to be created.
        """
        return pulumi.get(self, "default_content_key")

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

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

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


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

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

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

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

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

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

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


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

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

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

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

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

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


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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 audio_analysis_mode: Optional[str] = None,
                 audio_language: Optional[str] = None):
        """
        :param str audio_analysis_mode: Possibles value are `Basic` or `Standard`. Determines the set of audio analysis operations to be performed.
        :param str audio_language: The language for the audio payload in the input using the BCP-47 format of 'language tag-region' (e.g: 'en-US'). If you know the language of your content, it is recommended that you specify it. The language must be specified explicitly for AudioAnalysisMode:Basic, since automatic language detection is not included in basic mode. If the language isn't specified, automatic language detection will choose the first language detected and process with the selected language for the duration of the file. It does not currently support dynamically switching between languages after the first language is detected. The automatic detection works best with audio recordings with clearly discernable 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[str]:
        """
        Possibles value are `Basic` or `Standard`. Determines the set of audio analysis operations to be performed.
        """
        return pulumi.get(self, "audio_analysis_mode")

    @property
    @pulumi.getter(name="audioLanguage")
    def audio_language(self) -> Optional[str]:
        """
        The language for the audio payload in the input using the BCP-47 format of 'language tag-region' (e.g: 'en-US'). If you know the language of your content, it is recommended that you specify it. The language must be specified explicitly for AudioAnalysisMode:Basic, since automatic language detection is not included in basic mode. If the language isn't specified, automatic language detection will choose the first language detected and process with the selected language for the duration of the file. It does not currently support dynamically switching between languages after the first language is detected. The automatic detection works best with audio recordings with clearly discernable 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")


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

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

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

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

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


@pulumi.output_type
class TransformOutputFaceDetectorPreset(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "analysisResolution":
            suggest = "analysis_resolution"

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 audio_analysis_mode: Optional[str] = None,
                 audio_language: Optional[str] = None,
                 insights_type: Optional[str] = None):
        """
        :param str audio_analysis_mode: Possibles value are `Basic` or `Standard`. Determines the set of audio analysis operations to be performed.
        :param str audio_language: The language for the audio payload in the input using the BCP-47 format of 'language tag-region' (e.g: 'en-US'). If you know the language of your content, it is recommended that you specify it. The language must be specified explicitly for AudioAnalysisMode:Basic, since automatic language detection is not included in basic mode. If the language isn't specified, automatic language detection will choose the first language detected and process with the selected language for the duration of the file. It does not currently support dynamically switching between languages after the first language is detected. The automatic detection works best with audio recordings with clearly discernable 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 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[str]:
        """
        Possibles value are `Basic` or `Standard`. Determines the set of audio analysis operations to be performed.
        """
        return pulumi.get(self, "audio_analysis_mode")

    @property
    @pulumi.getter(name="audioLanguage")
    def audio_language(self) -> Optional[str]:
        """
        The language for the audio payload in the input using the BCP-47 format of 'language tag-region' (e.g: 'en-US'). If you know the language of your content, it is recommended that you specify it. The language must be specified explicitly for AudioAnalysisMode:Basic, since automatic language detection is not included in basic mode. If the language isn't specified, automatic language detection will choose the first language detected and process with the selected language for the duration of the file. It does not currently support dynamically switching between languages after the first language is detected. The automatic detection works best with audio recordings with clearly discernable 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")

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


