All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.pulumi.azure.media.kotlin.TransformArgs.kt Maven / Gradle / Ivy

Go to download

Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.

There is a newer version: 6.14.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.azure.media.kotlin

import com.pulumi.azure.media.TransformArgs.builder
import com.pulumi.azure.media.kotlin.inputs.TransformOutputArgs
import com.pulumi.azure.media.kotlin.inputs.TransformOutputArgsBuilder
import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.jvm.JvmName

/**
 * Manages a Transform.
 * ## Example Usage
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as azure from "@pulumi/azure";
 * const example = new azure.core.ResourceGroup("example", {
 *     name: "media-resources",
 *     location: "West Europe",
 * });
 * const exampleAccount = new azure.storage.Account("example", {
 *     name: "examplestoracc",
 *     resourceGroupName: example.name,
 *     location: example.location,
 *     accountTier: "Standard",
 *     accountReplicationType: "GRS",
 * });
 * const exampleServiceAccount = new azure.media.ServiceAccount("example", {
 *     name: "examplemediaacc",
 *     location: example.location,
 *     resourceGroupName: example.name,
 *     storageAccounts: [{
 *         id: exampleAccount.id,
 *         isPrimary: true,
 *     }],
 * });
 * const exampleTransform = new azure.media.Transform("example", {
 *     name: "transform1",
 *     resourceGroupName: example.name,
 *     mediaServicesAccountName: exampleServiceAccount.name,
 *     description: "My transform description",
 *     outputs: [{
 *         relativePriority: "Normal",
 *         onErrorAction: "ContinueJob",
 *         builtinPreset: {
 *             presetName: "AACGoodQualityAudio",
 *         },
 *     }],
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_azure as azure
 * example = azure.core.ResourceGroup("example",
 *     name="media-resources",
 *     location="West Europe")
 * example_account = azure.storage.Account("example",
 *     name="examplestoracc",
 *     resource_group_name=example.name,
 *     location=example.location,
 *     account_tier="Standard",
 *     account_replication_type="GRS")
 * example_service_account = azure.media.ServiceAccount("example",
 *     name="examplemediaacc",
 *     location=example.location,
 *     resource_group_name=example.name,
 *     storage_accounts=[azure.media.ServiceAccountStorageAccountArgs(
 *         id=example_account.id,
 *         is_primary=True,
 *     )])
 * example_transform = azure.media.Transform("example",
 *     name="transform1",
 *     resource_group_name=example.name,
 *     media_services_account_name=example_service_account.name,
 *     description="My transform description",
 *     outputs=[azure.media.TransformOutputArgs(
 *         relative_priority="Normal",
 *         on_error_action="ContinueJob",
 *         builtin_preset=azure.media.TransformOutputBuiltinPresetArgs(
 *             preset_name="AACGoodQualityAudio",
 *         ),
 *     )])
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Azure = Pulumi.Azure;
 * return await Deployment.RunAsync(() =>
 * {
 *     var example = new Azure.Core.ResourceGroup("example", new()
 *     {
 *         Name = "media-resources",
 *         Location = "West Europe",
 *     });
 *     var exampleAccount = new Azure.Storage.Account("example", new()
 *     {
 *         Name = "examplestoracc",
 *         ResourceGroupName = example.Name,
 *         Location = example.Location,
 *         AccountTier = "Standard",
 *         AccountReplicationType = "GRS",
 *     });
 *     var exampleServiceAccount = new Azure.Media.ServiceAccount("example", new()
 *     {
 *         Name = "examplemediaacc",
 *         Location = example.Location,
 *         ResourceGroupName = example.Name,
 *         StorageAccounts = new[]
 *         {
 *             new Azure.Media.Inputs.ServiceAccountStorageAccountArgs
 *             {
 *                 Id = exampleAccount.Id,
 *                 IsPrimary = true,
 *             },
 *         },
 *     });
 *     var exampleTransform = new Azure.Media.Transform("example", new()
 *     {
 *         Name = "transform1",
 *         ResourceGroupName = example.Name,
 *         MediaServicesAccountName = exampleServiceAccount.Name,
 *         Description = "My transform description",
 *         Outputs = new[]
 *         {
 *             new Azure.Media.Inputs.TransformOutputArgs
 *             {
 *                 RelativePriority = "Normal",
 *                 OnErrorAction = "ContinueJob",
 *                 BuiltinPreset = new Azure.Media.Inputs.TransformOutputBuiltinPresetArgs
 *                 {
 *                     PresetName = "AACGoodQualityAudio",
 *                 },
 *             },
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
 * 	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/media"
 * 	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/storage"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
 * 			Name:     pulumi.String("media-resources"),
 * 			Location: pulumi.String("West Europe"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		exampleAccount, err := storage.NewAccount(ctx, "example", &storage.AccountArgs{
 * 			Name:                   pulumi.String("examplestoracc"),
 * 			ResourceGroupName:      example.Name,
 * 			Location:               example.Location,
 * 			AccountTier:            pulumi.String("Standard"),
 * 			AccountReplicationType: pulumi.String("GRS"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		exampleServiceAccount, err := media.NewServiceAccount(ctx, "example", &media.ServiceAccountArgs{
 * 			Name:              pulumi.String("examplemediaacc"),
 * 			Location:          example.Location,
 * 			ResourceGroupName: example.Name,
 * 			StorageAccounts: media.ServiceAccountStorageAccountArray{
 * 				&media.ServiceAccountStorageAccountArgs{
 * 					Id:        exampleAccount.ID(),
 * 					IsPrimary: pulumi.Bool(true),
 * 				},
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = media.NewTransform(ctx, "example", &media.TransformArgs{
 * 			Name:                     pulumi.String("transform1"),
 * 			ResourceGroupName:        example.Name,
 * 			MediaServicesAccountName: exampleServiceAccount.Name,
 * 			Description:              pulumi.String("My transform description"),
 * 			Outputs: media.TransformOutputTypeArray{
 * 				&media.TransformOutputTypeArgs{
 * 					RelativePriority: pulumi.String("Normal"),
 * 					OnErrorAction:    pulumi.String("ContinueJob"),
 * 					BuiltinPreset: &media.TransformOutputBuiltinPresetArgs{
 * 						PresetName: pulumi.String("AACGoodQualityAudio"),
 * 					},
 * 				},
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.azure.core.ResourceGroup;
 * import com.pulumi.azure.core.ResourceGroupArgs;
 * import com.pulumi.azure.storage.Account;
 * import com.pulumi.azure.storage.AccountArgs;
 * import com.pulumi.azure.media.ServiceAccount;
 * import com.pulumi.azure.media.ServiceAccountArgs;
 * import com.pulumi.azure.media.inputs.ServiceAccountStorageAccountArgs;
 * import com.pulumi.azure.media.Transform;
 * import com.pulumi.azure.media.TransformArgs;
 * import com.pulumi.azure.media.inputs.TransformOutputArgs;
 * import com.pulumi.azure.media.inputs.TransformOutputBuiltinPresetArgs;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         var example = new ResourceGroup("example", ResourceGroupArgs.builder()
 *             .name("media-resources")
 *             .location("West Europe")
 *             .build());
 *         var exampleAccount = new Account("exampleAccount", AccountArgs.builder()
 *             .name("examplestoracc")
 *             .resourceGroupName(example.name())
 *             .location(example.location())
 *             .accountTier("Standard")
 *             .accountReplicationType("GRS")
 *             .build());
 *         var exampleServiceAccount = new ServiceAccount("exampleServiceAccount", ServiceAccountArgs.builder()
 *             .name("examplemediaacc")
 *             .location(example.location())
 *             .resourceGroupName(example.name())
 *             .storageAccounts(ServiceAccountStorageAccountArgs.builder()
 *                 .id(exampleAccount.id())
 *                 .isPrimary(true)
 *                 .build())
 *             .build());
 *         var exampleTransform = new Transform("exampleTransform", TransformArgs.builder()
 *             .name("transform1")
 *             .resourceGroupName(example.name())
 *             .mediaServicesAccountName(exampleServiceAccount.name())
 *             .description("My transform description")
 *             .outputs(TransformOutputArgs.builder()
 *                 .relativePriority("Normal")
 *                 .onErrorAction("ContinueJob")
 *                 .builtinPreset(TransformOutputBuiltinPresetArgs.builder()
 *                     .presetName("AACGoodQualityAudio")
 *                     .build())
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   example:
 *     type: azure:core:ResourceGroup
 *     properties:
 *       name: media-resources
 *       location: West Europe
 *   exampleAccount:
 *     type: azure:storage:Account
 *     name: example
 *     properties:
 *       name: examplestoracc
 *       resourceGroupName: ${example.name}
 *       location: ${example.location}
 *       accountTier: Standard
 *       accountReplicationType: GRS
 *   exampleServiceAccount:
 *     type: azure:media:ServiceAccount
 *     name: example
 *     properties:
 *       name: examplemediaacc
 *       location: ${example.location}
 *       resourceGroupName: ${example.name}
 *       storageAccounts:
 *         - id: ${exampleAccount.id}
 *           isPrimary: true
 *   exampleTransform:
 *     type: azure:media:Transform
 *     name: example
 *     properties:
 *       name: transform1
 *       resourceGroupName: ${example.name}
 *       mediaServicesAccountName: ${exampleServiceAccount.name}
 *       description: My transform description
 *       outputs:
 *         - relativePriority: Normal
 *           onErrorAction: ContinueJob
 *           builtinPreset:
 *             presetName: AACGoodQualityAudio
 * ```
 * 
 * ### With Multiple Outputs
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as azure from "@pulumi/azure";
 * const example = new azure.core.ResourceGroup("example", {
 *     name: "media-resources",
 *     location: "West Europe",
 * });
 * const exampleAccount = new azure.storage.Account("example", {
 *     name: "examplestoracc",
 *     resourceGroupName: example.name,
 *     location: example.location,
 *     accountTier: "Standard",
 *     accountReplicationType: "GRS",
 * });
 * const exampleServiceAccount = new azure.media.ServiceAccount("example", {
 *     name: "examplemediaacc",
 *     location: example.location,
 *     resourceGroupName: example.name,
 *     storageAccounts: [{
 *         id: exampleAccount.id,
 *         isPrimary: true,
 *     }],
 * });
 * const exampleTransform = new azure.media.Transform("example", {
 *     name: "transform1",
 *     resourceGroupName: example.name,
 *     mediaServicesAccountName: exampleServiceAccount.name,
 *     description: "My transform description",
 *     outputs: [
 *         {
 *             relativePriority: "Normal",
 *             onErrorAction: "ContinueJob",
 *             builtinPreset: {
 *                 presetName: "AACGoodQualityAudio",
 *                 presetConfiguration: {
 *                     complexity: "Balanced",
 *                     interleaveOutput: "NonInterleavedOutput",
 *                     keyFrameIntervalInSeconds: 123122.5,
 *                     maxBitrateBps: 300000,
 *                     maxHeight: 480,
 *                     maxLayers: 14,
 *                     minBitrateBps: 200000,
 *                     minHeight: 360,
 *                 },
 *             },
 *         },
 *         {
 *             relativePriority: "Low",
 *             onErrorAction: "ContinueJob",
 *             audioAnalyzerPreset: {
 *                 audioLanguage: "en-US",
 *                 audioAnalysisMode: "Basic",
 *                 experimentalOptions: {
 *                     env: "test",
 *                 },
 *             },
 *         },
 *         {
 *             relativePriority: "Low",
 *             onErrorAction: "StopProcessingJob",
 *             faceDetectorPreset: {
 *                 analysisResolution: "StandardDefinition",
 *                 blurType: "Med",
 *                 faceRedactorMode: "Combined",
 *                 experimentalOptions: {
 *                     env: "test",
 *                 },
 *             },
 *         },
 *         {
 *             relativePriority: "Normal",
 *             onErrorAction: "StopProcessingJob",
 *             videoAnalyzerPreset: {
 *                 audioLanguage: "en-US",
 *                 audioAnalysisMode: "Basic",
 *                 insightsType: "AllInsights",
 *                 experimentalOptions: {
 *                     env: "test",
 *                 },
 *             },
 *         },
 *         {
 *             relativePriority: "Low",
 *             onErrorAction: "ContinueJob",
 *             customPreset: {
 *                 codecs: [
 *                     {
 *                         aacAudio: {
 *                             bitrate: 128000,
 *                             channels: 2,
 *                             samplingRate: 48000,
 *                             profile: "AacLc",
 *                         },
 *                     },
 *                     {
 *                         copyAudio: {
 *                             label: "test",
 *                         },
 *                     },
 *                     {
 *                         copyVideo: {
 *                             label: "test",
 *                         },
 *                     },
 *                     {
 *                         h264Video: {
 *                             keyFrameInterval: "PT1S",
 *                             stretchMode: "AutoSize",
 *                             syncMode: "Auto",
 *                             sceneChangeDetectionEnabled: false,
 *                             rateControlMode: "ABR",
 *                             complexity: "Quality",
 *                             layers: [
 *                                 {
 *                                     width: "64",
 *                                     height: "64",
 *                                     bitrate: 1045000,
 *                                     maxBitrate: 1045000,
 *                                     bFrames: 3,
 *                                     slices: 0,
 *                                     adaptiveBFrameEnabled: true,
 *                                     profile: "Auto",
 *                                     level: "auto",
 *                                     bufferWindow: "PT5S",
 *                                     referenceFrames: 4,
 *                                     crf: 23,
 *                                     entropyMode: "Cabac",
 *                                 },
 *                                 {
 *                                     width: "64",
 *                                     height: "64",
 *                                     bitrate: 1000,
 *                                     maxBitrate: 1000,
 *                                     bFrames: 3,
 *                                     frameRate: "32",
 *                                     slices: 1,
 *                                     adaptiveBFrameEnabled: true,
 *                                     profile: "High444",
 *                                     level: "auto",
 *                                     bufferWindow: "PT5S",
 *                                     referenceFrames: 4,
 *                                     crf: 23,
 *                                     entropyMode: "Cavlc",
 *                                 },
 *                             ],
 *                         },
 *                     },
 *                     {
 *                         h265Video: {
 *                             keyFrameInterval: "PT2S",
 *                             stretchMode: "AutoSize",
 *                             syncMode: "Auto",
 *                             sceneChangeDetectionEnabled: false,
 *                             complexity: "Speed",
 *                             layers: [{
 *                                 width: "64",
 *                                 height: "64",
 *                                 bitrate: 1045000,
 *                                 maxBitrate: 1045000,
 *                                 bFrames: 3,
 *                                 slices: 5,
 *                                 adaptiveBFrameEnabled: true,
 *                                 profile: "Auto",
 *                                 label: "test",
 *                                 level: "auto",
 *                                 bufferWindow: "PT5S",
 *                                 frameRate: "32",
 *                                 referenceFrames: 4,
 *                                 crf: 23,
 *                             }],
 *                         },
 *                     },
 *                     {
 *                         jpgImage: {
 *                             stretchMode: "AutoSize",
 *                             syncMode: "Auto",
 *                             start: "10",
 *                             range: "100%%",
 *                             spriteColumn: 1,
 *                             step: "10",
 *                             layers: [{
 *                                 quality: 70,
 *                                 height: "180",
 *                                 label: "test",
 *                                 width: "120",
 *                             }],
 *                         },
 *                     },
 *                     {
 *                         pngImage: {
 *                             stretchMode: "AutoSize",
 *                             syncMode: "Auto",
 *                             start: "{Best}",
 *                             range: "80",
 *                             step: "10",
 *                             layers: [{
 *                                 height: "180",
 *                                 label: "test",
 *                                 width: "120",
 *                             }],
 *                         },
 *                     },
 *                 ],
 *                 formats: [
 *                     {
 *                         jpg: {
 *                             filenamePattern: "test{Basename}",
 *                         },
 *                     },
 *                     {
 *                         mp4: {
 *                             filenamePattern: "test{Bitrate}",
 *                             outputFiles: [{
 *                                 labels: [
 *                                     "test",
 *                                     "ppe",
 *                                 ],
 *                             }],
 *                         },
 *                     },
 *                     {
 *                         png: {
 *                             filenamePattern: "test{Basename}",
 *                         },
 *                     },
 *                     {
 *                         transportStream: {
 *                             filenamePattern: "test{Bitrate}",
 *                             outputFiles: [{
 *                                 labels: ["prod"],
 *                             }],
 *                         },
 *                     },
 *                 ],
 *                 filter: {
 *                     cropRectangle: {
 *                         height: "240",
 *                         left: "30",
 *                         top: "360",
 *                         width: "70",
 *                     },
 *                     deinterlace: {
 *                         parity: "TopFieldFirst",
 *                         mode: "AutoPixelAdaptive",
 *                     },
 *                     fadeIn: {
 *                         duration: "PT5S",
 *                         fadeColor: "0xFF0000",
 *                         start: "10",
 *                     },
 *                     fadeOut: {
 *                         duration: "90%%",
 *                         fadeColor: "#FF0C7B",
 *                         start: "10%%",
 *                     },
 *                     rotation: "Auto",
 *                     overlays: [
 *                         {
 *                             audio: {
 *                                 inputLabel: "label.jpg",
 *                                 start: "PT5S",
 *                                 end: "PT30S",
 *                                 fadeInDuration: "PT1S",
 *                                 fadeOutDuration: "PT2S",
 *                                 audioGainLevel: 1,
 *                             },
 *                         },
 *                         {
 *                             video: {
 *                                 inputLabel: "label.jpg",
 *                                 start: "PT5S",
 *                                 end: "PT30S",
 *                                 fadeInDuration: "PT1S",
 *                                 fadeOutDuration: "PT2S",
 *                                 audioGainLevel: 1,
 *                                 opacity: 1,
 *                                 position: {
 *                                     height: "180",
 *                                     left: "20",
 *                                     top: "240",
 *                                     width: "140",
 *                                 },
 *                                 cropRectangle: {
 *                                     height: "240",
 *                                     left: "30",
 *                                     top: "360",
 *                                     width: "70",
 *                                 },
 *                             },
 *                         },
 *                     ],
 *                 },
 *             },
 *         },
 *     ],
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_azure as azure
 * example = azure.core.ResourceGroup("example",
 *     name="media-resources",
 *     location="West Europe")
 * example_account = azure.storage.Account("example",
 *     name="examplestoracc",
 *     resource_group_name=example.name,
 *     location=example.location,
 *     account_tier="Standard",
 *     account_replication_type="GRS")
 * example_service_account = azure.media.ServiceAccount("example",
 *     name="examplemediaacc",
 *     location=example.location,
 *     resource_group_name=example.name,
 *     storage_accounts=[azure.media.ServiceAccountStorageAccountArgs(
 *         id=example_account.id,
 *         is_primary=True,
 *     )])
 * example_transform = azure.media.Transform("example",
 *     name="transform1",
 *     resource_group_name=example.name,
 *     media_services_account_name=example_service_account.name,
 *     description="My transform description",
 *     outputs=[
 *         azure.media.TransformOutputArgs(
 *             relative_priority="Normal",
 *             on_error_action="ContinueJob",
 *             builtin_preset=azure.media.TransformOutputBuiltinPresetArgs(
 *                 preset_name="AACGoodQualityAudio",
 *                 preset_configuration=azure.media.TransformOutputBuiltinPresetPresetConfigurationArgs(
 *                     complexity="Balanced",
 *                     interleave_output="NonInterleavedOutput",
 *                     key_frame_interval_in_seconds=123122.5,
 *                     max_bitrate_bps=300000,
 *                     max_height=480,
 *                     max_layers=14,
 *                     min_bitrate_bps=200000,
 *                     min_height=360,
 *                 ),
 *             ),
 *         ),
 *         azure.media.TransformOutputArgs(
 *             relative_priority="Low",
 *             on_error_action="ContinueJob",
 *             audio_analyzer_preset=azure.media.TransformOutputAudioAnalyzerPresetArgs(
 *                 audio_language="en-US",
 *                 audio_analysis_mode="Basic",
 *                 experimental_options={
 *                     "env": "test",
 *                 },
 *             ),
 *         ),
 *         azure.media.TransformOutputArgs(
 *             relative_priority="Low",
 *             on_error_action="StopProcessingJob",
 *             face_detector_preset=azure.media.TransformOutputFaceDetectorPresetArgs(
 *                 analysis_resolution="StandardDefinition",
 *                 blur_type="Med",
 *                 face_redactor_mode="Combined",
 *                 experimental_options={
 *                     "env": "test",
 *                 },
 *             ),
 *         ),
 *         azure.media.TransformOutputArgs(
 *             relative_priority="Normal",
 *             on_error_action="StopProcessingJob",
 *             video_analyzer_preset=azure.media.TransformOutputVideoAnalyzerPresetArgs(
 *                 audio_language="en-US",
 *                 audio_analysis_mode="Basic",
 *                 insights_type="AllInsights",
 *                 experimental_options={
 *                     "env": "test",
 *                 },
 *             ),
 *         ),
 *         azure.media.TransformOutputArgs(
 *             relative_priority="Low",
 *             on_error_action="ContinueJob",
 *             custom_preset=azure.media.TransformOutputCustomPresetArgs(
 *                 codecs=[
 *                     azure.media.TransformOutputCustomPresetCodecArgs(
 *                         aac_audio=azure.media.TransformOutputCustomPresetCodecAacAudioArgs(
 *                             bitrate=128000,
 *                             channels=2,
 *                             sampling_rate=48000,
 *                             profile="AacLc",
 *                         ),
 *                     ),
 *                     azure.media.TransformOutputCustomPresetCodecArgs(
 *                         copy_audio=azure.media.TransformOutputCustomPresetCodecCopyAudioArgs(
 *                             label="test",
 *                         ),
 *                     ),
 *                     azure.media.TransformOutputCustomPresetCodecArgs(
 *                         copy_video=azure.media.TransformOutputCustomPresetCodecCopyVideoArgs(
 *                             label="test",
 *                         ),
 *                     ),
 *                     azure.media.TransformOutputCustomPresetCodecArgs(
 *                         h264_video=azure.media.TransformOutputCustomPresetCodecH264VideoArgs(
 *                             key_frame_interval="PT1S",
 *                             stretch_mode="AutoSize",
 *                             sync_mode="Auto",
 *                             scene_change_detection_enabled=False,
 *                             rate_control_mode="ABR",
 *                             complexity="Quality",
 *                             layers=[
 *                                 azure.media.TransformOutputCustomPresetCodecH264VideoLayerArgs(
 *                                     width="64",
 *                                     height="64",
 *                                     bitrate=1045000,
 *                                     max_bitrate=1045000,
 *                                     b_frames=3,
 *                                     slices=0,
 *                                     adaptive_b_frame_enabled=True,
 *                                     profile="Auto",
 *                                     level="auto",
 *                                     buffer_window="PT5S",
 *                                     reference_frames=4,
 *                                     crf=23,
 *                                     entropy_mode="Cabac",
 *                                 ),
 *                                 azure.media.TransformOutputCustomPresetCodecH264VideoLayerArgs(
 *                                     width="64",
 *                                     height="64",
 *                                     bitrate=1000,
 *                                     max_bitrate=1000,
 *                                     b_frames=3,
 *                                     frame_rate="32",
 *                                     slices=1,
 *                                     adaptive_b_frame_enabled=True,
 *                                     profile="High444",
 *                                     level="auto",
 *                                     buffer_window="PT5S",
 *                                     reference_frames=4,
 *                                     crf=23,
 *                                     entropy_mode="Cavlc",
 *                                 ),
 *                             ],
 *                         ),
 *                     ),
 *                     azure.media.TransformOutputCustomPresetCodecArgs(
 *                         h265_video=azure.media.TransformOutputCustomPresetCodecH265VideoArgs(
 *                             key_frame_interval="PT2S",
 *                             stretch_mode="AutoSize",
 *                             sync_mode="Auto",
 *                             scene_change_detection_enabled=False,
 *                             complexity="Speed",
 *                             layers=[azure.media.TransformOutputCustomPresetCodecH265VideoLayerArgs(
 *                                 width="64",
 *                                 height="64",
 *                                 bitrate=1045000,
 *                                 max_bitrate=1045000,
 *                                 b_frames=3,
 *                                 slices=5,
 *                                 adaptive_b_frame_enabled=True,
 *                                 profile="Auto",
 *                                 label="test",
 *                                 level="auto",
 *                                 buffer_window="PT5S",
 *                                 frame_rate="32",
 *                                 reference_frames=4,
 *                                 crf=23,
 *                             )],
 *                         ),
 *                     ),
 *                     azure.media.TransformOutputCustomPresetCodecArgs(
 *                         jpg_image=azure.media.TransformOutputCustomPresetCodecJpgImageArgs(
 *                             stretch_mode="AutoSize",
 *                             sync_mode="Auto",
 *                             start="10",
 *                             range="100%%",
 *                             sprite_column=1,
 *                             step="10",
 *                             layers=[azure.media.TransformOutputCustomPresetCodecJpgImageLayerArgs(
 *                                 quality=70,
 *                                 height="180",
 *                                 label="test",
 *                                 width="120",
 *                             )],
 *                         ),
 *                     ),
 *                     azure.media.TransformOutputCustomPresetCodecArgs(
 *                         png_image=azure.media.TransformOutputCustomPresetCodecPngImageArgs(
 *                             stretch_mode="AutoSize",
 *                             sync_mode="Auto",
 *                             start="{Best}",
 *                             range="80",
 *                             step="10",
 *                             layers=[azure.media.TransformOutputCustomPresetCodecPngImageLayerArgs(
 *                                 height="180",
 *                                 label="test",
 *                                 width="120",
 *                             )],
 *                         ),
 *                     ),
 *                 ],
 *                 formats=[
 *                     azure.media.TransformOutputCustomPresetFormatArgs(
 *                         jpg=azure.media.TransformOutputCustomPresetFormatJpgArgs(
 *                             filename_pattern="test{Basename}",
 *                         ),
 *                     ),
 *                     azure.media.TransformOutputCustomPresetFormatArgs(
 *                         mp4=azure.media.TransformOutputCustomPresetFormatMp4Args(
 *                             filename_pattern="test{Bitrate}",
 *                             output_files=[azure.media.TransformOutputCustomPresetFormatMp4OutputFileArgs(
 *                                 labels=[
 *                                     "test",
 *                                     "ppe",
 *                                 ],
 *                             )],
 *                         ),
 *                     ),
 *                     azure.media.TransformOutputCustomPresetFormatArgs(
 *                         png=azure.media.TransformOutputCustomPresetFormatPngArgs(
 *                             filename_pattern="test{Basename}",
 *                         ),
 *                     ),
 *                     azure.media.TransformOutputCustomPresetFormatArgs(
 *                         transport_stream=azure.media.TransformOutputCustomPresetFormatTransportStreamArgs(
 *                             filename_pattern="test{Bitrate}",
 *                             output_files=[azure.media.TransformOutputCustomPresetFormatTransportStreamOutputFileArgs(
 *                                 labels=["prod"],
 *                             )],
 *                         ),
 *                     ),
 *                 ],
 *                 filter=azure.media.TransformOutputCustomPresetFilterArgs(
 *                     crop_rectangle=azure.media.TransformOutputCustomPresetFilterCropRectangleArgs(
 *                         height="240",
 *                         left="30",
 *                         top="360",
 *                         width="70",
 *                     ),
 *                     deinterlace=azure.media.TransformOutputCustomPresetFilterDeinterlaceArgs(
 *                         parity="TopFieldFirst",
 *                         mode="AutoPixelAdaptive",
 *                     ),
 *                     fade_in=azure.media.TransformOutputCustomPresetFilterFadeInArgs(
 *                         duration="PT5S",
 *                         fade_color="0xFF0000",
 *                         start="10",
 *                     ),
 *                     fade_out=azure.media.TransformOutputCustomPresetFilterFadeOutArgs(
 *                         duration="90%%",
 *                         fade_color="#FF0C7B",
 *                         start="10%%",
 *                     ),
 *                     rotation="Auto",
 *                     overlays=[
 *                         azure.media.TransformOutputCustomPresetFilterOverlayArgs(
 *                             audio=azure.media.TransformOutputCustomPresetFilterOverlayAudioArgs(
 *                                 input_label="label.jpg",
 *                                 start="PT5S",
 *                                 end="PT30S",
 *                                 fade_in_duration="PT1S",
 *                                 fade_out_duration="PT2S",
 *                                 audio_gain_level=1,
 *                             ),
 *                         ),
 *                         azure.media.TransformOutputCustomPresetFilterOverlayArgs(
 *                             video=azure.media.TransformOutputCustomPresetFilterOverlayVideoArgs(
 *                                 input_label="label.jpg",
 *                                 start="PT5S",
 *                                 end="PT30S",
 *                                 fade_in_duration="PT1S",
 *                                 fade_out_duration="PT2S",
 *                                 audio_gain_level=1,
 *                                 opacity=1,
 *                                 position=azure.media.TransformOutputCustomPresetFilterOverlayVideoPositionArgs(
 *                                     height="180",
 *                                     left="20",
 *                                     top="240",
 *                                     width="140",
 *                                 ),
 *                                 crop_rectangle=azure.media.TransformOutputCustomPresetFilterOverlayVideoCropRectangleArgs(
 *                                     height="240",
 *                                     left="30",
 *                                     top="360",
 *                                     width="70",
 *                                 ),
 *                             ),
 *                         ),
 *                     ],
 *                 ),
 *             ),
 *         ),
 *     ])
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Azure = Pulumi.Azure;
 * return await Deployment.RunAsync(() =>
 * {
 *     var example = new Azure.Core.ResourceGroup("example", new()
 *     {
 *         Name = "media-resources",
 *         Location = "West Europe",
 *     });
 *     var exampleAccount = new Azure.Storage.Account("example", new()
 *     {
 *         Name = "examplestoracc",
 *         ResourceGroupName = example.Name,
 *         Location = example.Location,
 *         AccountTier = "Standard",
 *         AccountReplicationType = "GRS",
 *     });
 *     var exampleServiceAccount = new Azure.Media.ServiceAccount("example", new()
 *     {
 *         Name = "examplemediaacc",
 *         Location = example.Location,
 *         ResourceGroupName = example.Name,
 *         StorageAccounts = new[]
 *         {
 *             new Azure.Media.Inputs.ServiceAccountStorageAccountArgs
 *             {
 *                 Id = exampleAccount.Id,
 *                 IsPrimary = true,
 *             },
 *         },
 *     });
 *     var exampleTransform = new Azure.Media.Transform("example", new()
 *     {
 *         Name = "transform1",
 *         ResourceGroupName = example.Name,
 *         MediaServicesAccountName = exampleServiceAccount.Name,
 *         Description = "My transform description",
 *         Outputs = new[]
 *         {
 *             new Azure.Media.Inputs.TransformOutputArgs
 *             {
 *                 RelativePriority = "Normal",
 *                 OnErrorAction = "ContinueJob",
 *                 BuiltinPreset = new Azure.Media.Inputs.TransformOutputBuiltinPresetArgs
 *                 {
 *                     PresetName = "AACGoodQualityAudio",
 *                     PresetConfiguration = new Azure.Media.Inputs.TransformOutputBuiltinPresetPresetConfigurationArgs
 *                     {
 *                         Complexity = "Balanced",
 *                         InterleaveOutput = "NonInterleavedOutput",
 *                         KeyFrameIntervalInSeconds = 123122.5,
 *                         MaxBitrateBps = 300000,
 *                         MaxHeight = 480,
 *                         MaxLayers = 14,
 *                         MinBitrateBps = 200000,
 *                         MinHeight = 360,
 *                     },
 *                 },
 *             },
 *             new Azure.Media.Inputs.TransformOutputArgs
 *             {
 *                 RelativePriority = "Low",
 *                 OnErrorAction = "ContinueJob",
 *                 AudioAnalyzerPreset = new Azure.Media.Inputs.TransformOutputAudioAnalyzerPresetArgs
 *                 {
 *                     AudioLanguage = "en-US",
 *                     AudioAnalysisMode = "Basic",
 *                     ExperimentalOptions =
 *                     {
 *                         { "env", "test" },
 *                     },
 *                 },
 *             },
 *             new Azure.Media.Inputs.TransformOutputArgs
 *             {
 *                 RelativePriority = "Low",
 *                 OnErrorAction = "StopProcessingJob",
 *                 FaceDetectorPreset = new Azure.Media.Inputs.TransformOutputFaceDetectorPresetArgs
 *                 {
 *                     AnalysisResolution = "StandardDefinition",
 *                     BlurType = "Med",
 *                     FaceRedactorMode = "Combined",
 *                     ExperimentalOptions =
 *                     {
 *                         { "env", "test" },
 *                     },
 *                 },
 *             },
 *             new Azure.Media.Inputs.TransformOutputArgs
 *             {
 *                 RelativePriority = "Normal",
 *                 OnErrorAction = "StopProcessingJob",
 *                 VideoAnalyzerPreset = new Azure.Media.Inputs.TransformOutputVideoAnalyzerPresetArgs
 *                 {
 *                     AudioLanguage = "en-US",
 *                     AudioAnalysisMode = "Basic",
 *                     InsightsType = "AllInsights",
 *                     ExperimentalOptions =
 *                     {
 *                         { "env", "test" },
 *                     },
 *                 },
 *             },
 *             new Azure.Media.Inputs.TransformOutputArgs
 *             {
 *                 RelativePriority = "Low",
 *                 OnErrorAction = "ContinueJob",
 *                 CustomPreset = new Azure.Media.Inputs.TransformOutputCustomPresetArgs
 *                 {
 *                     Codecs = new[]
 *                     {
 *                         new Azure.Media.Inputs.TransformOutputCustomPresetCodecArgs
 *                         {
 *                             AacAudio = new Azure.Media.Inputs.TransformOutputCustomPresetCodecAacAudioArgs
 *                             {
 *                                 Bitrate = 128000,
 *                                 Channels = 2,
 *                                 SamplingRate = 48000,
 *                                 Profile = "AacLc",
 *                             },
 *                         },
 *                         new Azure.Media.Inputs.TransformOutputCustomPresetCodecArgs
 *                         {
 *                             CopyAudio = new Azure.Media.Inputs.TransformOutputCustomPresetCodecCopyAudioArgs
 *                             {
 *                                 Label = "test",
 *                             },
 *                         },
 *                         new Azure.Media.Inputs.TransformOutputCustomPresetCodecArgs
 *                         {
 *                             CopyVideo = new Azure.Media.Inputs.TransformOutputCustomPresetCodecCopyVideoArgs
 *                             {
 *                                 Label = "test",
 *                             },
 *                         },
 *                         new Azure.Media.Inputs.TransformOutputCustomPresetCodecArgs
 *                         {
 *                             H264Video = new Azure.Media.Inputs.TransformOutputCustomPresetCodecH264VideoArgs
 *                             {
 *                                 KeyFrameInterval = "PT1S",
 *                                 StretchMode = "AutoSize",
 *                                 SyncMode = "Auto",
 *                                 SceneChangeDetectionEnabled = false,
 *                                 RateControlMode = "ABR",
 *                                 Complexity = "Quality",
 *                                 Layers = new[]
 *                                 {
 *                                     new Azure.Media.Inputs.TransformOutputCustomPresetCodecH264VideoLayerArgs
 *                                     {
 *                                         Width = "64",
 *                                         Height = "64",
 *                                         Bitrate = 1045000,
 *                                         MaxBitrate = 1045000,
 *                                         BFrames = 3,
 *                                         Slices = 0,
 *                                         AdaptiveBFrameEnabled = true,
 *                                         Profile = "Auto",
 *                                         Level = "auto",
 *                                         BufferWindow = "PT5S",
 *                                         ReferenceFrames = 4,
 *                                         Crf = 23,
 *                                         EntropyMode = "Cabac",
 *                                     },
 *                                     new Azure.Media.Inputs.TransformOutputCustomPresetCodecH264VideoLayerArgs
 *                                     {
 *                                         Width = "64",
 *                                         Height = "64",
 *                                         Bitrate = 1000,
 *                                         MaxBitrate = 1000,
 *                                         BFrames = 3,
 *                                         FrameRate = "32",
 *                                         Slices = 1,
 *                                         AdaptiveBFrameEnabled = true,
 *                                         Profile = "High444",
 *                                         Level = "auto",
 *                                         BufferWindow = "PT5S",
 *                                         ReferenceFrames = 4,
 *                                         Crf = 23,
 *                                         EntropyMode = "Cavlc",
 *                                     },
 *                                 },
 *                             },
 *                         },
 *                         new Azure.Media.Inputs.TransformOutputCustomPresetCodecArgs
 *                         {
 *                             H265Video = new Azure.Media.Inputs.TransformOutputCustomPresetCodecH265VideoArgs
 *                             {
 *                                 KeyFrameInterval = "PT2S",
 *                                 StretchMode = "AutoSize",
 *                                 SyncMode = "Auto",
 *                                 SceneChangeDetectionEnabled = false,
 *                                 Complexity = "Speed",
 *                                 Layers = new[]
 *                                 {
 *                                     new Azure.Media.Inputs.TransformOutputCustomPresetCodecH265VideoLayerArgs
 *                                     {
 *                                         Width = "64",
 *                                         Height = "64",
 *                                         Bitrate = 1045000,
 *                                         MaxBitrate = 1045000,
 *                                         BFrames = 3,
 *                                         Slices = 5,
 *                                         AdaptiveBFrameEnabled = true,
 *                                         Profile = "Auto",
 *                                         Label = "test",
 *                                         Level = "auto",
 *                                         BufferWindow = "PT5S",
 *                                         FrameRate = "32",
 *                                         ReferenceFrames = 4,
 *                                         Crf = 23,
 *                                     },
 *                                 },
 *                             },
 *                         },
 *                         new Azure.Media.Inputs.TransformOutputCustomPresetCodecArgs
 *                         {
 *                             JpgImage = new Azure.Media.Inputs.TransformOutputCustomPresetCodecJpgImageArgs
 *                             {
 *                                 StretchMode = "AutoSize",
 *                                 SyncMode = "Auto",
 *                                 Start = "10",
 *                                 Range = "100%%",
 *                                 SpriteColumn = 1,
 *                                 Step = "10",
 *                                 Layers = new[]
 *                                 {
 *                                     new Azure.Media.Inputs.TransformOutputCustomPresetCodecJpgImageLayerArgs
 *                                     {
 *                                         Quality = 70,
 *                                         Height = "180",
 *                                         Label = "test",
 *                                         Width = "120",
 *                                     },
 *                                 },
 *                             },
 *                         },
 *                         new Azure.Media.Inputs.TransformOutputCustomPresetCodecArgs
 *                         {
 *                             PngImage = new Azure.Media.Inputs.TransformOutputCustomPresetCodecPngImageArgs
 *                             {
 *                                 StretchMode = "AutoSize",
 *                                 SyncMode = "Auto",
 *                                 Start = "{Best}",
 *                                 Range = "80",
 *                                 Step = "10",
 *                                 Layers = new[]
 *                                 {
 *                                     new Azure.Media.Inputs.TransformOutputCustomPresetCodecPngImageLayerArgs
 *                                     {
 *                                         Height = "180",
 *                                         Label = "test",
 *                                         Width = "120",
 *                                     },
 *                                 },
 *                             },
 *                         },
 *                     },
 *                     Formats = new[]
 *                     {
 *                         new Azure.Media.Inputs.TransformOutputCustomPresetFormatArgs
 *                         {
 *                             Jpg = new Azure.Media.Inputs.TransformOutputCustomPresetFormatJpgArgs
 *                             {
 *                                 FilenamePattern = "test{Basename}",
 *                             },
 *                         },
 *                         new Azure.Media.Inputs.TransformOutputCustomPresetFormatArgs
 *                         {
 *                             Mp4 = new Azure.Media.Inputs.TransformOutputCustomPresetFormatMp4Args
 *                             {
 *                                 FilenamePattern = "test{Bitrate}",
 *                                 OutputFiles = new[]
 *                                 {
 *                                     new Azure.Media.Inputs.TransformOutputCustomPresetFormatMp4OutputFileArgs
 *                                     {
 *                                         Labels = new[]
 *                                         {
 *                                             "test",
 *                                             "ppe",
 *                                         },
 *                                     },
 *                                 },
 *                             },
 *                         },
 *                         new Azure.Media.Inputs.TransformOutputCustomPresetFormatArgs
 *                         {
 *                             Png = new Azure.Media.Inputs.TransformOutputCustomPresetFormatPngArgs
 *                             {
 *                                 FilenamePattern = "test{Basename}",
 *                             },
 *                         },
 *                         new Azure.Media.Inputs.TransformOutputCustomPresetFormatArgs
 *                         {
 *                             TransportStream = new Azure.Media.Inputs.TransformOutputCustomPresetFormatTransportStreamArgs
 *                             {
 *                                 FilenamePattern = "test{Bitrate}",
 *                                 OutputFiles = new[]
 *                                 {
 *                                     new Azure.Media.Inputs.TransformOutputCustomPresetFormatTransportStreamOutputFileArgs
 *                                     {
 *                                         Labels = new[]
 *                                         {
 *                                             "prod",
 *                                         },
 *                                     },
 *                                 },
 *                             },
 *                         },
 *                     },
 *                     Filter = new Azure.Media.Inputs.TransformOutputCustomPresetFilterArgs
 *                     {
 *                         CropRectangle = new Azure.Media.Inputs.TransformOutputCustomPresetFilterCropRectangleArgs
 *                         {
 *                             Height = "240",
 *                             Left = "30",
 *                             Top = "360",
 *                             Width = "70",
 *                         },
 *                         Deinterlace = new Azure.Media.Inputs.TransformOutputCustomPresetFilterDeinterlaceArgs
 *                         {
 *                             Parity = "TopFieldFirst",
 *                             Mode = "AutoPixelAdaptive",
 *                         },
 *                         FadeIn = new Azure.Media.Inputs.TransformOutputCustomPresetFilterFadeInArgs
 *                         {
 *                             Duration = "PT5S",
 *                             FadeColor = "0xFF0000",
 *                             Start = "10",
 *                         },
 *                         FadeOut = new Azure.Media.Inputs.TransformOutputCustomPresetFilterFadeOutArgs
 *                         {
 *                             Duration = "90%%",
 *                             FadeColor = "#FF0C7B",
 *                             Start = "10%%",
 *                         },
 *                         Rotation = "Auto",
 *                         Overlays = new[]
 *                         {
 *                             new Azure.Media.Inputs.TransformOutputCustomPresetFilterOverlayArgs
 *                             {
 *                                 Audio = new Azure.Media.Inputs.TransformOutputCustomPresetFilterOverlayAudioArgs
 *                                 {
 *                                     InputLabel = "label.jpg",
 *                                     Start = "PT5S",
 *                                     End = "PT30S",
 *                                     FadeInDuration = "PT1S",
 *                                     FadeOutDuration = "PT2S",
 *                                     AudioGainLevel = 1,
 *                                 },
 *                             },
 *                             new Azure.Media.Inputs.TransformOutputCustomPresetFilterOverlayArgs
 *                             {
 *                                 Video = new Azure.Media.Inputs.TransformOutputCustomPresetFilterOverlayVideoArgs
 *                                 {
 *                                     InputLabel = "label.jpg",
 *                                     Start = "PT5S",
 *                                     End = "PT30S",
 *                                     FadeInDuration = "PT1S",
 *                                     FadeOutDuration = "PT2S",
 *                                     AudioGainLevel = 1,
 *                                     Opacity = 1,
 *                                     Position = new Azure.Media.Inputs.TransformOutputCustomPresetFilterOverlayVideoPositionArgs
 *                                     {
 *                                         Height = "180",
 *                                         Left = "20",
 *                                         Top = "240",
 *                                         Width = "140",
 *                                     },
 *                                     CropRectangle = new Azure.Media.Inputs.TransformOutputCustomPresetFilterOverlayVideoCropRectangleArgs
 *                                     {
 *                                         Height = "240",
 *                                         Left = "30",
 *                                         Top = "360",
 *                                         Width = "70",
 *                                     },
 *                                 },
 *                             },
 *                         },
 *                     },
 *                 },
 *             },
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
 * 	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/media"
 * 	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/storage"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
 * 			Name:     pulumi.String("media-resources"),
 * 			Location: pulumi.String("West Europe"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		exampleAccount, err := storage.NewAccount(ctx, "example", &storage.AccountArgs{
 * 			Name:                   pulumi.String("examplestoracc"),
 * 			ResourceGroupName:      example.Name,
 * 			Location:               example.Location,
 * 			AccountTier:            pulumi.String("Standard"),
 * 			AccountReplicationType: pulumi.String("GRS"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		exampleServiceAccount, err := media.NewServiceAccount(ctx, "example", &media.ServiceAccountArgs{
 * 			Name:              pulumi.String("examplemediaacc"),
 * 			Location:          example.Location,
 * 			ResourceGroupName: example.Name,
 * 			StorageAccounts: media.ServiceAccountStorageAccountArray{
 * 				&media.ServiceAccountStorageAccountArgs{
 * 					Id:        exampleAccount.ID(),
 * 					IsPrimary: pulumi.Bool(true),
 * 				},
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = media.NewTransform(ctx, "example", &media.TransformArgs{
 * 			Name:                     pulumi.String("transform1"),
 * 			ResourceGroupName:        example.Name,
 * 			MediaServicesAccountName: exampleServiceAccount.Name,
 * 			Description:              pulumi.String("My transform description"),
 * 			Outputs: media.TransformOutputTypeArray{
 * 				&media.TransformOutputTypeArgs{
 * 					RelativePriority: pulumi.String("Normal"),
 * 					OnErrorAction:    pulumi.String("ContinueJob"),
 * 					BuiltinPreset: &media.TransformOutputBuiltinPresetArgs{
 * 						PresetName: pulumi.String("AACGoodQualityAudio"),
 * 						PresetConfiguration: &media.TransformOutputBuiltinPresetPresetConfigurationArgs{
 * 							Complexity:                pulumi.String("Balanced"),
 * 							InterleaveOutput:          pulumi.String("NonInterleavedOutput"),
 * 							KeyFrameIntervalInSeconds: pulumi.Float64(123122.5),
 * 							MaxBitrateBps:             pulumi.Int(300000),
 * 							MaxHeight:                 pulumi.Int(480),
 * 							MaxLayers:                 pulumi.Int(14),
 * 							MinBitrateBps:             pulumi.Int(200000),
 * 							MinHeight:                 pulumi.Int(360),
 * 						},
 * 					},
 * 				},
 * 				&media.TransformOutputTypeArgs{
 * 					RelativePriority: pulumi.String("Low"),
 * 					OnErrorAction:    pulumi.String("ContinueJob"),
 * 					AudioAnalyzerPreset: &media.TransformOutputAudioAnalyzerPresetArgs{
 * 						AudioLanguage:     pulumi.String("en-US"),
 * 						AudioAnalysisMode: pulumi.String("Basic"),
 * 						ExperimentalOptions: pulumi.StringMap{
 * 							"env": pulumi.String("test"),
 * 						},
 * 					},
 * 				},
 * 				&media.TransformOutputTypeArgs{
 * 					RelativePriority: pulumi.String("Low"),
 * 					OnErrorAction:    pulumi.String("StopProcessingJob"),
 * 					FaceDetectorPreset: &media.TransformOutputFaceDetectorPresetArgs{
 * 						AnalysisResolution: pulumi.String("StandardDefinition"),
 * 						BlurType:           pulumi.String("Med"),
 * 						FaceRedactorMode:   pulumi.String("Combined"),
 * 						ExperimentalOptions: pulumi.StringMap{
 * 							"env": pulumi.String("test"),
 * 						},
 * 					},
 * 				},
 * 				&media.TransformOutputTypeArgs{
 * 					RelativePriority: pulumi.String("Normal"),
 * 					OnErrorAction:    pulumi.String("StopProcessingJob"),
 * 					VideoAnalyzerPreset: &media.TransformOutputVideoAnalyzerPresetArgs{
 * 						AudioLanguage:     pulumi.String("en-US"),
 * 						AudioAnalysisMode: pulumi.String("Basic"),
 * 						InsightsType:      pulumi.String("AllInsights"),
 * 						ExperimentalOptions: pulumi.StringMap{
 * 							"env": pulumi.String("test"),
 * 						},
 * 					},
 * 				},
 * 				&media.TransformOutputTypeArgs{
 * 					RelativePriority: pulumi.String("Low"),
 * 					OnErrorAction:    pulumi.String("ContinueJob"),
 * 					CustomPreset: &media.TransformOutputCustomPresetArgs{
 * 						Codecs: media.TransformOutputCustomPresetCodecArray{
 * 							&media.TransformOutputCustomPresetCodecArgs{
 * 								AacAudio: &media.TransformOutputCustomPresetCodecAacAudioArgs{
 * 									Bitrate:      pulumi.Int(128000),
 * 									Channels:     pulumi.Int(2),
 * 									SamplingRate: pulumi.Int(48000),
 * 									Profile:      pulumi.String("AacLc"),
 * 								},
 * 							},
 * 							&media.TransformOutputCustomPresetCodecArgs{
 * 								CopyAudio: &media.TransformOutputCustomPresetCodecCopyAudioArgs{
 * 									Label: pulumi.String("test"),
 * 								},
 * 							},
 * 							&media.TransformOutputCustomPresetCodecArgs{
 * 								CopyVideo: &media.TransformOutputCustomPresetCodecCopyVideoArgs{
 * 									Label: pulumi.String("test"),
 * 								},
 * 							},
 * 							&media.TransformOutputCustomPresetCodecArgs{
 * 								H264Video: &media.TransformOutputCustomPresetCodecH264VideoArgs{
 * 									KeyFrameInterval:            pulumi.String("PT1S"),
 * 									StretchMode:                 pulumi.String("AutoSize"),
 * 									SyncMode:                    pulumi.String("Auto"),
 * 									SceneChangeDetectionEnabled: pulumi.Bool(false),
 * 									RateControlMode:             pulumi.String("ABR"),
 * 									Complexity:                  pulumi.String("Quality"),
 * 									Layers: media.TransformOutputCustomPresetCodecH264VideoLayerArray{
 * 										&media.TransformOutputCustomPresetCodecH264VideoLayerArgs{
 * 											Width:                 pulumi.String("64"),
 * 											Height:                pulumi.String("64"),
 * 											Bitrate:               pulumi.Int(1045000),
 * 											MaxBitrate:            pulumi.Int(1045000),
 * 											BFrames:               pulumi.Int(3),
 * 											Slices:                pulumi.Int(0),
 * 											AdaptiveBFrameEnabled: pulumi.Bool(true),
 * 											Profile:               pulumi.String("Auto"),
 * 											Level:                 pulumi.String("auto"),
 * 											BufferWindow:          pulumi.String("PT5S"),
 * 											ReferenceFrames:       pulumi.Int(4),
 * 											Crf:                   pulumi.Float64(23),
 * 											EntropyMode:           pulumi.String("Cabac"),
 * 										},
 * 										&media.TransformOutputCustomPresetCodecH264VideoLayerArgs{
 * 											Width:                 pulumi.String("64"),
 * 											Height:                pulumi.String("64"),
 * 											Bitrate:               pulumi.Int(1000),
 * 											MaxBitrate:            pulumi.Int(1000),
 * 											BFrames:               pulumi.Int(3),
 * 											FrameRate:             pulumi.String("32"),
 * 											Slices:                pulumi.Int(1),
 * 											AdaptiveBFrameEnabled: pulumi.Bool(true),
 * 											Profile:               pulumi.String("High444"),
 * 											Level:                 pulumi.String("auto"),
 * 											BufferWindow:          pulumi.String("PT5S"),
 * 											ReferenceFrames:       pulumi.Int(4),
 * 											Crf:                   pulumi.Float64(23),
 * 											EntropyMode:           pulumi.String("Cavlc"),
 * 										},
 * 									},
 * 								},
 * 							},
 * 							&media.TransformOutputCustomPresetCodecArgs{
 * 								H265Video: &media.TransformOutputCustomPresetCodecH265VideoArgs{
 * 									KeyFrameInterval:            pulumi.String("PT2S"),
 * 									StretchMode:                 pulumi.String("AutoSize"),
 * 									SyncMode:                    pulumi.String("Auto"),
 * 									SceneChangeDetectionEnabled: pulumi.Bool(false),
 * 									Complexity:                  pulumi.String("Speed"),
 * 									Layers: media.TransformOutputCustomPresetCodecH265VideoLayerArray{
 * 										&media.TransformOutputCustomPresetCodecH265VideoLayerArgs{
 * 											Width:                 pulumi.String("64"),
 * 											Height:                pulumi.String("64"),
 * 											Bitrate:               pulumi.Int(1045000),
 * 											MaxBitrate:            pulumi.Int(1045000),
 * 											BFrames:               pulumi.Int(3),
 * 											Slices:                pulumi.Int(5),
 * 											AdaptiveBFrameEnabled: pulumi.Bool(true),
 * 											Profile:               pulumi.String("Auto"),
 * 											Label:                 pulumi.String("test"),
 * 											Level:                 pulumi.String("auto"),
 * 											BufferWindow:          pulumi.String("PT5S"),
 * 											FrameRate:             pulumi.String("32"),
 * 											ReferenceFrames:       pulumi.Int(4),
 * 											Crf:                   pulumi.Float64(23),
 * 										},
 * 									},
 * 								},
 * 							},
 * 							&media.TransformOutputCustomPresetCodecArgs{
 * 								JpgImage: &media.TransformOutputCustomPresetCodecJpgImageArgs{
 * 									StretchMode:  pulumi.String("AutoSize"),
 * 									SyncMode:     pulumi.String("Auto"),
 * 									Start:        pulumi.String("10"),
 * 									Range:        pulumi.String("100%%"),
 * 									SpriteColumn: pulumi.Int(1),
 * 									Step:         pulumi.String("10"),
 * 									Layers: media.TransformOutputCustomPresetCodecJpgImageLayerArray{
 * 										&media.TransformOutputCustomPresetCodecJpgImageLayerArgs{
 * 											Quality: pulumi.Int(70),
 * 											Height:  pulumi.String("180"),
 * 											Label:   pulumi.String("test"),
 * 											Width:   pulumi.String("120"),
 * 										},
 * 									},
 * 								},
 * 							},
 * 							&media.TransformOutputCustomPresetCodecArgs{
 * 								PngImage: &media.TransformOutputCustomPresetCodecPngImageArgs{
 * 									StretchMode: pulumi.String("AutoSize"),
 * 									SyncMode:    pulumi.String("Auto"),
 * 									Start:       pulumi.String("{Best}"),
 * 									Range:       pulumi.String("80"),
 * 									Step:        pulumi.String("10"),
 * 									Layers: media.TransformOutputCustomPresetCodecPngImageLayerArray{
 * 										&media.TransformOutputCustomPresetCodecPngImageLayerArgs{
 * 											Height: pulumi.String("180"),
 * 											Label:  pulumi.String("test"),
 * 											Width:  pulumi.String("120"),
 * 										},
 * 									},
 * 								},
 * 							},
 * 						},
 * 						Formats: media.TransformOutputCustomPresetFormatArray{
 * 							&media.TransformOutputCustomPresetFormatArgs{
 * 								Jpg: &media.TransformOutputCustomPresetFormatJpgArgs{
 * 									FilenamePattern: pulumi.String("test{Basename}"),
 * 								},
 * 							},
 * 							&media.TransformOutputCustomPresetFormatArgs{
 * 								Mp4: &media.TransformOutputCustomPresetFormatMp4Args{
 * 									FilenamePattern: pulumi.String("test{Bitrate}"),
 * 									OutputFiles: media.TransformOutputCustomPresetFormatMp4OutputFileArray{
 * 										&media.TransformOutputCustomPresetFormatMp4OutputFileArgs{
 * 											Labels: pulumi.StringArray{
 * 												pulumi.String("test"),
 * 												pulumi.String("ppe"),
 * 											},
 * 										},
 * 									},
 * 								},
 * 							},
 * 							&media.TransformOutputCustomPresetFormatArgs{
 * 								Png: &media.TransformOutputCustomPresetFormatPngArgs{
 * 									FilenamePattern: pulumi.String("test{Basename}"),
 * 								},
 * 							},
 * 							&media.TransformOutputCustomPresetFormatArgs{
 * 								TransportStream: &media.TransformOutputCustomPresetFormatTransportStreamArgs{
 * 									FilenamePattern: pulumi.String("test{Bitrate}"),
 * 									OutputFiles: media.TransformOutputCustomPresetFormatTransportStreamOutputFileArray{
 * 										&media.TransformOutputCustomPresetFormatTransportStreamOutputFileArgs{
 * 											Labels: pulumi.StringArray{
 * 												pulumi.String("prod"),
 * 											},
 * 										},
 * 									},
 * 								},
 * 							},
 * 						},
 * 						Filter: &media.TransformOutputCustomPresetFilterArgs{
 * 							CropRectangle: &media.TransformOutputCustomPresetFilterCropRectangleArgs{
 * 								Height: pulumi.String("240"),
 * 								Left:   pulumi.String("30"),
 * 								Top:    pulumi.String("360"),
 * 								Width:  pulumi.String("70"),
 * 							},
 * 							Deinterlace: &media.TransformOutputCustomPresetFilterDeinterlaceArgs{
 * 								Parity: pulumi.String("TopFieldFirst"),
 * 								Mode:   pulumi.String("AutoPixelAdaptive"),
 * 							},
 * 							FadeIn: &media.TransformOutputCustomPresetFilterFadeInArgs{
 * 								Duration:  pulumi.String("PT5S"),
 * 								FadeColor: pulumi.String("0xFF0000"),
 * 								Start:     pulumi.String("10"),
 * 							},
 * 							FadeOut: &media.TransformOutputCustomPresetFilterFadeOutArgs{
 * 								Duration:  pulumi.String("90%%"),
 * 								FadeColor: pulumi.String("#FF0C7B"),
 * 								Start:     pulumi.String("10%%"),
 * 							},
 * 							Rotation: pulumi.String("Auto"),
 * 							Overlays: media.TransformOutputCustomPresetFilterOverlayArray{
 * 								&media.TransformOutputCustomPresetFilterOverlayArgs{
 * 									Audio: &media.TransformOutputCustomPresetFilterOverlayAudioArgs{
 * 										InputLabel:      pulumi.String("label.jpg"),
 * 										Start:           pulumi.String("PT5S"),
 * 										End:             pulumi.String("PT30S"),
 * 										FadeInDuration:  pulumi.String("PT1S"),
 * 										FadeOutDuration: pulumi.String("PT2S"),
 * 										AudioGainLevel:  pulumi.Float64(1),
 * 									},
 * 								},
 * 								&media.TransformOutputCustomPresetFilterOverlayArgs{
 * 									Video: &media.TransformOutputCustomPresetFilterOverlayVideoArgs{
 * 										InputLabel:      pulumi.String("label.jpg"),
 * 										Start:           pulumi.String("PT5S"),
 * 										End:             pulumi.String("PT30S"),
 * 										FadeInDuration:  pulumi.String("PT1S"),
 * 										FadeOutDuration: pulumi.String("PT2S"),
 * 										AudioGainLevel:  pulumi.Float64(1),
 * 										Opacity:         pulumi.Float64(1),
 * 										Position: &media.TransformOutputCustomPresetFilterOverlayVideoPositionArgs{
 * 											Height: pulumi.String("180"),
 * 											Left:   pulumi.String("20"),
 * 											Top:    pulumi.String("240"),
 * 											Width:  pulumi.String("140"),
 * 										},
 * 										CropRectangle: &media.TransformOutputCustomPresetFilterOverlayVideoCropRectangleArgs{
 * 											Height: pulumi.String("240"),
 * 											Left:   pulumi.String("30"),
 * 											Top:    pulumi.String("360"),
 * 											Width:  pulumi.String("70"),
 * 										},
 * 									},
 * 								},
 * 							},
 * 						},
 * 					},
 * 				},
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.azure.core.ResourceGroup;
 * import com.pulumi.azure.core.ResourceGroupArgs;
 * import com.pulumi.azure.storage.Account;
 * import com.pulumi.azure.storage.AccountArgs;
 * import com.pulumi.azure.media.ServiceAccount;
 * import com.pulumi.azure.media.ServiceAccountArgs;
 * import com.pulumi.azure.media.inputs.ServiceAccountStorageAccountArgs;
 * import com.pulumi.azure.media.Transform;
 * import com.pulumi.azure.media.TransformArgs;
 * import com.pulumi.azure.media.inputs.TransformOutputArgs;
 * import com.pulumi.azure.media.inputs.TransformOutputBuiltinPresetArgs;
 * import com.pulumi.azure.media.inputs.TransformOutputBuiltinPresetPresetConfigurationArgs;
 * import com.pulumi.azure.media.inputs.TransformOutputAudioAnalyzerPresetArgs;
 * import com.pulumi.azure.media.inputs.TransformOutputFaceDetectorPresetArgs;
 * import com.pulumi.azure.media.inputs.TransformOutputVideoAnalyzerPresetArgs;
 * import com.pulumi.azure.media.inputs.TransformOutputCustomPresetArgs;
 * import com.pulumi.azure.media.inputs.TransformOutputCustomPresetFilterArgs;
 * import com.pulumi.azure.media.inputs.TransformOutputCustomPresetFilterCropRectangleArgs;
 * import com.pulumi.azure.media.inputs.TransformOutputCustomPresetFilterDeinterlaceArgs;
 * import com.pulumi.azure.media.inputs.TransformOutputCustomPresetFilterFadeInArgs;
 * import com.pulumi.azure.media.inputs.TransformOutputCustomPresetFilterFadeOutArgs;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         var example = new ResourceGroup("example", ResourceGroupArgs.builder()
 *             .name("media-resources")
 *             .location("West Europe")
 *             .build());
 *         var exampleAccount = new Account("exampleAccount", AccountArgs.builder()
 *             .name("examplestoracc")
 *             .resourceGroupName(example.name())
 *             .location(example.location())
 *             .accountTier("Standard")
 *             .accountReplicationType("GRS")
 *             .build());
 *         var exampleServiceAccount = new ServiceAccount("exampleServiceAccount", ServiceAccountArgs.builder()
 *             .name("examplemediaacc")
 *             .location(example.location())
 *             .resourceGroupName(example.name())
 *             .storageAccounts(ServiceAccountStorageAccountArgs.builder()
 *                 .id(exampleAccount.id())
 *                 .isPrimary(true)
 *                 .build())
 *             .build());
 *         var exampleTransform = new Transform("exampleTransform", TransformArgs.builder()
 *             .name("transform1")
 *             .resourceGroupName(example.name())
 *             .mediaServicesAccountName(exampleServiceAccount.name())
 *             .description("My transform description")
 *             .outputs(
 *                 TransformOutputArgs.builder()
 *                     .relativePriority("Normal")
 *                     .onErrorAction("ContinueJob")
 *                     .builtinPreset(TransformOutputBuiltinPresetArgs.builder()
 *                         .presetName("AACGoodQualityAudio")
 *                         .presetConfiguration(TransformOutputBuiltinPresetPresetConfigurationArgs.builder()
 *                             .complexity("Balanced")
 *                             .interleaveOutput("NonInterleavedOutput")
 *                             .keyFrameIntervalInSeconds(123122.5)
 *                             .maxBitrateBps(300000)
 *                             .maxHeight(480)
 *                             .maxLayers(14)
 *                             .minBitrateBps(200000)
 *                             .minHeight(360)
 *                             .build())
 *                         .build())
 *                     .build(),
 *                 TransformOutputArgs.builder()
 *                     .relativePriority("Low")
 *                     .onErrorAction("ContinueJob")
 *                     .audioAnalyzerPreset(TransformOutputAudioAnalyzerPresetArgs.builder()
 *                         .audioLanguage("en-US")
 *                         .audioAnalysisMode("Basic")
 *                         .experimentalOptions(Map.of("env", "test"))
 *                         .build())
 *                     .build(),
 *                 TransformOutputArgs.builder()
 *                     .relativePriority("Low")
 *                     .onErrorAction("StopProcessingJob")
 *                     .faceDetectorPreset(TransformOutputFaceDetectorPresetArgs.builder()
 *                         .analysisResolution("StandardDefinition")
 *                         .blurType("Med")
 *                         .faceRedactorMode("Combined")
 *                         .experimentalOptions(Map.of("env", "test"))
 *                         .build())
 *                     .build(),
 *                 TransformOutputArgs.builder()
 *                     .relativePriority("Normal")
 *                     .onErrorAction("StopProcessingJob")
 *                     .videoAnalyzerPreset(TransformOutputVideoAnalyzerPresetArgs.builder()
 *                         .audioLanguage("en-US")
 *                         .audioAnalysisMode("Basic")
 *                         .insightsType("AllInsights")
 *                         .experimentalOptions(Map.of("env", "test"))
 *                         .build())
 *                     .build(),
 *                 TransformOutputArgs.builder()
 *                     .relativePriority("Low")
 *                     .onErrorAction("ContinueJob")
 *                     .customPreset(TransformOutputCustomPresetArgs.builder()
 *                         .codecs(
 *                             TransformOutputCustomPresetCodecArgs.builder()
 *                                 .aacAudio(TransformOutputCustomPresetCodecAacAudioArgs.builder()
 *                                     .bitrate(128000)
 *                                     .channels(2)
 *                                     .samplingRate(48000)
 *                                     .profile("AacLc")
 *                                     .build())
 *                                 .build(),
 *                             TransformOutputCustomPresetCodecArgs.builder()
 *                                 .copyAudio(TransformOutputCustomPresetCodecCopyAudioArgs.builder()
 *                                     .label("test")
 *                                     .build())
 *                                 .build(),
 *                             TransformOutputCustomPresetCodecArgs.builder()
 *                                 .copyVideo(TransformOutputCustomPresetCodecCopyVideoArgs.builder()
 *                                     .label("test")
 *                                     .build())
 *                                 .build(),
 *                             TransformOutputCustomPresetCodecArgs.builder()
 *                                 .h264Video(TransformOutputCustomPresetCodecH264VideoArgs.builder()
 *                                     .keyFrameInterval("PT1S")
 *                                     .stretchMode("AutoSize")
 *                                     .syncMode("Auto")
 *                                     .sceneChangeDetectionEnabled(false)
 *                                     .rateControlMode("ABR")
 *                                     .complexity("Quality")
 *                                     .layers(
 *                                         TransformOutputCustomPresetCodecH264VideoLayerArgs.builder()
 *                                             .width("64")
 *                                             .height("64")
 *                                             .bitrate(1045000)
 *                                             .maxBitrate(1045000)
 *                                             .bFrames(3)
 *                                             .slices(0)
 *                                             .adaptiveBFrameEnabled(true)
 *                                             .profile("Auto")
 *                                             .level("auto")
 *                                             .bufferWindow("PT5S")
 *                                             .referenceFrames(4)
 *                                             .crf(23)
 *                                             .entropyMode("Cabac")
 *                                             .build(),
 *                                         TransformOutputCustomPresetCodecH264VideoLayerArgs.builder()
 *                                             .width("64")
 *                                             .height("64")
 *                                             .bitrate(1000)
 *                                             .maxBitrate(1000)
 *                                             .bFrames(3)
 *                                             .frameRate("32")
 *                                             .slices(1)
 *                                             .adaptiveBFrameEnabled(true)
 *                                             .profile("High444")
 *                                             .level("auto")
 *                                             .bufferWindow("PT5S")
 *                                             .referenceFrames(4)
 *                                             .crf(23)
 *                                             .entropyMode("Cavlc")
 *                                             .build())
 *                                     .build())
 *                                 .build(),
 *                             TransformOutputCustomPresetCodecArgs.builder()
 *                                 .h265Video(TransformOutputCustomPresetCodecH265VideoArgs.builder()
 *                                     .keyFrameInterval("PT2S")
 *                                     .stretchMode("AutoSize")
 *                                     .syncMode("Auto")
 *                                     .sceneChangeDetectionEnabled(false)
 *                                     .complexity("Speed")
 *                                     .layers(TransformOutputCustomPresetCodecH265VideoLayerArgs.builder()
 *                                         .width("64")
 *                                         .height("64")
 *                                         .bitrate(1045000)
 *                                         .maxBitrate(1045000)
 *                                         .bFrames(3)
 *                                         .slices(5)
 *                                         .adaptiveBFrameEnabled(true)
 *                                         .profile("Auto")
 *                                         .label("test")
 *                                         .level("auto")
 *                                         .bufferWindow("PT5S")
 *                                         .frameRate("32")
 *                                         .referenceFrames(4)
 *                                         .crf(23)
 *                                         .build())
 *                                     .build())
 *                                 .build(),
 *                             TransformOutputCustomPresetCodecArgs.builder()
 *                                 .jpgImage(TransformOutputCustomPresetCodecJpgImageArgs.builder()
 *                                     .stretchMode("AutoSize")
 *                                     .syncMode("Auto")
 *                                     .start("10")
 *                                     .range("100%%")
 *                                     .spriteColumn(1)
 *                                     .step("10")
 *                                     .layers(TransformOutputCustomPresetCodecJpgImageLayerArgs.builder()
 *                                         .quality(70)
 *                                         .height("180")
 *                                         .label("test")
 *                                         .width("120")
 *                                         .build())
 *                                     .build())
 *                                 .build(),
 *                             TransformOutputCustomPresetCodecArgs.builder()
 *                                 .pngImage(TransformOutputCustomPresetCodecPngImageArgs.builder()
 *                                     .stretchMode("AutoSize")
 *                                     .syncMode("Auto")
 *                                     .start("{Best}")
 *                                     .range("80")
 *                                     .step("10")
 *                                     .layers(TransformOutputCustomPresetCodecPngImageLayerArgs.builder()
 *                                         .height("180")
 *                                         .label("test")
 *                                         .width("120")
 *                                         .build())
 *                                     .build())
 *                                 .build())
 *                         .formats(
 *                             TransformOutputCustomPresetFormatArgs.builder()
 *                                 .jpg(TransformOutputCustomPresetFormatJpgArgs.builder()
 *                                     .filenamePattern("test{Basename}")
 *                                     .build())
 *                                 .build(),
 *                             TransformOutputCustomPresetFormatArgs.builder()
 *                                 .mp4(TransformOutputCustomPresetFormatMp4Args.builder()
 *                                     .filenamePattern("test{Bitrate}")
 *                                     .outputFiles(TransformOutputCustomPresetFormatMp4OutputFileArgs.builder()
 *                                         .labels(
 *                                             "test",
 *                                             "ppe")
 *                                         .build())
 *                                     .build())
 *                                 .build(),
 *                             TransformOutputCustomPresetFormatArgs.builder()
 *                                 .png(TransformOutputCustomPresetFormatPngArgs.builder()
 *                                     .filenamePattern("test{Basename}")
 *                                     .build())
 *                                 .build(),
 *                             TransformOutputCustomPresetFormatArgs.builder()
 *                                 .transportStream(TransformOutputCustomPresetFormatTransportStreamArgs.builder()
 *                                     .filenamePattern("test{Bitrate}")
 *                                     .outputFiles(TransformOutputCustomPresetFormatTransportStreamOutputFileArgs.builder()
 *                                         .labels("prod")
 *                                         .build())
 *                                     .build())
 *                                 .build())
 *                         .filter(TransformOutputCustomPresetFilterArgs.builder()
 *                             .cropRectangle(TransformOutputCustomPresetFilterCropRectangleArgs.builder()
 *                                 .height("240")
 *                                 .left("30")
 *                                 .top("360")
 *                                 .width("70")
 *                                 .build())
 *                             .deinterlace(TransformOutputCustomPresetFilterDeinterlaceArgs.builder()
 *                                 .parity("TopFieldFirst")
 *                                 .mode("AutoPixelAdaptive")
 *                                 .build())
 *                             .fadeIn(TransformOutputCustomPresetFilterFadeInArgs.builder()
 *                                 .duration("PT5S")
 *                                 .fadeColor("0xFF0000")
 *                                 .start("10")
 *                                 .build())
 *                             .fadeOut(TransformOutputCustomPresetFilterFadeOutArgs.builder()
 *                                 .duration("90%%")
 *                                 .fadeColor("#FF0C7B")
 *                                 .start("10%%")
 *                                 .build())
 *                             .rotation("Auto")
 *                             .overlays(
 *                                 TransformOutputCustomPresetFilterOverlayArgs.builder()
 *                                     .audio(TransformOutputCustomPresetFilterOverlayAudioArgs.builder()
 *                                         .inputLabel("label.jpg")
 *                                         .start("PT5S")
 *                                         .end("PT30S")
 *                                         .fadeInDuration("PT1S")
 *                                         .fadeOutDuration("PT2S")
 *                                         .audioGainLevel(1)
 *                                         .build())
 *                                     .build(),
 *                                 TransformOutputCustomPresetFilterOverlayArgs.builder()
 *                                     .video(TransformOutputCustomPresetFilterOverlayVideoArgs.builder()
 *                                         .inputLabel("label.jpg")
 *                                         .start("PT5S")
 *                                         .end("PT30S")
 *                                         .fadeInDuration("PT1S")
 *                                         .fadeOutDuration("PT2S")
 *                                         .audioGainLevel(1)
 *                                         .opacity(1)
 *                                         .position(TransformOutputCustomPresetFilterOverlayVideoPositionArgs.builder()
 *                                             .height("180")
 *                                             .left("20")
 *                                             .top("240")
 *                                             .width("140")
 *                                             .build())
 *                                         .cropRectangle(TransformOutputCustomPresetFilterOverlayVideoCropRectangleArgs.builder()
 *                                             .height("240")
 *                                             .left("30")
 *                                             .top("360")
 *                                             .width("70")
 *                                             .build())
 *                                         .build())
 *                                     .build())
 *                             .build())
 *                         .build())
 *                     .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   example:
 *     type: azure:core:ResourceGroup
 *     properties:
 *       name: media-resources
 *       location: West Europe
 *   exampleAccount:
 *     type: azure:storage:Account
 *     name: example
 *     properties:
 *       name: examplestoracc
 *       resourceGroupName: ${example.name}
 *       location: ${example.location}
 *       accountTier: Standard
 *       accountReplicationType: GRS
 *   exampleServiceAccount:
 *     type: azure:media:ServiceAccount
 *     name: example
 *     properties:
 *       name: examplemediaacc
 *       location: ${example.location}
 *       resourceGroupName: ${example.name}
 *       storageAccounts:
 *         - id: ${exampleAccount.id}
 *           isPrimary: true
 *   exampleTransform:
 *     type: azure:media:Transform
 *     name: example
 *     properties:
 *       name: transform1
 *       resourceGroupName: ${example.name}
 *       mediaServicesAccountName: ${exampleServiceAccount.name}
 *       description: My transform description
 *       outputs:
 *         - relativePriority: Normal
 *           onErrorAction: ContinueJob
 *           builtinPreset:
 *             presetName: AACGoodQualityAudio
 *             presetConfiguration:
 *               complexity: Balanced
 *               interleaveOutput: NonInterleavedOutput
 *               keyFrameIntervalInSeconds: 123122.5
 *               maxBitrateBps: 300000
 *               maxHeight: 480
 *               maxLayers: 14
 *               minBitrateBps: 200000
 *               minHeight: 360
 *         - relativePriority: Low
 *           onErrorAction: ContinueJob
 *           audioAnalyzerPreset:
 *             audioLanguage: en-US
 *             audioAnalysisMode: Basic
 *             experimentalOptions:
 *               env: test
 *         - relativePriority: Low
 *           onErrorAction: StopProcessingJob
 *           faceDetectorPreset:
 *             analysisResolution: StandardDefinition
 *             blurType: Med
 *             faceRedactorMode: Combined
 *             experimentalOptions:
 *               env: test
 *         - relativePriority: Normal
 *           onErrorAction: StopProcessingJob
 *           videoAnalyzerPreset:
 *             audioLanguage: en-US
 *             audioAnalysisMode: Basic
 *             insightsType: AllInsights
 *             experimentalOptions:
 *               env: test
 *         - relativePriority: Low
 *           onErrorAction: ContinueJob
 *           customPreset:
 *             codecs:
 *               - aacAudio:
 *                   bitrate: 128000
 *                   channels: 2
 *                   samplingRate: 48000
 *                   profile: AacLc
 *               - copyAudio:
 *                   label: test
 *               - copyVideo:
 *                   label: test
 *               - h264Video:
 *                   keyFrameInterval: PT1S
 *                   stretchMode: AutoSize
 *                   syncMode: Auto
 *                   sceneChangeDetectionEnabled: false
 *                   rateControlMode: ABR
 *                   complexity: Quality
 *                   layers:
 *                     - width: '64'
 *                       height: '64'
 *                       bitrate: 1.045e+06
 *                       maxBitrate: 1.045e+06
 *                       bFrames: 3
 *                       slices: 0
 *                       adaptiveBFrameEnabled: true
 *                       profile: Auto
 *                       level: auto
 *                       bufferWindow: PT5S
 *                       referenceFrames: 4
 *                       crf: 23
 *                       entropyMode: Cabac
 *                     - width: '64'
 *                       height: '64'
 *                       bitrate: 1000
 *                       maxBitrate: 1000
 *                       bFrames: 3
 *                       frameRate: '32'
 *                       slices: 1
 *                       adaptiveBFrameEnabled: true
 *                       profile: High444
 *                       level: auto
 *                       bufferWindow: PT5S
 *                       referenceFrames: 4
 *                       crf: 23
 *                       entropyMode: Cavlc
 *               - h265Video:
 *                   keyFrameInterval: PT2S
 *                   stretchMode: AutoSize
 *                   syncMode: Auto
 *                   sceneChangeDetectionEnabled: false
 *                   complexity: Speed
 *                   layers:
 *                     - width: '64'
 *                       height: '64'
 *                       bitrate: 1.045e+06
 *                       maxBitrate: 1.045e+06
 *                       bFrames: 3
 *                       slices: 5
 *                       adaptiveBFrameEnabled: true
 *                       profile: Auto
 *                       label: test
 *                       level: auto
 *                       bufferWindow: PT5S
 *                       frameRate: '32'
 *                       referenceFrames: 4
 *                       crf: 23
 *               - jpgImage:
 *                   stretchMode: AutoSize
 *                   syncMode: Auto
 *                   start: '10'
 *                   range: 100%%
 *                   spriteColumn: 1
 *                   step: '10'
 *                   layers:
 *                     - quality: 70
 *                       height: '180'
 *                       label: test
 *                       width: '120'
 *               - pngImage:
 *                   stretchMode: AutoSize
 *                   syncMode: Auto
 *                   start: '{Best}'
 *                   range: '80'
 *                   step: '10'
 *                   layers:
 *                     - height: '180'
 *                       label: test
 *                       width: '120'
 *             formats:
 *               - jpg:
 *                   filenamePattern: test{Basename}
 *               - mp4:
 *                   filenamePattern: test{Bitrate}
 *                   outputFiles:
 *                     - labels:
 *                         - test
 *                         - ppe
 *               - png:
 *                   filenamePattern: test{Basename}
 *               - transportStream:
 *                   filenamePattern: test{Bitrate}
 *                   outputFiles:
 *                     - labels:
 *                         - prod
 *             filter:
 *               cropRectangle:
 *                 height: '240'
 *                 left: '30'
 *                 top: '360'
 *                 width: '70'
 *               deinterlace:
 *                 parity: TopFieldFirst
 *                 mode: AutoPixelAdaptive
 *               fadeIn:
 *                 duration: PT5S
 *                 fadeColor: 0xFF0000
 *                 start: '10'
 *               fadeOut:
 *                 duration: 90%%
 *                 fadeColor: '#FF0C7B'
 *                 start: 10%%
 *               rotation: Auto
 *               overlays:
 *                 - audio:
 *                     inputLabel: label.jpg
 *                     start: PT5S
 *                     end: PT30S
 *                     fadeInDuration: PT1S
 *                     fadeOutDuration: PT2S
 *                     audioGainLevel: 1
 *                 - video:
 *                     inputLabel: label.jpg
 *                     start: PT5S
 *                     end: PT30S
 *                     fadeInDuration: PT1S
 *                     fadeOutDuration: PT2S
 *                     audioGainLevel: 1
 *                     opacity: 1
 *                     position:
 *                       height: '180'
 *                       left: '20'
 *                       top: '240'
 *                       width: '140'
 *                     cropRectangle:
 *                       height: '240'
 *                       left: '30'
 *                       top: '360'
 *                       width: '70'
 * ```
 * 
 * ## Import
 * Transforms can be imported using the `resource id`, e.g.
 * ```sh
 * $ pulumi import azure:media/transform:Transform example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Media/mediaServices/media1/transforms/transform1
 * ```
 * @property description An optional verbose description of the Transform.
 * @property mediaServicesAccountName The Media Services account name. Changing this forces a new Transform to be created.
 * @property name The name which should be used for this Transform. Changing this forces a new Transform to be created.
 * @property outputs One or more `output` blocks as defined below. At least one `output` must be defined.
 * @property resourceGroupName The name of the Resource Group where the Transform should exist. Changing this forces a new Transform to be created.
 */
public data class TransformArgs(
    public val description: Output? = null,
    public val mediaServicesAccountName: Output? = null,
    public val name: Output? = null,
    public val outputs: Output>? = null,
    public val resourceGroupName: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.azure.media.TransformArgs =
        com.pulumi.azure.media.TransformArgs.builder()
            .description(description?.applyValue({ args0 -> args0 }))
            .mediaServicesAccountName(mediaServicesAccountName?.applyValue({ args0 -> args0 }))
            .name(name?.applyValue({ args0 -> args0 }))
            .outputs(
                outputs?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .resourceGroupName(resourceGroupName?.applyValue({ args0 -> args0 })).build()
}

/**
 * Builder for [TransformArgs].
 */
@PulumiTagMarker
public class TransformArgsBuilder internal constructor() {
    private var description: Output? = null

    private var mediaServicesAccountName: Output? = null

    private var name: Output? = null

    private var outputs: Output>? = null

    private var resourceGroupName: Output? = null

    /**
     * @param value An optional verbose description of the Transform.
     */
    @JvmName("fnltbfwiypyhnnon")
    public suspend fun description(`value`: Output) {
        this.description = value
    }

    /**
     * @param value The Media Services account name. Changing this forces a new Transform to be created.
     */
    @JvmName("leocymkgkmfxsjqv")
    public suspend fun mediaServicesAccountName(`value`: Output) {
        this.mediaServicesAccountName = value
    }

    /**
     * @param value The name which should be used for this Transform. Changing this forces a new Transform to be created.
     */
    @JvmName("ofihvlshcvgexqfk")
    public suspend fun name(`value`: Output) {
        this.name = value
    }

    /**
     * @param value One or more `output` blocks as defined below. At least one `output` must be defined.
     */
    @JvmName("pnsujhmkrnmdcpic")
    public suspend fun outputs(`value`: Output>) {
        this.outputs = value
    }

    @JvmName("rfxphthkrweaunji")
    public suspend fun outputs(vararg values: Output) {
        this.outputs = Output.all(values.asList())
    }

    /**
     * @param values One or more `output` blocks as defined below. At least one `output` must be defined.
     */
    @JvmName("pvtmcricqqndrqdx")
    public suspend fun outputs(values: List>) {
        this.outputs = Output.all(values)
    }

    /**
     * @param value The name of the Resource Group where the Transform should exist. Changing this forces a new Transform to be created.
     */
    @JvmName("imblwkbkxxyvksxc")
    public suspend fun resourceGroupName(`value`: Output) {
        this.resourceGroupName = value
    }

    /**
     * @param value An optional verbose description of the Transform.
     */
    @JvmName("arwdvtchmaupqkcr")
    public suspend fun description(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.description = mapped
    }

    /**
     * @param value The Media Services account name. Changing this forces a new Transform to be created.
     */
    @JvmName("rljmglxexcpyirxq")
    public suspend fun mediaServicesAccountName(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.mediaServicesAccountName = mapped
    }

    /**
     * @param value The name which should be used for this Transform. Changing this forces a new Transform to be created.
     */
    @JvmName("koibelmqwtsikqbr")
    public suspend fun name(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.name = mapped
    }

    /**
     * @param value One or more `output` blocks as defined below. At least one `output` must be defined.
     */
    @JvmName("ohqisdevtnedxwad")
    public suspend fun outputs(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.outputs = mapped
    }

    /**
     * @param argument One or more `output` blocks as defined below. At least one `output` must be defined.
     */
    @JvmName("ekqtugsxjfkvxpsf")
    public suspend fun outputs(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            TransformOutputArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.outputs = mapped
    }

    /**
     * @param argument One or more `output` blocks as defined below. At least one `output` must be defined.
     */
    @JvmName("nbykhwkngktmywfa")
    public suspend fun outputs(vararg argument: suspend TransformOutputArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            TransformOutputArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.outputs = mapped
    }

    /**
     * @param argument One or more `output` blocks as defined below. At least one `output` must be defined.
     */
    @JvmName("xprslvqaosxjludn")
    public suspend fun outputs(argument: suspend TransformOutputArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(TransformOutputArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.outputs = mapped
    }

    /**
     * @param values One or more `output` blocks as defined below. At least one `output` must be defined.
     */
    @JvmName("pbyxuhdtofuvyumu")
    public suspend fun outputs(vararg values: TransformOutputArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.outputs = mapped
    }

    /**
     * @param value The name of the Resource Group where the Transform should exist. Changing this forces a new Transform to be created.
     */
    @JvmName("ualwrgniiooukllq")
    public suspend fun resourceGroupName(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.resourceGroupName = mapped
    }

    internal fun build(): TransformArgs = TransformArgs(
        description = description,
        mediaServicesAccountName = mediaServicesAccountName,
        name = name,
        outputs = outputs,
        resourceGroupName = resourceGroupName,
    )
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy