transcoder

package
v8.11.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 16, 2024 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Job 

type Job struct {
	pulumi.CustomResourceState

	// The configuration for this template.
	// Structure is documented below.
	Config JobConfigOutput `pulumi:"config"`
	// The time the job was created.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapOutput `pulumi:"effectiveLabels"`
	// The time the transcoding finished.
	EndTime pulumi.StringOutput `pulumi:"endTime"`
	// The labels associated with this job. You can use these to organize and group your jobs.
	//
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the resource.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// The location of the transcoding job resource.
	//
	// ***
	Location pulumi.StringOutput `pulumi:"location"`
	// The resource name of the job.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapOutput `pulumi:"pulumiLabels"`
	// The time the transcoding started.
	StartTime pulumi.StringOutput `pulumi:"startTime"`
	// The current state of the job.
	State pulumi.StringOutput `pulumi:"state"`
	// Specify the templateId to use for populating Job.config.
	// The default is preset/web-hd, which is the only supported preset.
	TemplateId pulumi.StringOutput `pulumi:"templateId"`
}

Transcoding Job Resource

To get more information about Job, see:

* [API documentation](https://cloud.google.com/transcoder/docs/reference/rest/v1/projects.locations.jobs) * How-to Guides

## Example Usage

### Transcoder Job Basic

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/storage"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/transcoder"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := storage.NewBucket(ctx, "default", &storage.BucketArgs{
			Name:                     pulumi.String("transcoder-job"),
			Location:                 pulumi.String("US"),
			ForceDestroy:             pulumi.Bool(true),
			UniformBucketLevelAccess: pulumi.Bool(true),
			PublicAccessPrevention:   pulumi.String("enforced"),
		})
		if err != nil {
			return err
		}
		exampleMp4, err := storage.NewBucketObject(ctx, "example_mp4", &storage.BucketObjectArgs{
			Name:   pulumi.String("example.mp4"),
			Source: pulumi.NewFileAsset("./test-fixtures/example.mp4"),
			Bucket: _default.Name,
		})
		if err != nil {
			return err
		}
		defaultJobTemplate, err := transcoder.NewJobTemplate(ctx, "default", &transcoder.JobTemplateArgs{
			JobTemplateId: pulumi.String("example-job-template"),
			Location:      pulumi.String("us-central1"),
			Config: &transcoder.JobTemplateConfigArgs{
				Inputs: transcoder.JobTemplateConfigInputTypeArray{
					&transcoder.JobTemplateConfigInputTypeArgs{
						Key: pulumi.String("input0"),
						Uri: pulumi.All(_default.Name, exampleMp4.Name).ApplyT(func(_args []interface{}) (string, error) {
							defaultName := _args[0].(string)
							exampleMp4Name := _args[1].(string)
							return fmt.Sprintf("gs://%v/%v", defaultName, exampleMp4Name), nil
						}).(pulumi.StringOutput),
					},
				},
				Output: &transcoder.JobTemplateConfigOutputTypeArgs{
					Uri: _default.Name.ApplyT(func(name string) (string, error) {
						return fmt.Sprintf("gs://%v/outputs/", name), nil
					}).(pulumi.StringOutput),
				},
				EditLists: transcoder.JobTemplateConfigEditListArray{
					&transcoder.JobTemplateConfigEditListArgs{
						Key: pulumi.String("atom0"),
						Inputs: pulumi.StringArray{
							pulumi.String("input0"),
						},
						StartTimeOffset: pulumi.String("0s"),
					},
				},
				ElementaryStreams: transcoder.JobTemplateConfigElementaryStreamArray{
					&transcoder.JobTemplateConfigElementaryStreamArgs{
						Key: pulumi.String("video-stream0"),
						VideoStream: &transcoder.JobTemplateConfigElementaryStreamVideoStreamArgs{
							H264: &transcoder.JobTemplateConfigElementaryStreamVideoStreamH264Args{
								WidthPixels:     pulumi.Int(640),
								HeightPixels:    pulumi.Int(360),
								BitrateBps:      pulumi.Int(550000),
								FrameRate:       pulumi.Int(60),
								PixelFormat:     pulumi.String("yuv420p"),
								RateControlMode: pulumi.String("vbr"),
								CrfLevel:        pulumi.Int(21),
								GopDuration:     pulumi.String("3s"),
								VbvSizeBits:     pulumi.Int(550000),
								VbvFullnessBits: pulumi.Int(495000),
								EntropyCoder:    pulumi.String("cabac"),
								Profile:         pulumi.String("high"),
								Preset:          pulumi.String("veryfast"),
							},
						},
					},
					&transcoder.JobTemplateConfigElementaryStreamArgs{
						Key: pulumi.String("video-stream1"),
						VideoStream: &transcoder.JobTemplateConfigElementaryStreamVideoStreamArgs{
							H264: &transcoder.JobTemplateConfigElementaryStreamVideoStreamH264Args{
								WidthPixels:     pulumi.Int(1280),
								HeightPixels:    pulumi.Int(720),
								BitrateBps:      pulumi.Int(550000),
								FrameRate:       pulumi.Int(60),
								PixelFormat:     pulumi.String("yuv420p"),
								RateControlMode: pulumi.String("vbr"),
								CrfLevel:        pulumi.Int(21),
								GopDuration:     pulumi.String("3s"),
								VbvSizeBits:     pulumi.Int(2500000),
								VbvFullnessBits: pulumi.Int(2250000),
								EntropyCoder:    pulumi.String("cabac"),
								Profile:         pulumi.String("high"),
								Preset:          pulumi.String("veryfast"),
							},
						},
					},
					&transcoder.JobTemplateConfigElementaryStreamArgs{
						Key: pulumi.String("audio-stream0"),
						AudioStream: &transcoder.JobTemplateConfigElementaryStreamAudioStreamArgs{
							Codec:        pulumi.String("aac"),
							BitrateBps:   pulumi.Int(64000),
							ChannelCount: pulumi.Int(2),
							ChannelLayouts: pulumi.StringArray{
								pulumi.String("fl"),
								pulumi.String("fr"),
							},
							SampleRateHertz: pulumi.Int(48000),
						},
					},
				},
				MuxStreams: transcoder.JobTemplateConfigMuxStreamArray{
					&transcoder.JobTemplateConfigMuxStreamArgs{
						Key:       pulumi.String("sd"),
						FileName:  pulumi.String("sd.mp4"),
						Container: pulumi.String("mp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream0"),
							pulumi.String("audio-stream0"),
						},
					},
					&transcoder.JobTemplateConfigMuxStreamArgs{
						Key:       pulumi.String("hd"),
						FileName:  pulumi.String("hd.mp4"),
						Container: pulumi.String("mp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream1"),
							pulumi.String("audio-stream0"),
						},
					},
				},
			},
			Labels: pulumi.StringMap{
				"label": pulumi.String("key"),
			},
		})
		if err != nil {
			return err
		}
		_, err = transcoder.NewJob(ctx, "default", &transcoder.JobArgs{
			TemplateId: defaultJobTemplate.Name,
			Location:   pulumi.String("us-central1"),
			Labels: pulumi.StringMap{
				"label": pulumi.String("key"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Transcoder Job Pubsub

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/pubsub"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/storage"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/transcoder"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := storage.NewBucket(ctx, "default", &storage.BucketArgs{
			Name:                     pulumi.String("transcoder-job"),
			Location:                 pulumi.String("US"),
			ForceDestroy:             pulumi.Bool(true),
			UniformBucketLevelAccess: pulumi.Bool(true),
			PublicAccessPrevention:   pulumi.String("enforced"),
		})
		if err != nil {
			return err
		}
		exampleMp4, err := storage.NewBucketObject(ctx, "example_mp4", &storage.BucketObjectArgs{
			Name:   pulumi.String("example.mp4"),
			Source: pulumi.NewFileAsset("./test-fixtures/example.mp4"),
			Bucket: _default.Name,
		})
		if err != nil {
			return err
		}
		transcoderNotifications, err := pubsub.NewTopic(ctx, "transcoder_notifications", &pubsub.TopicArgs{
			Name: pulumi.String("transcoder-notifications"),
		})
		if err != nil {
			return err
		}
		_, err = transcoder.NewJob(ctx, "default", &transcoder.JobArgs{
			Location: pulumi.String("us-central1"),
			Config: &transcoder.JobConfigArgs{
				Inputs: transcoder.JobConfigInputTypeArray{
					&transcoder.JobConfigInputTypeArgs{
						Key: pulumi.String("input0"),
						Uri: pulumi.All(_default.Name, exampleMp4.Name).ApplyT(func(_args []interface{}) (string, error) {
							defaultName := _args[0].(string)
							exampleMp4Name := _args[1].(string)
							return fmt.Sprintf("gs://%v/%v", defaultName, exampleMp4Name), nil
						}).(pulumi.StringOutput),
					},
				},
				EditLists: transcoder.JobConfigEditListArray{
					&transcoder.JobConfigEditListArgs{
						Key: pulumi.String("atom0"),
						Inputs: pulumi.StringArray{
							pulumi.String("input0"),
						},
						StartTimeOffset: pulumi.String("0s"),
					},
				},
				AdBreaks: transcoder.JobConfigAdBreakArray{
					&transcoder.JobConfigAdBreakArgs{
						StartTimeOffset: pulumi.String("3.500s"),
					},
				},
				ElementaryStreams: transcoder.JobConfigElementaryStreamArray{
					&transcoder.JobConfigElementaryStreamArgs{
						Key: pulumi.String("video-stream0"),
						VideoStream: &transcoder.JobConfigElementaryStreamVideoStreamArgs{
							H264: &transcoder.JobConfigElementaryStreamVideoStreamH264Args{
								WidthPixels:     pulumi.Int(640),
								HeightPixels:    pulumi.Int(360),
								BitrateBps:      pulumi.Int(550000),
								FrameRate:       pulumi.Int(60),
								PixelFormat:     pulumi.String("yuv420p"),
								RateControlMode: pulumi.String("vbr"),
								CrfLevel:        pulumi.Int(21),
								GopDuration:     pulumi.String("3s"),
								VbvSizeBits:     pulumi.Int(550000),
								VbvFullnessBits: pulumi.Int(495000),
								EntropyCoder:    pulumi.String("cabac"),
								Profile:         pulumi.String("high"),
								Preset:          pulumi.String("veryfast"),
							},
						},
					},
					&transcoder.JobConfigElementaryStreamArgs{
						Key: pulumi.String("video-stream1"),
						VideoStream: &transcoder.JobConfigElementaryStreamVideoStreamArgs{
							H264: &transcoder.JobConfigElementaryStreamVideoStreamH264Args{
								WidthPixels:     pulumi.Int(1280),
								HeightPixels:    pulumi.Int(720),
								BitrateBps:      pulumi.Int(550000),
								FrameRate:       pulumi.Int(60),
								PixelFormat:     pulumi.String("yuv420p"),
								RateControlMode: pulumi.String("vbr"),
								CrfLevel:        pulumi.Int(21),
								GopDuration:     pulumi.String("3s"),
								VbvSizeBits:     pulumi.Int(2500000),
								VbvFullnessBits: pulumi.Int(2250000),
								EntropyCoder:    pulumi.String("cabac"),
								Profile:         pulumi.String("high"),
								Preset:          pulumi.String("veryfast"),
							},
						},
					},
					&transcoder.JobConfigElementaryStreamArgs{
						Key: pulumi.String("audio-stream0"),
						AudioStream: &transcoder.JobConfigElementaryStreamAudioStreamArgs{
							Codec:        pulumi.String("aac"),
							BitrateBps:   pulumi.Int(64000),
							ChannelCount: pulumi.Int(2),
							ChannelLayouts: pulumi.StringArray{
								pulumi.String("fl"),
								pulumi.String("fr"),
							},
							SampleRateHertz: pulumi.Int(48000),
						},
					},
				},
				MuxStreams: transcoder.JobConfigMuxStreamArray{
					&transcoder.JobConfigMuxStreamArgs{
						Key:       pulumi.String("sd"),
						FileName:  pulumi.String("sd.mp4"),
						Container: pulumi.String("mp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream0"),
							pulumi.String("audio-stream0"),
						},
					},
					&transcoder.JobConfigMuxStreamArgs{
						Key:       pulumi.String("hd"),
						FileName:  pulumi.String("hd.mp4"),
						Container: pulumi.String("mp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream1"),
							pulumi.String("audio-stream0"),
						},
					},
				},
				PubsubDestination: &transcoder.JobConfigPubsubDestinationArgs{
					Topic: transcoderNotifications.ID(),
				},
				Output: &transcoder.JobConfigOutputTypeArgs{
					Uri: _default.Name.ApplyT(func(name string) (string, error) {
						return fmt.Sprintf("gs://%v/outputs/", name), nil
					}).(pulumi.StringOutput),
				},
			},
			Labels: pulumi.StringMap{
				"label": pulumi.String("key"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Transcoder Job Encryptions

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/organizations"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/projects"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/secretmanager"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/storage"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/transcoder"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := storage.NewBucket(ctx, "default", &storage.BucketArgs{
			Name:                     pulumi.String("transcoder-job"),
			Location:                 pulumi.String("US"),
			ForceDestroy:             pulumi.Bool(true),
			UniformBucketLevelAccess: pulumi.Bool(true),
			PublicAccessPrevention:   pulumi.String("enforced"),
		})
		if err != nil {
			return err
		}
		exampleMp4, err := storage.NewBucketObject(ctx, "example_mp4", &storage.BucketObjectArgs{
			Name:   pulumi.String("example.mp4"),
			Source: pulumi.NewFileAsset("./test-fixtures/example.mp4"),
			Bucket: _default.Name,
		})
		if err != nil {
			return err
		}
		encryptionKey, err := secretmanager.NewSecret(ctx, "encryption_key", &secretmanager.SecretArgs{
			SecretId: pulumi.String("transcoder-encryption-key"),
			Replication: &secretmanager.SecretReplicationArgs{
				Auto: &secretmanager.SecretReplicationAutoArgs{},
			},
		})
		if err != nil {
			return err
		}
		encryptionKeySecretVersion, err := secretmanager.NewSecretVersion(ctx, "encryption_key", &secretmanager.SecretVersionArgs{
			Secret:     encryptionKey.Name,
			SecretData: pulumi.String("4A67F2C1B8E93A4F6D3E7890A1BC23DF"),
		})
		if err != nil {
			return err
		}
		project, err := organizations.LookupProject(ctx, &organizations.LookupProjectArgs{}, nil)
		if err != nil {
			return err
		}
		// this is required to allow the transcoder service identity to access the secret
		transcoder, err := projects.NewServiceIdentity(ctx, "transcoder", &projects.ServiceIdentityArgs{
			Project: pulumi.String(project.ProjectId),
			Service: pulumi.String("transcoder.googleapis.com"),
		})
		if err != nil {
			return err
		}
		_, err = secretmanager.NewSecretIamMember(ctx, "transcoder_encryption_key_accessor", &secretmanager.SecretIamMemberArgs{
			SecretId: encryptionKey.SecretId,
			Project:  encryptionKey.Project,
			Role:     pulumi.String("roles/secretmanager.secretAccessor"),
			Member: transcoder.Email.ApplyT(func(email string) (string, error) {
				return fmt.Sprintf("serviceAccount:%v", email), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		_, err = transcoder.NewJob(ctx, "default", &transcoder.JobArgs{
			Location: pulumi.String("us-central1"),
			Config: &transcoder.JobConfigArgs{
				Inputs: transcoder.JobConfigInputTypeArray{
					&transcoder.JobConfigInputTypeArgs{
						Key: pulumi.String("input0"),
						Uri: pulumi.All(_default.Name, exampleMp4.Name).ApplyT(func(_args []interface{}) (string, error) {
							defaultName := _args[0].(string)
							exampleMp4Name := _args[1].(string)
							return fmt.Sprintf("gs://%v/%v", defaultName, exampleMp4Name), nil
						}).(pulumi.StringOutput),
					},
				},
				ElementaryStreams: transcoder.JobConfigElementaryStreamArray{
					&transcoder.JobConfigElementaryStreamArgs{
						Key: pulumi.String("es_video"),
						VideoStream: &transcoder.JobConfigElementaryStreamVideoStreamArgs{
							H264: &transcoder.JobConfigElementaryStreamVideoStreamH264Args{
								Profile:      pulumi.String("main"),
								HeightPixels: pulumi.Int(600),
								WidthPixels:  pulumi.Int(800),
								BitrateBps:   pulumi.Int(1000000),
								FrameRate:    pulumi.Int(60),
							},
						},
					},
					&transcoder.JobConfigElementaryStreamArgs{
						Key: pulumi.String("es_audio"),
						AudioStream: &transcoder.JobConfigElementaryStreamAudioStreamArgs{
							Codec:        pulumi.String("aac"),
							ChannelCount: pulumi.Int(2),
							BitrateBps:   pulumi.Int(160000),
						},
					},
				},
				Encryptions: transcoder.JobConfigEncryptionArray{
					&transcoder.JobConfigEncryptionArgs{
						Id: pulumi.String("aes-128"),
						SecretManagerKeySource: &transcoder.JobConfigEncryptionSecretManagerKeySourceArgs{
							SecretVersion: encryptionKeySecretVersion.Name,
						},
						DrmSystems: &transcoder.JobConfigEncryptionDrmSystemsArgs{
							Clearkey: &transcoder.JobConfigEncryptionDrmSystemsClearkeyArgs{},
						},
						Aes128: &transcoder.JobConfigEncryptionAes128Args{},
					},
					&transcoder.JobConfigEncryptionArgs{
						Id: pulumi.String("cenc"),
						SecretManagerKeySource: &transcoder.JobConfigEncryptionSecretManagerKeySourceArgs{
							SecretVersion: encryptionKeySecretVersion.Name,
						},
						DrmSystems: &transcoder.JobConfigEncryptionDrmSystemsArgs{
							Widevine: &transcoder.JobConfigEncryptionDrmSystemsWidevineArgs{},
						},
						MpegCenc: &transcoder.JobConfigEncryptionMpegCencArgs{
							Scheme: pulumi.String("cenc"),
						},
					},
					&transcoder.JobConfigEncryptionArgs{
						Id: pulumi.String("cbcs"),
						SecretManagerKeySource: &transcoder.JobConfigEncryptionSecretManagerKeySourceArgs{
							SecretVersion: encryptionKeySecretVersion.Name,
						},
						DrmSystems: &transcoder.JobConfigEncryptionDrmSystemsArgs{
							Widevine: &transcoder.JobConfigEncryptionDrmSystemsWidevineArgs{},
						},
						MpegCenc: &transcoder.JobConfigEncryptionMpegCencArgs{
							Scheme: pulumi.String("cbcs"),
						},
					},
				},
				MuxStreams: transcoder.JobConfigMuxStreamArray{
					&transcoder.JobConfigMuxStreamArgs{
						Key:       pulumi.String("ts_aes128"),
						Container: pulumi.String("ts"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("es_video"),
							pulumi.String("es_audio"),
						},
						SegmentSettings: &transcoder.JobConfigMuxStreamSegmentSettingsArgs{
							SegmentDuration: pulumi.String("6s"),
						},
						EncryptionId: pulumi.String("aes-128"),
					},
					&transcoder.JobConfigMuxStreamArgs{
						Key:       pulumi.String("fmp4_cenc_video"),
						Container: pulumi.String("fmp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("es_video"),
						},
						SegmentSettings: &transcoder.JobConfigMuxStreamSegmentSettingsArgs{
							SegmentDuration: pulumi.String("6s"),
						},
						EncryptionId: pulumi.String("cenc"),
					},
					&transcoder.JobConfigMuxStreamArgs{
						Key:       pulumi.String("fmp4_cenc_audio"),
						Container: pulumi.String("fmp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("es_audio"),
						},
						SegmentSettings: &transcoder.JobConfigMuxStreamSegmentSettingsArgs{
							SegmentDuration: pulumi.String("6s"),
						},
						EncryptionId: pulumi.String("cenc"),
					},
					&transcoder.JobConfigMuxStreamArgs{
						Key:       pulumi.String("fmp4_cbcs_video"),
						Container: pulumi.String("fmp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("es_video"),
						},
						SegmentSettings: &transcoder.JobConfigMuxStreamSegmentSettingsArgs{
							SegmentDuration: pulumi.String("6s"),
						},
						EncryptionId: pulumi.String("cbcs"),
					},
					&transcoder.JobConfigMuxStreamArgs{
						Key:       pulumi.String("fmp4_cbcs_audio"),
						Container: pulumi.String("fmp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("es_audio"),
						},
						SegmentSettings: &transcoder.JobConfigMuxStreamSegmentSettingsArgs{
							SegmentDuration: pulumi.String("6s"),
						},
						EncryptionId: pulumi.String("cbcs"),
					},
				},
				Manifests: transcoder.JobConfigManifestArray{
					&transcoder.JobConfigManifestArgs{
						FileName: pulumi.String("manifest_aes128.m3u8"),
						Type:     pulumi.String("HLS"),
						MuxStreams: pulumi.StringArray{
							pulumi.String("ts_aes128"),
						},
					},
					&transcoder.JobConfigManifestArgs{
						FileName: pulumi.String("manifest_cenc.mpd"),
						Type:     pulumi.String("DASH"),
						MuxStreams: pulumi.StringArray{
							pulumi.String("fmp4_cenc_video"),
							pulumi.String("fmp4_cenc_audio"),
						},
					},
					&transcoder.JobConfigManifestArgs{
						FileName: pulumi.String("manifest_cbcs.mpd"),
						Type:     pulumi.String("DASH"),
						MuxStreams: pulumi.StringArray{
							pulumi.String("fmp4_cbcs_video"),
							pulumi.String("fmp4_cbcs_audio"),
						},
					},
				},
				Output: &transcoder.JobConfigOutputTypeArgs{
					Uri: _default.Name.ApplyT(func(name string) (string, error) {
						return fmt.Sprintf("gs://%v/outputs/", name), nil
					}).(pulumi.StringOutput),
				},
			},
			Labels: pulumi.StringMap{
				"label": pulumi.String("key"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Transcoder Job Overlays

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/storage"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/transcoder"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := storage.NewBucket(ctx, "default", &storage.BucketArgs{
			Name:                     pulumi.String("transcoder-job"),
			Location:                 pulumi.String("US"),
			ForceDestroy:             pulumi.Bool(true),
			UniformBucketLevelAccess: pulumi.Bool(true),
			PublicAccessPrevention:   pulumi.String("enforced"),
		})
		if err != nil {
			return err
		}
		exampleMp4, err := storage.NewBucketObject(ctx, "example_mp4", &storage.BucketObjectArgs{
			Name:   pulumi.String("example.mp4"),
			Source: pulumi.NewFileAsset("./test-fixtures/example.mp4"),
			Bucket: _default.Name,
		})
		if err != nil {
			return err
		}
		overlayPng, err := storage.NewBucketObject(ctx, "overlay_png", &storage.BucketObjectArgs{
			Name:   pulumi.String("overlay.png"),
			Source: pulumi.NewFileAsset("./test-fixtures/overlay.png"),
			Bucket: _default.Name,
		})
		if err != nil {
			return err
		}
		_, err = transcoder.NewJob(ctx, "default", &transcoder.JobArgs{
			Location: pulumi.String("us-central1"),
			Config: &transcoder.JobConfigArgs{
				Inputs: transcoder.JobConfigInputTypeArray{
					&transcoder.JobConfigInputTypeArgs{
						Key: pulumi.String("input0"),
						Uri: pulumi.All(_default.Name, exampleMp4.Name).ApplyT(func(_args []interface{}) (string, error) {
							defaultName := _args[0].(string)
							exampleMp4Name := _args[1].(string)
							return fmt.Sprintf("gs://%v/%v", defaultName, exampleMp4Name), nil
						}).(pulumi.StringOutput),
					},
				},
				EditLists: transcoder.JobConfigEditListArray{
					&transcoder.JobConfigEditListArgs{
						Key: pulumi.String("atom0"),
						Inputs: pulumi.StringArray{
							pulumi.String("input0"),
						},
						StartTimeOffset: pulumi.String("0s"),
					},
				},
				AdBreaks: transcoder.JobConfigAdBreakArray{
					&transcoder.JobConfigAdBreakArgs{
						StartTimeOffset: pulumi.String("3.500s"),
					},
				},
				Overlays: transcoder.JobConfigOverlayArray{
					&transcoder.JobConfigOverlayArgs{
						Animations: transcoder.JobConfigOverlayAnimationArray{
							&transcoder.JobConfigOverlayAnimationArgs{
								AnimationFade: &transcoder.JobConfigOverlayAnimationAnimationFadeArgs{
									FadeType:        pulumi.String("FADE_IN"),
									StartTimeOffset: pulumi.String("1.500s"),
									EndTimeOffset:   pulumi.String("3.500s"),
									Xy: &transcoder.JobConfigOverlayAnimationAnimationFadeXyArgs{
										X: pulumi.Float64(1),
										Y: pulumi.Float64(0.5),
									},
								},
							},
						},
						Image: &transcoder.JobConfigOverlayImageArgs{
							Uri: pulumi.All(_default.Name, overlayPng.Name).ApplyT(func(_args []interface{}) (string, error) {
								defaultName := _args[0].(string)
								overlayPngName := _args[1].(string)
								return fmt.Sprintf("gs://%v/%v", defaultName, overlayPngName), nil
							}).(pulumi.StringOutput),
						},
					},
				},
				ElementaryStreams: transcoder.JobConfigElementaryStreamArray{
					&transcoder.JobConfigElementaryStreamArgs{
						Key: pulumi.String("video-stream0"),
						VideoStream: &transcoder.JobConfigElementaryStreamVideoStreamArgs{
							H264: &transcoder.JobConfigElementaryStreamVideoStreamH264Args{
								WidthPixels:     pulumi.Int(640),
								HeightPixels:    pulumi.Int(360),
								BitrateBps:      pulumi.Int(550000),
								FrameRate:       pulumi.Int(60),
								PixelFormat:     pulumi.String("yuv420p"),
								RateControlMode: pulumi.String("vbr"),
								CrfLevel:        pulumi.Int(21),
								GopDuration:     pulumi.String("3s"),
								VbvSizeBits:     pulumi.Int(550000),
								VbvFullnessBits: pulumi.Int(495000),
								EntropyCoder:    pulumi.String("cabac"),
								Profile:         pulumi.String("high"),
								Preset:          pulumi.String("veryfast"),
							},
						},
					},
					&transcoder.JobConfigElementaryStreamArgs{
						Key: pulumi.String("video-stream1"),
						VideoStream: &transcoder.JobConfigElementaryStreamVideoStreamArgs{
							H264: &transcoder.JobConfigElementaryStreamVideoStreamH264Args{
								WidthPixels:     pulumi.Int(1280),
								HeightPixels:    pulumi.Int(720),
								BitrateBps:      pulumi.Int(550000),
								FrameRate:       pulumi.Int(60),
								PixelFormat:     pulumi.String("yuv420p"),
								RateControlMode: pulumi.String("vbr"),
								CrfLevel:        pulumi.Int(21),
								GopDuration:     pulumi.String("3s"),
								VbvSizeBits:     pulumi.Int(2500000),
								VbvFullnessBits: pulumi.Int(2250000),
								EntropyCoder:    pulumi.String("cabac"),
								Profile:         pulumi.String("high"),
								Preset:          pulumi.String("veryfast"),
							},
						},
					},
					&transcoder.JobConfigElementaryStreamArgs{
						Key: pulumi.String("audio-stream0"),
						AudioStream: &transcoder.JobConfigElementaryStreamAudioStreamArgs{
							Codec:        pulumi.String("aac"),
							BitrateBps:   pulumi.Int(64000),
							ChannelCount: pulumi.Int(2),
							ChannelLayouts: pulumi.StringArray{
								pulumi.String("fl"),
								pulumi.String("fr"),
							},
							SampleRateHertz: pulumi.Int(48000),
						},
					},
				},
				MuxStreams: transcoder.JobConfigMuxStreamArray{
					&transcoder.JobConfigMuxStreamArgs{
						Key:       pulumi.String("sd"),
						FileName:  pulumi.String("sd.mp4"),
						Container: pulumi.String("mp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream0"),
							pulumi.String("audio-stream0"),
						},
					},
					&transcoder.JobConfigMuxStreamArgs{
						Key:       pulumi.String("hd"),
						FileName:  pulumi.String("hd.mp4"),
						Container: pulumi.String("mp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream1"),
							pulumi.String("audio-stream0"),
						},
					},
				},
				Output: &transcoder.JobConfigOutputTypeArgs{
					Uri: _default.Name.ApplyT(func(name string) (string, error) {
						return fmt.Sprintf("gs://%v/outputs/", name), nil
					}).(pulumi.StringOutput),
				},
			},
			Labels: pulumi.StringMap{
				"label": pulumi.String("key"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Transcoder Job Manifests

```go package main

import ( 

"fmt"

"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/storage"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/transcoder"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := storage.NewBucket(ctx, "default", &storage.BucketArgs{
			Name:                     pulumi.String("transcoder-job"),
			Location:                 pulumi.String("US"),
			ForceDestroy:             pulumi.Bool(true),
			UniformBucketLevelAccess: pulumi.Bool(true),
			PublicAccessPrevention:   pulumi.String("enforced"),
		})
		if err != nil {
			return err
		}
		exampleMp4, err := storage.NewBucketObject(ctx, "example_mp4", &storage.BucketObjectArgs{
			Name:   pulumi.String("example.mp4"),
			Source: pulumi.NewFileAsset("./test-fixtures/example.mp4"),
			Bucket: _default.Name,
		})
		if err != nil {
			return err
		}
		_, err = transcoder.NewJob(ctx, "default", &transcoder.JobArgs{
			Location: pulumi.String("us-central1"),
			Config: &transcoder.JobConfigArgs{
				Inputs: transcoder.JobConfigInputTypeArray{
					&transcoder.JobConfigInputTypeArgs{
						Key: pulumi.String("input0"),
						Uri: pulumi.All(_default.Name, exampleMp4.Name).ApplyT(func(_args []interface{}) (string, error) {
							defaultName := _args[0].(string)
							exampleMp4Name := _args[1].(string)
							return fmt.Sprintf("gs://%v/%v", defaultName, exampleMp4Name), nil
						}).(pulumi.StringOutput),
					},
				},
				EditLists: transcoder.JobConfigEditListArray{
					&transcoder.JobConfigEditListArgs{
						Key:             pulumi.String("atom0"),
						StartTimeOffset: pulumi.String("0s"),
						Inputs: pulumi.StringArray{
							pulumi.String("input0"),
						},
					},
				},
				AdBreaks: transcoder.JobConfigAdBreakArray{
					&transcoder.JobConfigAdBreakArgs{
						StartTimeOffset: pulumi.String("3.500s"),
					},
				},
				ElementaryStreams: transcoder.JobConfigElementaryStreamArray{
					&transcoder.JobConfigElementaryStreamArgs{
						Key: pulumi.String("video-stream0"),
						VideoStream: &transcoder.JobConfigElementaryStreamVideoStreamArgs{
							H264: &transcoder.JobConfigElementaryStreamVideoStreamH264Args{
								WidthPixels:     pulumi.Int(640),
								HeightPixels:    pulumi.Int(360),
								BitrateBps:      pulumi.Int(550000),
								FrameRate:       pulumi.Int(60),
								PixelFormat:     pulumi.String("yuv420p"),
								RateControlMode: pulumi.String("vbr"),
								CrfLevel:        pulumi.Int(21),
								GopDuration:     pulumi.String("3s"),
								VbvSizeBits:     pulumi.Int(550000),
								VbvFullnessBits: pulumi.Int(495000),
								EntropyCoder:    pulumi.String("cabac"),
								Profile:         pulumi.String("high"),
								Preset:          pulumi.String("veryfast"),
							},
						},
					},
					&transcoder.JobConfigElementaryStreamArgs{
						Key: pulumi.String("video-stream1"),
						VideoStream: &transcoder.JobConfigElementaryStreamVideoStreamArgs{
							H264: &transcoder.JobConfigElementaryStreamVideoStreamH264Args{
								WidthPixels:     pulumi.Int(1280),
								HeightPixels:    pulumi.Int(720),
								BitrateBps:      pulumi.Int(550000),
								FrameRate:       pulumi.Int(60),
								PixelFormat:     pulumi.String("yuv420p"),
								RateControlMode: pulumi.String("vbr"),
								CrfLevel:        pulumi.Int(21),
								GopDuration:     pulumi.String("3s"),
								VbvSizeBits:     pulumi.Int(2500000),
								VbvFullnessBits: pulumi.Int(2250000),
								EntropyCoder:    pulumi.String("cabac"),
								Profile:         pulumi.String("high"),
								Preset:          pulumi.String("veryfast"),
							},
						},
					},
					&transcoder.JobConfigElementaryStreamArgs{
						Key: pulumi.String("audio-stream0"),
						AudioStream: &transcoder.JobConfigElementaryStreamAudioStreamArgs{
							Codec:        pulumi.String("aac"),
							BitrateBps:   pulumi.Int(64000),
							ChannelCount: pulumi.Int(2),
							ChannelLayouts: pulumi.StringArray{
								pulumi.String("fl"),
								pulumi.String("fr"),
							},
							SampleRateHertz: pulumi.Int(48000),
						},
					},
				},
				MuxStreams: transcoder.JobConfigMuxStreamArray{
					&transcoder.JobConfigMuxStreamArgs{
						Key:       pulumi.String("sd"),
						FileName:  pulumi.String("sd.mp4"),
						Container: pulumi.String("mp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream0"),
							pulumi.String("audio-stream0"),
						},
					},
					&transcoder.JobConfigMuxStreamArgs{
						Key:       pulumi.String("hd"),
						FileName:  pulumi.String("hd.mp4"),
						Container: pulumi.String("mp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream1"),
							pulumi.String("audio-stream0"),
						},
					},
					&transcoder.JobConfigMuxStreamArgs{
						Key:       pulumi.String("media-sd"),
						FileName:  pulumi.String("media-sd.ts"),
						Container: pulumi.String("ts"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream0"),
							pulumi.String("audio-stream0"),
						},
					},
					&transcoder.JobConfigMuxStreamArgs{
						Key:       pulumi.String("media-hd"),
						FileName:  pulumi.String("media-hd.ts"),
						Container: pulumi.String("ts"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream1"),
							pulumi.String("audio-stream0"),
						},
					},
					&transcoder.JobConfigMuxStreamArgs{
						Key:       pulumi.String("video-only-sd"),
						FileName:  pulumi.String("video-only-sd.m4s"),
						Container: pulumi.String("fmp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream0"),
						},
					},
					&transcoder.JobConfigMuxStreamArgs{
						Key:       pulumi.String("video-only-hd"),
						FileName:  pulumi.String("video-only-hd.m4s"),
						Container: pulumi.String("fmp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream1"),
						},
					},
					&transcoder.JobConfigMuxStreamArgs{
						Key:       pulumi.String("audio-only"),
						FileName:  pulumi.String("audio-only.m4s"),
						Container: pulumi.String("fmp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("audio-stream0"),
						},
					},
				},
				Manifests: transcoder.JobConfigManifestArray{
					&transcoder.JobConfigManifestArgs{
						FileName: pulumi.String("manifest.m3u8"),
						Type:     pulumi.String("HLS"),
						MuxStreams: pulumi.StringArray{
							pulumi.String("media-sd"),
							pulumi.String("media-hd"),
						},
					},
					&transcoder.JobConfigManifestArgs{
						FileName: pulumi.String("manifest.mpd"),
						Type:     pulumi.String("DASH"),
						MuxStreams: pulumi.StringArray{
							pulumi.String("video-only-sd"),
							pulumi.String("video-only-hd"),
							pulumi.String("audio-only"),
						},
					},
				},
				Output: &transcoder.JobConfigOutputTypeArgs{
					Uri: _default.Name.ApplyT(func(name string) (string, error) {
						return fmt.Sprintf("gs://%v/outputs/", name), nil
					}).(pulumi.StringOutput),
				},
			},
			Labels: pulumi.StringMap{
				"label": pulumi.String("key"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Job can be imported using any of these accepted formats:

* `{{project}}/{{name}}`

* `{{project}} {{name}}`

* `{{name}}`

When using the `pulumi import` command, Job can be imported using one of the formats above. For example:

```sh $ pulumi import gcp:transcoder/job:Job default {{project}}/{{name}} ```

```sh $ pulumi import gcp:transcoder/job:Job default "{{project}} {{name}}" ```

```sh $ pulumi import gcp:transcoder/job:Job default {{name}} ```

func GetJob 

func GetJob(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *JobState, opts ...pulumi.ResourceOption) (*Job, error)

GetJob gets an existing Job resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewJob 

func NewJob(ctx *pulumi.Context,
	name string, args *JobArgs, opts ...pulumi.ResourceOption) (*Job, error)

NewJob registers a new resource with the given unique name, arguments, and options.

func (*Job) ElementType 

func (*Job) ElementType() reflect.Type

func (*Job) ToJobOutput 

func (i *Job) ToJobOutput() JobOutput

func (*Job) ToJobOutputWithContext 

func (i *Job) ToJobOutputWithContext(ctx context.Context) JobOutput

type JobArgs 

type JobArgs struct {
	// The configuration for this template.
	// Structure is documented below.
	Config JobConfigPtrInput
	// The labels associated with this job. You can use these to organize and group your jobs.
	//
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the resource.
	Labels pulumi.StringMapInput
	// The location of the transcoding job resource.
	//
	// ***
	Location pulumi.StringInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// Specify the templateId to use for populating Job.config.
	// The default is preset/web-hd, which is the only supported preset.
	TemplateId pulumi.StringPtrInput
}

The set of arguments for constructing a Job resource.

func (JobArgs) ElementType 

func (JobArgs) ElementType() reflect.Type

type JobArray 

type JobArray []JobInput

func (JobArray) ElementType 

func (JobArray) ElementType() reflect.Type

func (JobArray) ToJobArrayOutput 

func (i JobArray) ToJobArrayOutput() JobArrayOutput

func (JobArray) ToJobArrayOutputWithContext 

func (i JobArray) ToJobArrayOutputWithContext(ctx context.Context) JobArrayOutput

type JobArrayInput 

type JobArrayInput interface {
	pulumi.Input

	ToJobArrayOutput() JobArrayOutput
	ToJobArrayOutputWithContext(context.Context) JobArrayOutput
}

JobArrayInput is an input type that accepts JobArray and JobArrayOutput values. You can construct a concrete instance of `JobArrayInput` via: 

JobArray{ JobArgs{...} }

type JobArrayOutput 

type JobArrayOutput struct{ *pulumi.OutputState }

func (JobArrayOutput) ElementType 

func (JobArrayOutput) ElementType() reflect.Type

func (JobArrayOutput) Index 

func (o JobArrayOutput) Index(i pulumi.IntInput) JobOutput

func (JobArrayOutput) ToJobArrayOutput 

func (o JobArrayOutput) ToJobArrayOutput() JobArrayOutput

func (JobArrayOutput) ToJobArrayOutputWithContext 

func (o JobArrayOutput) ToJobArrayOutputWithContext(ctx context.Context) JobArrayOutput

type JobConfig 

type JobConfig struct {
	// Ad break.
	// Structure is documented below.
	AdBreaks []JobConfigAdBreak `pulumi:"adBreaks"`
	// List of input assets stored in Cloud Storage.
	// Structure is documented below.
	EditLists []JobConfigEditList `pulumi:"editLists"`
	// List of input assets stored in Cloud Storage.
	// Structure is documented below.
	ElementaryStreams []JobConfigElementaryStream `pulumi:"elementaryStreams"`
	// List of encryption configurations for the content.
	// Structure is documented below.
	Encryptions []JobConfigEncryption `pulumi:"encryptions"`
	// List of input assets stored in Cloud Storage.
	// Structure is documented below.
	Inputs []JobConfigInputType `pulumi:"inputs"`
	// Manifest configuration.
	// Structure is documented below.
	Manifests []JobConfigManifest `pulumi:"manifests"`
	// Multiplexing settings for output stream.
	// Structure is documented below.
	MuxStreams []JobConfigMuxStream `pulumi:"muxStreams"`
	// Location of output file(s) in a Cloud Storage bucket.
	// Structure is documented below.
	Output *JobConfigOutputType `pulumi:"output"`
	// List of overlays on the output video, in descending Z-order.
	// Structure is documented below.
	Overlays []JobConfigOverlay `pulumi:"overlays"`
	// Pub/Sub destination.
	// Structure is documented below.
	PubsubDestination *JobConfigPubsubDestination `pulumi:"pubsubDestination"`
}

type JobConfigAdBreak 

type JobConfigAdBreak struct {
	// Start time in seconds for the ad break, relative to the output file timeline
	StartTimeOffset *string `pulumi:"startTimeOffset"`
}

type JobConfigAdBreakArgs 

type JobConfigAdBreakArgs struct {
	// Start time in seconds for the ad break, relative to the output file timeline
	StartTimeOffset pulumi.StringPtrInput `pulumi:"startTimeOffset"`
}

func (JobConfigAdBreakArgs) ElementType 

func (JobConfigAdBreakArgs) ElementType() reflect.Type

func (JobConfigAdBreakArgs) ToJobConfigAdBreakOutput 

func (i JobConfigAdBreakArgs) ToJobConfigAdBreakOutput() JobConfigAdBreakOutput

func (JobConfigAdBreakArgs) ToJobConfigAdBreakOutputWithContext 

func (i JobConfigAdBreakArgs) ToJobConfigAdBreakOutputWithContext(ctx context.Context) JobConfigAdBreakOutput

type JobConfigAdBreakArray 

type JobConfigAdBreakArray []JobConfigAdBreakInput

func (JobConfigAdBreakArray) ElementType 

func (JobConfigAdBreakArray) ElementType() reflect.Type

func (JobConfigAdBreakArray) ToJobConfigAdBreakArrayOutput 

func (i JobConfigAdBreakArray) ToJobConfigAdBreakArrayOutput() JobConfigAdBreakArrayOutput

func (JobConfigAdBreakArray) ToJobConfigAdBreakArrayOutputWithContext 

func (i JobConfigAdBreakArray) ToJobConfigAdBreakArrayOutputWithContext(ctx context.Context) JobConfigAdBreakArrayOutput

type JobConfigAdBreakArrayInput 

type JobConfigAdBreakArrayInput interface {
	pulumi.Input

	ToJobConfigAdBreakArrayOutput() JobConfigAdBreakArrayOutput
	ToJobConfigAdBreakArrayOutputWithContext(context.Context) JobConfigAdBreakArrayOutput
}

JobConfigAdBreakArrayInput is an input type that accepts JobConfigAdBreakArray and JobConfigAdBreakArrayOutput values. You can construct a concrete instance of `JobConfigAdBreakArrayInput` via: 

JobConfigAdBreakArray{ JobConfigAdBreakArgs{...} }

type JobConfigAdBreakArrayOutput 

type JobConfigAdBreakArrayOutput struct{ *pulumi.OutputState }

func (JobConfigAdBreakArrayOutput) ElementType 

func (JobConfigAdBreakArrayOutput) ElementType() reflect.Type

func (JobConfigAdBreakArrayOutput) Index 

func (o JobConfigAdBreakArrayOutput) Index(i pulumi.IntInput) JobConfigAdBreakOutput

func (JobConfigAdBreakArrayOutput) ToJobConfigAdBreakArrayOutput 

func (o JobConfigAdBreakArrayOutput) ToJobConfigAdBreakArrayOutput() JobConfigAdBreakArrayOutput

func (JobConfigAdBreakArrayOutput) ToJobConfigAdBreakArrayOutputWithContext 

func (o JobConfigAdBreakArrayOutput) ToJobConfigAdBreakArrayOutputWithContext(ctx context.Context) JobConfigAdBreakArrayOutput

type JobConfigAdBreakInput 

type JobConfigAdBreakInput interface {
	pulumi.Input

	ToJobConfigAdBreakOutput() JobConfigAdBreakOutput
	ToJobConfigAdBreakOutputWithContext(context.Context) JobConfigAdBreakOutput
}

JobConfigAdBreakInput is an input type that accepts JobConfigAdBreakArgs and JobConfigAdBreakOutput values. You can construct a concrete instance of `JobConfigAdBreakInput` via: 

JobConfigAdBreakArgs{...}

type JobConfigAdBreakOutput 

type JobConfigAdBreakOutput struct{ *pulumi.OutputState }

func (JobConfigAdBreakOutput) ElementType 

func (JobConfigAdBreakOutput) ElementType() reflect.Type

func (JobConfigAdBreakOutput) StartTimeOffset 

func (o JobConfigAdBreakOutput) StartTimeOffset() pulumi.StringPtrOutput

Start time in seconds for the ad break, relative to the output file timeline

func (JobConfigAdBreakOutput) ToJobConfigAdBreakOutput 

func (o JobConfigAdBreakOutput) ToJobConfigAdBreakOutput() JobConfigAdBreakOutput

func (JobConfigAdBreakOutput) ToJobConfigAdBreakOutputWithContext 

func (o JobConfigAdBreakOutput) ToJobConfigAdBreakOutputWithContext(ctx context.Context) JobConfigAdBreakOutput

type JobConfigArgs 

type JobConfigArgs struct {
	// Ad break.
	// Structure is documented below.
	AdBreaks JobConfigAdBreakArrayInput `pulumi:"adBreaks"`
	// List of input assets stored in Cloud Storage.
	// Structure is documented below.
	EditLists JobConfigEditListArrayInput `pulumi:"editLists"`
	// List of input assets stored in Cloud Storage.
	// Structure is documented below.
	ElementaryStreams JobConfigElementaryStreamArrayInput `pulumi:"elementaryStreams"`
	// List of encryption configurations for the content.
	// Structure is documented below.
	Encryptions JobConfigEncryptionArrayInput `pulumi:"encryptions"`
	// List of input assets stored in Cloud Storage.
	// Structure is documented below.
	Inputs JobConfigInputTypeArrayInput `pulumi:"inputs"`
	// Manifest configuration.
	// Structure is documented below.
	Manifests JobConfigManifestArrayInput `pulumi:"manifests"`
	// Multiplexing settings for output stream.
	// Structure is documented below.
	MuxStreams JobConfigMuxStreamArrayInput `pulumi:"muxStreams"`
	// Location of output file(s) in a Cloud Storage bucket.
	// Structure is documented below.
	Output JobConfigOutputTypePtrInput `pulumi:"output"`
	// List of overlays on the output video, in descending Z-order.
	// Structure is documented below.
	Overlays JobConfigOverlayArrayInput `pulumi:"overlays"`
	// Pub/Sub destination.
	// Structure is documented below.
	PubsubDestination JobConfigPubsubDestinationPtrInput `pulumi:"pubsubDestination"`
}

func (JobConfigArgs) ElementType 

func (JobConfigArgs) ElementType() reflect.Type

func (JobConfigArgs) ToJobConfigOutput 

func (i JobConfigArgs) ToJobConfigOutput() JobConfigOutput

func (JobConfigArgs) ToJobConfigOutputWithContext 

func (i JobConfigArgs) ToJobConfigOutputWithContext(ctx context.Context) JobConfigOutput

func (JobConfigArgs) ToJobConfigPtrOutput 

func (i JobConfigArgs) ToJobConfigPtrOutput() JobConfigPtrOutput

func (JobConfigArgs) ToJobConfigPtrOutputWithContext 

func (i JobConfigArgs) ToJobConfigPtrOutputWithContext(ctx context.Context) JobConfigPtrOutput

type JobConfigEditList 

type JobConfigEditList struct {
	// List of values identifying files that should be used in this atom.
	Inputs []string `pulumi:"inputs"`
	// A unique key for this atom.
	Key *string `pulumi:"key"`
	// Start time in seconds for the atom, relative to the input file timeline. The default is `0s`.
	StartTimeOffset *string `pulumi:"startTimeOffset"`
}

type JobConfigEditListArgs 

type JobConfigEditListArgs struct {
	// List of values identifying files that should be used in this atom.
	Inputs pulumi.StringArrayInput `pulumi:"inputs"`
	// A unique key for this atom.
	Key pulumi.StringPtrInput `pulumi:"key"`
	// Start time in seconds for the atom, relative to the input file timeline. The default is `0s`.
	StartTimeOffset pulumi.StringPtrInput `pulumi:"startTimeOffset"`
}

func (JobConfigEditListArgs) ElementType 

func (JobConfigEditListArgs) ElementType() reflect.Type

func (JobConfigEditListArgs) ToJobConfigEditListOutput 

func (i JobConfigEditListArgs) ToJobConfigEditListOutput() JobConfigEditListOutput

func (JobConfigEditListArgs) ToJobConfigEditListOutputWithContext 

func (i JobConfigEditListArgs) ToJobConfigEditListOutputWithContext(ctx context.Context) JobConfigEditListOutput

type JobConfigEditListArray 

type JobConfigEditListArray []JobConfigEditListInput

func (JobConfigEditListArray) ElementType 

func (JobConfigEditListArray) ElementType() reflect.Type

func (JobConfigEditListArray) ToJobConfigEditListArrayOutput 

func (i JobConfigEditListArray) ToJobConfigEditListArrayOutput() JobConfigEditListArrayOutput

func (JobConfigEditListArray) ToJobConfigEditListArrayOutputWithContext 

func (i JobConfigEditListArray) ToJobConfigEditListArrayOutputWithContext(ctx context.Context) JobConfigEditListArrayOutput

type JobConfigEditListArrayInput 

type JobConfigEditListArrayInput interface {
	pulumi.Input

	ToJobConfigEditListArrayOutput() JobConfigEditListArrayOutput
	ToJobConfigEditListArrayOutputWithContext(context.Context) JobConfigEditListArrayOutput
}

JobConfigEditListArrayInput is an input type that accepts JobConfigEditListArray and JobConfigEditListArrayOutput values. You can construct a concrete instance of `JobConfigEditListArrayInput` via: 

JobConfigEditListArray{ JobConfigEditListArgs{...} }

type JobConfigEditListArrayOutput 

type JobConfigEditListArrayOutput struct{ *pulumi.OutputState }

func (JobConfigEditListArrayOutput) ElementType 

func (JobConfigEditListArrayOutput) ElementType() reflect.Type

func (JobConfigEditListArrayOutput) Index 

func (o JobConfigEditListArrayOutput) Index(i pulumi.IntInput) JobConfigEditListOutput

func (JobConfigEditListArrayOutput) ToJobConfigEditListArrayOutput 

func (o JobConfigEditListArrayOutput) ToJobConfigEditListArrayOutput() JobConfigEditListArrayOutput

func (JobConfigEditListArrayOutput) ToJobConfigEditListArrayOutputWithContext 

func (o JobConfigEditListArrayOutput) ToJobConfigEditListArrayOutputWithContext(ctx context.Context) JobConfigEditListArrayOutput

type JobConfigEditListInput 

type JobConfigEditListInput interface {
	pulumi.Input

	ToJobConfigEditListOutput() JobConfigEditListOutput
	ToJobConfigEditListOutputWithContext(context.Context) JobConfigEditListOutput
}

JobConfigEditListInput is an input type that accepts JobConfigEditListArgs and JobConfigEditListOutput values. You can construct a concrete instance of `JobConfigEditListInput` via: 

JobConfigEditListArgs{...}

type JobConfigEditListOutput 

type JobConfigEditListOutput struct{ *pulumi.OutputState }

func (JobConfigEditListOutput) ElementType 

func (JobConfigEditListOutput) ElementType() reflect.Type

func (JobConfigEditListOutput) Inputs 

func (o JobConfigEditListOutput) Inputs() pulumi.StringArrayOutput

List of values identifying files that should be used in this atom.

func (JobConfigEditListOutput) Key 

func (o JobConfigEditListOutput) Key() pulumi.StringPtrOutput

A unique key for this atom.

func (JobConfigEditListOutput) StartTimeOffset 

func (o JobConfigEditListOutput) StartTimeOffset() pulumi.StringPtrOutput

Start time in seconds for the atom, relative to the input file timeline. The default is `0s`.

func (JobConfigEditListOutput) ToJobConfigEditListOutput 

func (o JobConfigEditListOutput) ToJobConfigEditListOutput() JobConfigEditListOutput

func (JobConfigEditListOutput) ToJobConfigEditListOutputWithContext 

func (o JobConfigEditListOutput) ToJobConfigEditListOutputWithContext(ctx context.Context) JobConfigEditListOutput

type JobConfigElementaryStream 

type JobConfigElementaryStream struct {
	// Encoding of an audio stream.
	// Structure is documented below.
	AudioStream *JobConfigElementaryStreamAudioStream `pulumi:"audioStream"`
	// A unique key for this atom.
	Key *string `pulumi:"key"`
	// Encoding of a video stream.
	// Structure is documented below.
	VideoStream *JobConfigElementaryStreamVideoStream `pulumi:"videoStream"`
}

type JobConfigElementaryStreamArgs 

type JobConfigElementaryStreamArgs struct {
	// Encoding of an audio stream.
	// Structure is documented below.
	AudioStream JobConfigElementaryStreamAudioStreamPtrInput `pulumi:"audioStream"`
	// A unique key for this atom.
	Key pulumi.StringPtrInput `pulumi:"key"`
	// Encoding of a video stream.
	// Structure is documented below.
	VideoStream JobConfigElementaryStreamVideoStreamPtrInput `pulumi:"videoStream"`
}

func (JobConfigElementaryStreamArgs) ElementType 

func (JobConfigElementaryStreamArgs) ElementType() reflect.Type

func (JobConfigElementaryStreamArgs) ToJobConfigElementaryStreamOutput 

func (i JobConfigElementaryStreamArgs) ToJobConfigElementaryStreamOutput() JobConfigElementaryStreamOutput

func (JobConfigElementaryStreamArgs) ToJobConfigElementaryStreamOutputWithContext 

func (i JobConfigElementaryStreamArgs) ToJobConfigElementaryStreamOutputWithContext(ctx context.Context) JobConfigElementaryStreamOutput

type JobConfigElementaryStreamArray 

type JobConfigElementaryStreamArray []JobConfigElementaryStreamInput

func (JobConfigElementaryStreamArray) ElementType 

func (JobConfigElementaryStreamArray) ElementType() reflect.Type

func (JobConfigElementaryStreamArray) ToJobConfigElementaryStreamArrayOutput 

func (i JobConfigElementaryStreamArray) ToJobConfigElementaryStreamArrayOutput() JobConfigElementaryStreamArrayOutput

func (JobConfigElementaryStreamArray) ToJobConfigElementaryStreamArrayOutputWithContext 

func (i JobConfigElementaryStreamArray) ToJobConfigElementaryStreamArrayOutputWithContext(ctx context.Context) JobConfigElementaryStreamArrayOutput

type JobConfigElementaryStreamArrayInput 

type JobConfigElementaryStreamArrayInput interface {
	pulumi.Input

	ToJobConfigElementaryStreamArrayOutput() JobConfigElementaryStreamArrayOutput
	ToJobConfigElementaryStreamArrayOutputWithContext(context.Context) JobConfigElementaryStreamArrayOutput
}

JobConfigElementaryStreamArrayInput is an input type that accepts JobConfigElementaryStreamArray and JobConfigElementaryStreamArrayOutput values. You can construct a concrete instance of `JobConfigElementaryStreamArrayInput` via: 

JobConfigElementaryStreamArray{ JobConfigElementaryStreamArgs{...} }

type JobConfigElementaryStreamArrayOutput 

type JobConfigElementaryStreamArrayOutput struct{ *pulumi.OutputState }

func (JobConfigElementaryStreamArrayOutput) ElementType 

func (JobConfigElementaryStreamArrayOutput) ElementType() reflect.Type

func (JobConfigElementaryStreamArrayOutput) Index 

func (o JobConfigElementaryStreamArrayOutput) Index(i pulumi.IntInput) JobConfigElementaryStreamOutput

func (JobConfigElementaryStreamArrayOutput) ToJobConfigElementaryStreamArrayOutput 

func (o JobConfigElementaryStreamArrayOutput) ToJobConfigElementaryStreamArrayOutput() JobConfigElementaryStreamArrayOutput

func (JobConfigElementaryStreamArrayOutput) ToJobConfigElementaryStreamArrayOutputWithContext 

func (o JobConfigElementaryStreamArrayOutput) ToJobConfigElementaryStreamArrayOutputWithContext(ctx context.Context) JobConfigElementaryStreamArrayOutput

type JobConfigElementaryStreamAudioStream 

type JobConfigElementaryStreamAudioStream struct {
	// Audio bitrate in bits per second.
	BitrateBps int `pulumi:"bitrateBps"`
	// Number of audio channels. The default is `2`.
	ChannelCount *int `pulumi:"channelCount"`
	// A list of channel names specifying layout of the audio channels. The default is ["fl", "fr"].
	ChannelLayouts []string `pulumi:"channelLayouts"`
	// The codec for this audio stream. The default is `aac`.
	Codec *string `pulumi:"codec"`
	// The audio sample rate in Hertz. The default is `48000`.
	SampleRateHertz *int `pulumi:"sampleRateHertz"`
}

type JobConfigElementaryStreamAudioStreamArgs 

type JobConfigElementaryStreamAudioStreamArgs struct {
	// Audio bitrate in bits per second.
	BitrateBps pulumi.IntInput `pulumi:"bitrateBps"`
	// Number of audio channels. The default is `2`.
	ChannelCount pulumi.IntPtrInput `pulumi:"channelCount"`
	// A list of channel names specifying layout of the audio channels. The default is ["fl", "fr"].
	ChannelLayouts pulumi.StringArrayInput `pulumi:"channelLayouts"`
	// The codec for this audio stream. The default is `aac`.
	Codec pulumi.StringPtrInput `pulumi:"codec"`
	// The audio sample rate in Hertz. The default is `48000`.
	SampleRateHertz pulumi.IntPtrInput `pulumi:"sampleRateHertz"`
}

func (JobConfigElementaryStreamAudioStreamArgs) ElementType 

func (JobConfigElementaryStreamAudioStreamArgs) ElementType() reflect.Type

func (JobConfigElementaryStreamAudioStreamArgs) ToJobConfigElementaryStreamAudioStreamOutput 

func (i JobConfigElementaryStreamAudioStreamArgs) ToJobConfigElementaryStreamAudioStreamOutput() JobConfigElementaryStreamAudioStreamOutput

func (JobConfigElementaryStreamAudioStreamArgs) ToJobConfigElementaryStreamAudioStreamOutputWithContext 

func (i JobConfigElementaryStreamAudioStreamArgs) ToJobConfigElementaryStreamAudioStreamOutputWithContext(ctx context.Context) JobConfigElementaryStreamAudioStreamOutput

func (JobConfigElementaryStreamAudioStreamArgs) ToJobConfigElementaryStreamAudioStreamPtrOutput 

func (i JobConfigElementaryStreamAudioStreamArgs) ToJobConfigElementaryStreamAudioStreamPtrOutput() JobConfigElementaryStreamAudioStreamPtrOutput

func (JobConfigElementaryStreamAudioStreamArgs) ToJobConfigElementaryStreamAudioStreamPtrOutputWithContext 

func (i JobConfigElementaryStreamAudioStreamArgs) ToJobConfigElementaryStreamAudioStreamPtrOutputWithContext(ctx context.Context) JobConfigElementaryStreamAudioStreamPtrOutput

type JobConfigElementaryStreamAudioStreamInput 

type JobConfigElementaryStreamAudioStreamInput interface {
	pulumi.Input

	ToJobConfigElementaryStreamAudioStreamOutput() JobConfigElementaryStreamAudioStreamOutput
	ToJobConfigElementaryStreamAudioStreamOutputWithContext(context.Context) JobConfigElementaryStreamAudioStreamOutput
}

JobConfigElementaryStreamAudioStreamInput is an input type that accepts JobConfigElementaryStreamAudioStreamArgs and JobConfigElementaryStreamAudioStreamOutput values. You can construct a concrete instance of `JobConfigElementaryStreamAudioStreamInput` via: 

JobConfigElementaryStreamAudioStreamArgs{...}

type JobConfigElementaryStreamAudioStreamOutput 

type JobConfigElementaryStreamAudioStreamOutput struct{ *pulumi.OutputState }

func (JobConfigElementaryStreamAudioStreamOutput) BitrateBps 

func (o JobConfigElementaryStreamAudioStreamOutput) BitrateBps() pulumi.IntOutput

Audio bitrate in bits per second.

func (JobConfigElementaryStreamAudioStreamOutput) ChannelCount 

func (o JobConfigElementaryStreamAudioStreamOutput) ChannelCount() pulumi.IntPtrOutput

Number of audio channels. The default is `2`.

func (JobConfigElementaryStreamAudioStreamOutput) ChannelLayouts 

func (o JobConfigElementaryStreamAudioStreamOutput) ChannelLayouts() pulumi.StringArrayOutput

A list of channel names specifying layout of the audio channels. The default is ["fl", "fr"].

func (JobConfigElementaryStreamAudioStreamOutput) Codec 

func (o JobConfigElementaryStreamAudioStreamOutput) Codec() pulumi.StringPtrOutput

The codec for this audio stream. The default is `aac`.

func (JobConfigElementaryStreamAudioStreamOutput) ElementType 

func (JobConfigElementaryStreamAudioStreamOutput) ElementType() reflect.Type

func (JobConfigElementaryStreamAudioStreamOutput) SampleRateHertz 

func (o JobConfigElementaryStreamAudioStreamOutput) SampleRateHertz() pulumi.IntPtrOutput

The audio sample rate in Hertz. The default is `48000`.

func (JobConfigElementaryStreamAudioStreamOutput) ToJobConfigElementaryStreamAudioStreamOutput 

func (o JobConfigElementaryStreamAudioStreamOutput) ToJobConfigElementaryStreamAudioStreamOutput() JobConfigElementaryStreamAudioStreamOutput

func (JobConfigElementaryStreamAudioStreamOutput) ToJobConfigElementaryStreamAudioStreamOutputWithContext 

func (o JobConfigElementaryStreamAudioStreamOutput) ToJobConfigElementaryStreamAudioStreamOutputWithContext(ctx context.Context) JobConfigElementaryStreamAudioStreamOutput

func (JobConfigElementaryStreamAudioStreamOutput) ToJobConfigElementaryStreamAudioStreamPtrOutput 

func (o JobConfigElementaryStreamAudioStreamOutput) ToJobConfigElementaryStreamAudioStreamPtrOutput() JobConfigElementaryStreamAudioStreamPtrOutput

func (JobConfigElementaryStreamAudioStreamOutput) ToJobConfigElementaryStreamAudioStreamPtrOutputWithContext 

func (o JobConfigElementaryStreamAudioStreamOutput) ToJobConfigElementaryStreamAudioStreamPtrOutputWithContext(ctx context.Context) JobConfigElementaryStreamAudioStreamPtrOutput

type JobConfigElementaryStreamAudioStreamPtrInput 

type JobConfigElementaryStreamAudioStreamPtrInput interface {
	pulumi.Input

	ToJobConfigElementaryStreamAudioStreamPtrOutput() JobConfigElementaryStreamAudioStreamPtrOutput
	ToJobConfigElementaryStreamAudioStreamPtrOutputWithContext(context.Context) JobConfigElementaryStreamAudioStreamPtrOutput
}

JobConfigElementaryStreamAudioStreamPtrInput is an input type that accepts JobConfigElementaryStreamAudioStreamArgs, JobConfigElementaryStreamAudioStreamPtr and JobConfigElementaryStreamAudioStreamPtrOutput values. You can construct a concrete instance of `JobConfigElementaryStreamAudioStreamPtrInput` via: 

        JobConfigElementaryStreamAudioStreamArgs{...}

or:

        nil

func JobConfigElementaryStreamAudioStreamPtr 

func JobConfigElementaryStreamAudioStreamPtr(v *JobConfigElementaryStreamAudioStreamArgs) JobConfigElementaryStreamAudioStreamPtrInput

type JobConfigElementaryStreamAudioStreamPtrOutput 

type JobConfigElementaryStreamAudioStreamPtrOutput struct{ *pulumi.OutputState }

func (JobConfigElementaryStreamAudioStreamPtrOutput) BitrateBps 

func (o JobConfigElementaryStreamAudioStreamPtrOutput) BitrateBps() pulumi.IntPtrOutput

Audio bitrate in bits per second.

func (JobConfigElementaryStreamAudioStreamPtrOutput) ChannelCount 

func (o JobConfigElementaryStreamAudioStreamPtrOutput) ChannelCount() pulumi.IntPtrOutput

Number of audio channels. The default is `2`.

func (JobConfigElementaryStreamAudioStreamPtrOutput) ChannelLayouts 

func (o JobConfigElementaryStreamAudioStreamPtrOutput) ChannelLayouts() pulumi.StringArrayOutput

A list of channel names specifying layout of the audio channels. The default is ["fl", "fr"].

func (JobConfigElementaryStreamAudioStreamPtrOutput) Codec 

func (o JobConfigElementaryStreamAudioStreamPtrOutput) Codec() pulumi.StringPtrOutput

The codec for this audio stream. The default is `aac`.

func (JobConfigElementaryStreamAudioStreamPtrOutput) Elem 

func (o JobConfigElementaryStreamAudioStreamPtrOutput) Elem() JobConfigElementaryStreamAudioStreamOutput

func (JobConfigElementaryStreamAudioStreamPtrOutput) ElementType 

func (JobConfigElementaryStreamAudioStreamPtrOutput) ElementType() reflect.Type

func (JobConfigElementaryStreamAudioStreamPtrOutput) SampleRateHertz 

func (o JobConfigElementaryStreamAudioStreamPtrOutput) SampleRateHertz() pulumi.IntPtrOutput

The audio sample rate in Hertz. The default is `48000`.

func (JobConfigElementaryStreamAudioStreamPtrOutput) ToJobConfigElementaryStreamAudioStreamPtrOutput 

func (o JobConfigElementaryStreamAudioStreamPtrOutput) ToJobConfigElementaryStreamAudioStreamPtrOutput() JobConfigElementaryStreamAudioStreamPtrOutput

func (JobConfigElementaryStreamAudioStreamPtrOutput) ToJobConfigElementaryStreamAudioStreamPtrOutputWithContext 

func (o JobConfigElementaryStreamAudioStreamPtrOutput) ToJobConfigElementaryStreamAudioStreamPtrOutputWithContext(ctx context.Context) JobConfigElementaryStreamAudioStreamPtrOutput

type JobConfigElementaryStreamInput 

type JobConfigElementaryStreamInput interface {
	pulumi.Input

	ToJobConfigElementaryStreamOutput() JobConfigElementaryStreamOutput
	ToJobConfigElementaryStreamOutputWithContext(context.Context) JobConfigElementaryStreamOutput
}

JobConfigElementaryStreamInput is an input type that accepts JobConfigElementaryStreamArgs and JobConfigElementaryStreamOutput values. You can construct a concrete instance of `JobConfigElementaryStreamInput` via: 

JobConfigElementaryStreamArgs{...}

type JobConfigElementaryStreamOutput 

type JobConfigElementaryStreamOutput struct{ *pulumi.OutputState }

func (JobConfigElementaryStreamOutput) AudioStream 

func (o JobConfigElementaryStreamOutput) AudioStream() JobConfigElementaryStreamAudioStreamPtrOutput

Encoding of an audio stream. Structure is documented below.

func (JobConfigElementaryStreamOutput) ElementType 

func (JobConfigElementaryStreamOutput) ElementType() reflect.Type

func (JobConfigElementaryStreamOutput) Key 

func (o JobConfigElementaryStreamOutput) Key() pulumi.StringPtrOutput

A unique key for this atom.

func (JobConfigElementaryStreamOutput) ToJobConfigElementaryStreamOutput 

func (o JobConfigElementaryStreamOutput) ToJobConfigElementaryStreamOutput() JobConfigElementaryStreamOutput

func (JobConfigElementaryStreamOutput) ToJobConfigElementaryStreamOutputWithContext 

func (o JobConfigElementaryStreamOutput) ToJobConfigElementaryStreamOutputWithContext(ctx context.Context) JobConfigElementaryStreamOutput

func (JobConfigElementaryStreamOutput) VideoStream 

func (o JobConfigElementaryStreamOutput) VideoStream() JobConfigElementaryStreamVideoStreamPtrOutput

Encoding of a video stream. Structure is documented below.

type JobConfigElementaryStreamVideoStream 

type JobConfigElementaryStreamVideoStream struct {
	// H264 codec settings
	// Structure is documented below.
	//
	// <a name="nestedH264"></a>The `h264` block supports:
	H264 *JobConfigElementaryStreamVideoStreamH264 `pulumi:"h264"`
}

type JobConfigElementaryStreamVideoStreamArgs 

type JobConfigElementaryStreamVideoStreamArgs struct {
	// H264 codec settings
	// Structure is documented below.
	//
	// <a name="nestedH264"></a>The `h264` block supports:
	H264 JobConfigElementaryStreamVideoStreamH264PtrInput `pulumi:"h264"`
}

func (JobConfigElementaryStreamVideoStreamArgs) ElementType 

func (JobConfigElementaryStreamVideoStreamArgs) ElementType() reflect.Type

func (JobConfigElementaryStreamVideoStreamArgs) ToJobConfigElementaryStreamVideoStreamOutput 

func (i JobConfigElementaryStreamVideoStreamArgs) ToJobConfigElementaryStreamVideoStreamOutput() JobConfigElementaryStreamVideoStreamOutput

func (JobConfigElementaryStreamVideoStreamArgs) ToJobConfigElementaryStreamVideoStreamOutputWithContext 

func (i JobConfigElementaryStreamVideoStreamArgs) ToJobConfigElementaryStreamVideoStreamOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamOutput

func (JobConfigElementaryStreamVideoStreamArgs) ToJobConfigElementaryStreamVideoStreamPtrOutput 

func (i JobConfigElementaryStreamVideoStreamArgs) ToJobConfigElementaryStreamVideoStreamPtrOutput() JobConfigElementaryStreamVideoStreamPtrOutput

func (JobConfigElementaryStreamVideoStreamArgs) ToJobConfigElementaryStreamVideoStreamPtrOutputWithContext 

func (i JobConfigElementaryStreamVideoStreamArgs) ToJobConfigElementaryStreamVideoStreamPtrOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamPtrOutput

type JobConfigElementaryStreamVideoStreamH264 

type JobConfigElementaryStreamVideoStreamH264 struct {
	// The video bitrate in bits per second.
	BitrateBps int `pulumi:"bitrateBps"`
	// Target CRF level. The default is '21'.
	CrfLevel *int `pulumi:"crfLevel"`
	// The entropy coder to use. The default is 'cabac'.
	EntropyCoder *string `pulumi:"entropyCoder"`
	// The target video frame rate in frames per second (FPS).
	FrameRate int `pulumi:"frameRate"`
	// Select the GOP size based on the specified duration. The default is '3s'.
	GopDuration *string `pulumi:"gopDuration"`
	// The height of the video in pixels.
	HeightPixels *int `pulumi:"heightPixels"`
	// HLG color format setting for H264.
	Hlg *JobConfigElementaryStreamVideoStreamH264Hlg `pulumi:"hlg"`
	// Pixel format to use. The default is 'yuv420p'.
	PixelFormat *string `pulumi:"pixelFormat"`
	// Enforces the specified codec preset. The default is 'veryfast'.
	Preset *string `pulumi:"preset"`
	// Enforces the specified codec profile.
	Profile *string `pulumi:"profile"`
	// Specify the mode. The default is 'vbr'.
	RateControlMode *string `pulumi:"rateControlMode"`
	// SDR color format setting for H264.
	Sdr *JobConfigElementaryStreamVideoStreamH264Sdr `pulumi:"sdr"`
	// Initial fullness of the Video Buffering Verifier (VBV) buffer in bits.
	VbvFullnessBits *int `pulumi:"vbvFullnessBits"`
	// Size of the Video Buffering Verifier (VBV) buffer in bits.
	VbvSizeBits *int `pulumi:"vbvSizeBits"`
	// The width of the video in pixels.
	WidthPixels *int `pulumi:"widthPixels"`
}

type JobConfigElementaryStreamVideoStreamH264Args 

type JobConfigElementaryStreamVideoStreamH264Args struct {
	// The video bitrate in bits per second.
	BitrateBps pulumi.IntInput `pulumi:"bitrateBps"`
	// Target CRF level. The default is '21'.
	CrfLevel pulumi.IntPtrInput `pulumi:"crfLevel"`
	// The entropy coder to use. The default is 'cabac'.
	EntropyCoder pulumi.StringPtrInput `pulumi:"entropyCoder"`
	// The target video frame rate in frames per second (FPS).
	FrameRate pulumi.IntInput `pulumi:"frameRate"`
	// Select the GOP size based on the specified duration. The default is '3s'.
	GopDuration pulumi.StringPtrInput `pulumi:"gopDuration"`
	// The height of the video in pixels.
	HeightPixels pulumi.IntPtrInput `pulumi:"heightPixels"`
	// HLG color format setting for H264.
	Hlg JobConfigElementaryStreamVideoStreamH264HlgPtrInput `pulumi:"hlg"`
	// Pixel format to use. The default is 'yuv420p'.
	PixelFormat pulumi.StringPtrInput `pulumi:"pixelFormat"`
	// Enforces the specified codec preset. The default is 'veryfast'.
	Preset pulumi.StringPtrInput `pulumi:"preset"`
	// Enforces the specified codec profile.
	Profile pulumi.StringPtrInput `pulumi:"profile"`
	// Specify the mode. The default is 'vbr'.
	RateControlMode pulumi.StringPtrInput `pulumi:"rateControlMode"`
	// SDR color format setting for H264.
	Sdr JobConfigElementaryStreamVideoStreamH264SdrPtrInput `pulumi:"sdr"`
	// Initial fullness of the Video Buffering Verifier (VBV) buffer in bits.
	VbvFullnessBits pulumi.IntPtrInput `pulumi:"vbvFullnessBits"`
	// Size of the Video Buffering Verifier (VBV) buffer in bits.
	VbvSizeBits pulumi.IntPtrInput `pulumi:"vbvSizeBits"`
	// The width of the video in pixels.
	WidthPixels pulumi.IntPtrInput `pulumi:"widthPixels"`
}

func (JobConfigElementaryStreamVideoStreamH264Args) ElementType 

func (JobConfigElementaryStreamVideoStreamH264Args) ElementType() reflect.Type

func (JobConfigElementaryStreamVideoStreamH264Args) ToJobConfigElementaryStreamVideoStreamH264Output 

func (i JobConfigElementaryStreamVideoStreamH264Args) ToJobConfigElementaryStreamVideoStreamH264Output() JobConfigElementaryStreamVideoStreamH264Output

func (JobConfigElementaryStreamVideoStreamH264Args) ToJobConfigElementaryStreamVideoStreamH264OutputWithContext 

func (i JobConfigElementaryStreamVideoStreamH264Args) ToJobConfigElementaryStreamVideoStreamH264OutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamH264Output

func (JobConfigElementaryStreamVideoStreamH264Args) ToJobConfigElementaryStreamVideoStreamH264PtrOutput 

func (i JobConfigElementaryStreamVideoStreamH264Args) ToJobConfigElementaryStreamVideoStreamH264PtrOutput() JobConfigElementaryStreamVideoStreamH264PtrOutput

func (JobConfigElementaryStreamVideoStreamH264Args) ToJobConfigElementaryStreamVideoStreamH264PtrOutputWithContext 

func (i JobConfigElementaryStreamVideoStreamH264Args) ToJobConfigElementaryStreamVideoStreamH264PtrOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamH264PtrOutput

type JobConfigElementaryStreamVideoStreamH264Hlg 

type JobConfigElementaryStreamVideoStreamH264Hlg struct {
}

type JobConfigElementaryStreamVideoStreamH264HlgArgs 

type JobConfigElementaryStreamVideoStreamH264HlgArgs struct {
}

func (JobConfigElementaryStreamVideoStreamH264HlgArgs) ElementType 

func (JobConfigElementaryStreamVideoStreamH264HlgArgs) ElementType() reflect.Type

func (JobConfigElementaryStreamVideoStreamH264HlgArgs) ToJobConfigElementaryStreamVideoStreamH264HlgOutput 

func (i JobConfigElementaryStreamVideoStreamH264HlgArgs) ToJobConfigElementaryStreamVideoStreamH264HlgOutput() JobConfigElementaryStreamVideoStreamH264HlgOutput

func (JobConfigElementaryStreamVideoStreamH264HlgArgs) ToJobConfigElementaryStreamVideoStreamH264HlgOutputWithContext 

func (i JobConfigElementaryStreamVideoStreamH264HlgArgs) ToJobConfigElementaryStreamVideoStreamH264HlgOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamH264HlgOutput

func (JobConfigElementaryStreamVideoStreamH264HlgArgs) ToJobConfigElementaryStreamVideoStreamH264HlgPtrOutput 

func (i JobConfigElementaryStreamVideoStreamH264HlgArgs) ToJobConfigElementaryStreamVideoStreamH264HlgPtrOutput() JobConfigElementaryStreamVideoStreamH264HlgPtrOutput

func (JobConfigElementaryStreamVideoStreamH264HlgArgs) ToJobConfigElementaryStreamVideoStreamH264HlgPtrOutputWithContext 

func (i JobConfigElementaryStreamVideoStreamH264HlgArgs) ToJobConfigElementaryStreamVideoStreamH264HlgPtrOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamH264HlgPtrOutput

type JobConfigElementaryStreamVideoStreamH264HlgInput 

type JobConfigElementaryStreamVideoStreamH264HlgInput interface {
	pulumi.Input

	ToJobConfigElementaryStreamVideoStreamH264HlgOutput() JobConfigElementaryStreamVideoStreamH264HlgOutput
	ToJobConfigElementaryStreamVideoStreamH264HlgOutputWithContext(context.Context) JobConfigElementaryStreamVideoStreamH264HlgOutput
}

JobConfigElementaryStreamVideoStreamH264HlgInput is an input type that accepts JobConfigElementaryStreamVideoStreamH264HlgArgs and JobConfigElementaryStreamVideoStreamH264HlgOutput values. You can construct a concrete instance of `JobConfigElementaryStreamVideoStreamH264HlgInput` via: 

JobConfigElementaryStreamVideoStreamH264HlgArgs{...}

type JobConfigElementaryStreamVideoStreamH264HlgOutput 

type JobConfigElementaryStreamVideoStreamH264HlgOutput struct{ *pulumi.OutputState }

func (JobConfigElementaryStreamVideoStreamH264HlgOutput) ElementType 

func (JobConfigElementaryStreamVideoStreamH264HlgOutput) ElementType() reflect.Type

func (JobConfigElementaryStreamVideoStreamH264HlgOutput) ToJobConfigElementaryStreamVideoStreamH264HlgOutput 

func (o JobConfigElementaryStreamVideoStreamH264HlgOutput) ToJobConfigElementaryStreamVideoStreamH264HlgOutput() JobConfigElementaryStreamVideoStreamH264HlgOutput

func (JobConfigElementaryStreamVideoStreamH264HlgOutput) ToJobConfigElementaryStreamVideoStreamH264HlgOutputWithContext 

func (o JobConfigElementaryStreamVideoStreamH264HlgOutput) ToJobConfigElementaryStreamVideoStreamH264HlgOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamH264HlgOutput

func (JobConfigElementaryStreamVideoStreamH264HlgOutput) ToJobConfigElementaryStreamVideoStreamH264HlgPtrOutput 

func (o JobConfigElementaryStreamVideoStreamH264HlgOutput) ToJobConfigElementaryStreamVideoStreamH264HlgPtrOutput() JobConfigElementaryStreamVideoStreamH264HlgPtrOutput

func (JobConfigElementaryStreamVideoStreamH264HlgOutput) ToJobConfigElementaryStreamVideoStreamH264HlgPtrOutputWithContext 

func (o JobConfigElementaryStreamVideoStreamH264HlgOutput) ToJobConfigElementaryStreamVideoStreamH264HlgPtrOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamH264HlgPtrOutput

type JobConfigElementaryStreamVideoStreamH264HlgPtrInput 

type JobConfigElementaryStreamVideoStreamH264HlgPtrInput interface {
	pulumi.Input

	ToJobConfigElementaryStreamVideoStreamH264HlgPtrOutput() JobConfigElementaryStreamVideoStreamH264HlgPtrOutput
	ToJobConfigElementaryStreamVideoStreamH264HlgPtrOutputWithContext(context.Context) JobConfigElementaryStreamVideoStreamH264HlgPtrOutput
}

JobConfigElementaryStreamVideoStreamH264HlgPtrInput is an input type that accepts JobConfigElementaryStreamVideoStreamH264HlgArgs, JobConfigElementaryStreamVideoStreamH264HlgPtr and JobConfigElementaryStreamVideoStreamH264HlgPtrOutput values. You can construct a concrete instance of `JobConfigElementaryStreamVideoStreamH264HlgPtrInput` via: 

        JobConfigElementaryStreamVideoStreamH264HlgArgs{...}

or:

        nil

func JobConfigElementaryStreamVideoStreamH264HlgPtr 

func JobConfigElementaryStreamVideoStreamH264HlgPtr(v *JobConfigElementaryStreamVideoStreamH264HlgArgs) JobConfigElementaryStreamVideoStreamH264HlgPtrInput

type JobConfigElementaryStreamVideoStreamH264HlgPtrOutput 

type JobConfigElementaryStreamVideoStreamH264HlgPtrOutput struct{ *pulumi.OutputState }

func (JobConfigElementaryStreamVideoStreamH264HlgPtrOutput) Elem 

func (o JobConfigElementaryStreamVideoStreamH264HlgPtrOutput) Elem() JobConfigElementaryStreamVideoStreamH264HlgOutput

func (JobConfigElementaryStreamVideoStreamH264HlgPtrOutput) ElementType 

func (JobConfigElementaryStreamVideoStreamH264HlgPtrOutput) ElementType() reflect.Type

func (JobConfigElementaryStreamVideoStreamH264HlgPtrOutput) ToJobConfigElementaryStreamVideoStreamH264HlgPtrOutput 

func (o JobConfigElementaryStreamVideoStreamH264HlgPtrOutput) ToJobConfigElementaryStreamVideoStreamH264HlgPtrOutput() JobConfigElementaryStreamVideoStreamH264HlgPtrOutput

func (JobConfigElementaryStreamVideoStreamH264HlgPtrOutput) ToJobConfigElementaryStreamVideoStreamH264HlgPtrOutputWithContext 

func (o JobConfigElementaryStreamVideoStreamH264HlgPtrOutput) ToJobConfigElementaryStreamVideoStreamH264HlgPtrOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamH264HlgPtrOutput

type JobConfigElementaryStreamVideoStreamH264Input 

type JobConfigElementaryStreamVideoStreamH264Input interface {
	pulumi.Input

	ToJobConfigElementaryStreamVideoStreamH264Output() JobConfigElementaryStreamVideoStreamH264Output
	ToJobConfigElementaryStreamVideoStreamH264OutputWithContext(context.Context) JobConfigElementaryStreamVideoStreamH264Output
}

JobConfigElementaryStreamVideoStreamH264Input is an input type that accepts JobConfigElementaryStreamVideoStreamH264Args and JobConfigElementaryStreamVideoStreamH264Output values. You can construct a concrete instance of `JobConfigElementaryStreamVideoStreamH264Input` via: 

JobConfigElementaryStreamVideoStreamH264Args{...}

type JobConfigElementaryStreamVideoStreamH264Output 

type JobConfigElementaryStreamVideoStreamH264Output struct{ *pulumi.OutputState }

func (JobConfigElementaryStreamVideoStreamH264Output) BitrateBps 

func (o JobConfigElementaryStreamVideoStreamH264Output) BitrateBps() pulumi.IntOutput

The video bitrate in bits per second.

func (JobConfigElementaryStreamVideoStreamH264Output) CrfLevel 

func (o JobConfigElementaryStreamVideoStreamH264Output) CrfLevel() pulumi.IntPtrOutput

Target CRF level. The default is '21'.

func (JobConfigElementaryStreamVideoStreamH264Output) ElementType 

func (JobConfigElementaryStreamVideoStreamH264Output) ElementType() reflect.Type

func (JobConfigElementaryStreamVideoStreamH264Output) EntropyCoder 

func (o JobConfigElementaryStreamVideoStreamH264Output) EntropyCoder() pulumi.StringPtrOutput

The entropy coder to use. The default is 'cabac'.

func (JobConfigElementaryStreamVideoStreamH264Output) FrameRate 

func (o JobConfigElementaryStreamVideoStreamH264Output) FrameRate() pulumi.IntOutput

The target video frame rate in frames per second (FPS).

func (JobConfigElementaryStreamVideoStreamH264Output) GopDuration 

func (o JobConfigElementaryStreamVideoStreamH264Output) GopDuration() pulumi.StringPtrOutput

Select the GOP size based on the specified duration. The default is '3s'.

func (JobConfigElementaryStreamVideoStreamH264Output) HeightPixels 

func (o JobConfigElementaryStreamVideoStreamH264Output) HeightPixels() pulumi.IntPtrOutput

The height of the video in pixels.

func (JobConfigElementaryStreamVideoStreamH264Output) Hlg 

func (o JobConfigElementaryStreamVideoStreamH264Output) Hlg() JobConfigElementaryStreamVideoStreamH264HlgPtrOutput

HLG color format setting for H264.

func (JobConfigElementaryStreamVideoStreamH264Output) PixelFormat 

func (o JobConfigElementaryStreamVideoStreamH264Output) PixelFormat() pulumi.StringPtrOutput

Pixel format to use. The default is 'yuv420p'.

func (JobConfigElementaryStreamVideoStreamH264Output) Preset 

func (o JobConfigElementaryStreamVideoStreamH264Output) Preset() pulumi.StringPtrOutput

Enforces the specified codec preset. The default is 'veryfast'.

func (JobConfigElementaryStreamVideoStreamH264Output) Profile 

func (o JobConfigElementaryStreamVideoStreamH264Output) Profile() pulumi.StringPtrOutput

Enforces the specified codec profile.

func (JobConfigElementaryStreamVideoStreamH264Output) RateControlMode 

func (o JobConfigElementaryStreamVideoStreamH264Output) RateControlMode() pulumi.StringPtrOutput

Specify the mode. The default is 'vbr'.

func (JobConfigElementaryStreamVideoStreamH264Output) Sdr 

func (o JobConfigElementaryStreamVideoStreamH264Output) Sdr() JobConfigElementaryStreamVideoStreamH264SdrPtrOutput

SDR color format setting for H264.

func (JobConfigElementaryStreamVideoStreamH264Output) ToJobConfigElementaryStreamVideoStreamH264Output 

func (o JobConfigElementaryStreamVideoStreamH264Output) ToJobConfigElementaryStreamVideoStreamH264Output() JobConfigElementaryStreamVideoStreamH264Output

func (JobConfigElementaryStreamVideoStreamH264Output) ToJobConfigElementaryStreamVideoStreamH264OutputWithContext 

func (o JobConfigElementaryStreamVideoStreamH264Output) ToJobConfigElementaryStreamVideoStreamH264OutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamH264Output

func (JobConfigElementaryStreamVideoStreamH264Output) ToJobConfigElementaryStreamVideoStreamH264PtrOutput 

func (o JobConfigElementaryStreamVideoStreamH264Output) ToJobConfigElementaryStreamVideoStreamH264PtrOutput() JobConfigElementaryStreamVideoStreamH264PtrOutput

func (JobConfigElementaryStreamVideoStreamH264Output) ToJobConfigElementaryStreamVideoStreamH264PtrOutputWithContext 

func (o JobConfigElementaryStreamVideoStreamH264Output) ToJobConfigElementaryStreamVideoStreamH264PtrOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamH264PtrOutput

func (JobConfigElementaryStreamVideoStreamH264Output) VbvFullnessBits 

func (o JobConfigElementaryStreamVideoStreamH264Output) VbvFullnessBits() pulumi.IntPtrOutput

Initial fullness of the Video Buffering Verifier (VBV) buffer in bits.

func (JobConfigElementaryStreamVideoStreamH264Output) VbvSizeBits 

func (o JobConfigElementaryStreamVideoStreamH264Output) VbvSizeBits() pulumi.IntPtrOutput

Size of the Video Buffering Verifier (VBV) buffer in bits.

func (JobConfigElementaryStreamVideoStreamH264Output) WidthPixels 

func (o JobConfigElementaryStreamVideoStreamH264Output) WidthPixels() pulumi.IntPtrOutput

The width of the video in pixels.

type JobConfigElementaryStreamVideoStreamH264PtrInput 

type JobConfigElementaryStreamVideoStreamH264PtrInput interface {
	pulumi.Input

	ToJobConfigElementaryStreamVideoStreamH264PtrOutput() JobConfigElementaryStreamVideoStreamH264PtrOutput
	ToJobConfigElementaryStreamVideoStreamH264PtrOutputWithContext(context.Context) JobConfigElementaryStreamVideoStreamH264PtrOutput
}

JobConfigElementaryStreamVideoStreamH264PtrInput is an input type that accepts JobConfigElementaryStreamVideoStreamH264Args, JobConfigElementaryStreamVideoStreamH264Ptr and JobConfigElementaryStreamVideoStreamH264PtrOutput values. You can construct a concrete instance of `JobConfigElementaryStreamVideoStreamH264PtrInput` via: 

        JobConfigElementaryStreamVideoStreamH264Args{...}

or:

        nil

func JobConfigElementaryStreamVideoStreamH264Ptr 

func JobConfigElementaryStreamVideoStreamH264Ptr(v *JobConfigElementaryStreamVideoStreamH264Args) JobConfigElementaryStreamVideoStreamH264PtrInput

type JobConfigElementaryStreamVideoStreamH264PtrOutput 

type JobConfigElementaryStreamVideoStreamH264PtrOutput struct{ *pulumi.OutputState }

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) BitrateBps 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) BitrateBps() pulumi.IntPtrOutput

The video bitrate in bits per second.

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) CrfLevel 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) CrfLevel() pulumi.IntPtrOutput

Target CRF level. The default is '21'.

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) Elem 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) Elem() JobConfigElementaryStreamVideoStreamH264Output

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) ElementType 

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) ElementType() reflect.Type

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) EntropyCoder 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) EntropyCoder() pulumi.StringPtrOutput

The entropy coder to use. The default is 'cabac'.

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) FrameRate 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) FrameRate() pulumi.IntPtrOutput

The target video frame rate in frames per second (FPS).

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) GopDuration 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) GopDuration() pulumi.StringPtrOutput

Select the GOP size based on the specified duration. The default is '3s'.

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) HeightPixels 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) HeightPixels() pulumi.IntPtrOutput

The height of the video in pixels.

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) Hlg 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) Hlg() JobConfigElementaryStreamVideoStreamH264HlgPtrOutput

HLG color format setting for H264.

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) PixelFormat 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) PixelFormat() pulumi.StringPtrOutput

Pixel format to use. The default is 'yuv420p'.

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) Preset 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) Preset() pulumi.StringPtrOutput

Enforces the specified codec preset. The default is 'veryfast'.

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) Profile 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) Profile() pulumi.StringPtrOutput

Enforces the specified codec profile.

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) RateControlMode 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) RateControlMode() pulumi.StringPtrOutput

Specify the mode. The default is 'vbr'.

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) Sdr 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) Sdr() JobConfigElementaryStreamVideoStreamH264SdrPtrOutput

SDR color format setting for H264.

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) ToJobConfigElementaryStreamVideoStreamH264PtrOutput 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) ToJobConfigElementaryStreamVideoStreamH264PtrOutput() JobConfigElementaryStreamVideoStreamH264PtrOutput

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) ToJobConfigElementaryStreamVideoStreamH264PtrOutputWithContext 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) ToJobConfigElementaryStreamVideoStreamH264PtrOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamH264PtrOutput

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) VbvFullnessBits 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) VbvFullnessBits() pulumi.IntPtrOutput

Initial fullness of the Video Buffering Verifier (VBV) buffer in bits.

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) VbvSizeBits 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) VbvSizeBits() pulumi.IntPtrOutput

Size of the Video Buffering Verifier (VBV) buffer in bits.

func (JobConfigElementaryStreamVideoStreamH264PtrOutput) WidthPixels 

func (o JobConfigElementaryStreamVideoStreamH264PtrOutput) WidthPixels() pulumi.IntPtrOutput

The width of the video in pixels.

type JobConfigElementaryStreamVideoStreamH264Sdr 

type JobConfigElementaryStreamVideoStreamH264Sdr struct {
}

type JobConfigElementaryStreamVideoStreamH264SdrArgs 

type JobConfigElementaryStreamVideoStreamH264SdrArgs struct {
}

func (JobConfigElementaryStreamVideoStreamH264SdrArgs) ElementType 

func (JobConfigElementaryStreamVideoStreamH264SdrArgs) ElementType() reflect.Type

func (JobConfigElementaryStreamVideoStreamH264SdrArgs) ToJobConfigElementaryStreamVideoStreamH264SdrOutput 

func (i JobConfigElementaryStreamVideoStreamH264SdrArgs) ToJobConfigElementaryStreamVideoStreamH264SdrOutput() JobConfigElementaryStreamVideoStreamH264SdrOutput

func (JobConfigElementaryStreamVideoStreamH264SdrArgs) ToJobConfigElementaryStreamVideoStreamH264SdrOutputWithContext 

func (i JobConfigElementaryStreamVideoStreamH264SdrArgs) ToJobConfigElementaryStreamVideoStreamH264SdrOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamH264SdrOutput

func (JobConfigElementaryStreamVideoStreamH264SdrArgs) ToJobConfigElementaryStreamVideoStreamH264SdrPtrOutput 

func (i JobConfigElementaryStreamVideoStreamH264SdrArgs) ToJobConfigElementaryStreamVideoStreamH264SdrPtrOutput() JobConfigElementaryStreamVideoStreamH264SdrPtrOutput

func (JobConfigElementaryStreamVideoStreamH264SdrArgs) ToJobConfigElementaryStreamVideoStreamH264SdrPtrOutputWithContext 

func (i JobConfigElementaryStreamVideoStreamH264SdrArgs) ToJobConfigElementaryStreamVideoStreamH264SdrPtrOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamH264SdrPtrOutput

type JobConfigElementaryStreamVideoStreamH264SdrInput 

type JobConfigElementaryStreamVideoStreamH264SdrInput interface {
	pulumi.Input

	ToJobConfigElementaryStreamVideoStreamH264SdrOutput() JobConfigElementaryStreamVideoStreamH264SdrOutput
	ToJobConfigElementaryStreamVideoStreamH264SdrOutputWithContext(context.Context) JobConfigElementaryStreamVideoStreamH264SdrOutput
}

JobConfigElementaryStreamVideoStreamH264SdrInput is an input type that accepts JobConfigElementaryStreamVideoStreamH264SdrArgs and JobConfigElementaryStreamVideoStreamH264SdrOutput values. You can construct a concrete instance of `JobConfigElementaryStreamVideoStreamH264SdrInput` via: 

JobConfigElementaryStreamVideoStreamH264SdrArgs{...}

type JobConfigElementaryStreamVideoStreamH264SdrOutput 

type JobConfigElementaryStreamVideoStreamH264SdrOutput struct{ *pulumi.OutputState }

func (JobConfigElementaryStreamVideoStreamH264SdrOutput) ElementType 

func (JobConfigElementaryStreamVideoStreamH264SdrOutput) ElementType() reflect.Type

func (JobConfigElementaryStreamVideoStreamH264SdrOutput) ToJobConfigElementaryStreamVideoStreamH264SdrOutput 

func (o JobConfigElementaryStreamVideoStreamH264SdrOutput) ToJobConfigElementaryStreamVideoStreamH264SdrOutput() JobConfigElementaryStreamVideoStreamH264SdrOutput

func (JobConfigElementaryStreamVideoStreamH264SdrOutput) ToJobConfigElementaryStreamVideoStreamH264SdrOutputWithContext 

func (o JobConfigElementaryStreamVideoStreamH264SdrOutput) ToJobConfigElementaryStreamVideoStreamH264SdrOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamH264SdrOutput

func (JobConfigElementaryStreamVideoStreamH264SdrOutput) ToJobConfigElementaryStreamVideoStreamH264SdrPtrOutput 

func (o JobConfigElementaryStreamVideoStreamH264SdrOutput) ToJobConfigElementaryStreamVideoStreamH264SdrPtrOutput() JobConfigElementaryStreamVideoStreamH264SdrPtrOutput

func (JobConfigElementaryStreamVideoStreamH264SdrOutput) ToJobConfigElementaryStreamVideoStreamH264SdrPtrOutputWithContext 

func (o JobConfigElementaryStreamVideoStreamH264SdrOutput) ToJobConfigElementaryStreamVideoStreamH264SdrPtrOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamH264SdrPtrOutput

type JobConfigElementaryStreamVideoStreamH264SdrPtrInput 

type JobConfigElementaryStreamVideoStreamH264SdrPtrInput interface {
	pulumi.Input

	ToJobConfigElementaryStreamVideoStreamH264SdrPtrOutput() JobConfigElementaryStreamVideoStreamH264SdrPtrOutput
	ToJobConfigElementaryStreamVideoStreamH264SdrPtrOutputWithContext(context.Context) JobConfigElementaryStreamVideoStreamH264SdrPtrOutput
}

JobConfigElementaryStreamVideoStreamH264SdrPtrInput is an input type that accepts JobConfigElementaryStreamVideoStreamH264SdrArgs, JobConfigElementaryStreamVideoStreamH264SdrPtr and JobConfigElementaryStreamVideoStreamH264SdrPtrOutput values. You can construct a concrete instance of `JobConfigElementaryStreamVideoStreamH264SdrPtrInput` via: 

        JobConfigElementaryStreamVideoStreamH264SdrArgs{...}

or:

        nil

func JobConfigElementaryStreamVideoStreamH264SdrPtr 

func JobConfigElementaryStreamVideoStreamH264SdrPtr(v *JobConfigElementaryStreamVideoStreamH264SdrArgs) JobConfigElementaryStreamVideoStreamH264SdrPtrInput

type JobConfigElementaryStreamVideoStreamH264SdrPtrOutput 

type JobConfigElementaryStreamVideoStreamH264SdrPtrOutput struct{ *pulumi.OutputState }

func (JobConfigElementaryStreamVideoStreamH264SdrPtrOutput) Elem 

func (o JobConfigElementaryStreamVideoStreamH264SdrPtrOutput) Elem() JobConfigElementaryStreamVideoStreamH264SdrOutput

func (JobConfigElementaryStreamVideoStreamH264SdrPtrOutput) ElementType 

func (JobConfigElementaryStreamVideoStreamH264SdrPtrOutput) ElementType() reflect.Type

func (JobConfigElementaryStreamVideoStreamH264SdrPtrOutput) ToJobConfigElementaryStreamVideoStreamH264SdrPtrOutput 

func (o JobConfigElementaryStreamVideoStreamH264SdrPtrOutput) ToJobConfigElementaryStreamVideoStreamH264SdrPtrOutput() JobConfigElementaryStreamVideoStreamH264SdrPtrOutput

func (JobConfigElementaryStreamVideoStreamH264SdrPtrOutput) ToJobConfigElementaryStreamVideoStreamH264SdrPtrOutputWithContext 

func (o JobConfigElementaryStreamVideoStreamH264SdrPtrOutput) ToJobConfigElementaryStreamVideoStreamH264SdrPtrOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamH264SdrPtrOutput

type JobConfigElementaryStreamVideoStreamInput 

type JobConfigElementaryStreamVideoStreamInput interface {
	pulumi.Input

	ToJobConfigElementaryStreamVideoStreamOutput() JobConfigElementaryStreamVideoStreamOutput
	ToJobConfigElementaryStreamVideoStreamOutputWithContext(context.Context) JobConfigElementaryStreamVideoStreamOutput
}

JobConfigElementaryStreamVideoStreamInput is an input type that accepts JobConfigElementaryStreamVideoStreamArgs and JobConfigElementaryStreamVideoStreamOutput values. You can construct a concrete instance of `JobConfigElementaryStreamVideoStreamInput` via: 

JobConfigElementaryStreamVideoStreamArgs{...}

type JobConfigElementaryStreamVideoStreamOutput 

type JobConfigElementaryStreamVideoStreamOutput struct{ *pulumi.OutputState }

func (JobConfigElementaryStreamVideoStreamOutput) ElementType 

func (JobConfigElementaryStreamVideoStreamOutput) ElementType() reflect.Type

func (JobConfigElementaryStreamVideoStreamOutput) H264 

func (o JobConfigElementaryStreamVideoStreamOutput) H264() JobConfigElementaryStreamVideoStreamH264PtrOutput

H264 codec settings Structure is documented below.

<a name="nestedH264"></a>The `h264` block supports:

func (JobConfigElementaryStreamVideoStreamOutput) ToJobConfigElementaryStreamVideoStreamOutput 

func (o JobConfigElementaryStreamVideoStreamOutput) ToJobConfigElementaryStreamVideoStreamOutput() JobConfigElementaryStreamVideoStreamOutput

func (JobConfigElementaryStreamVideoStreamOutput) ToJobConfigElementaryStreamVideoStreamOutputWithContext 

func (o JobConfigElementaryStreamVideoStreamOutput) ToJobConfigElementaryStreamVideoStreamOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamOutput

func (JobConfigElementaryStreamVideoStreamOutput) ToJobConfigElementaryStreamVideoStreamPtrOutput 

func (o JobConfigElementaryStreamVideoStreamOutput) ToJobConfigElementaryStreamVideoStreamPtrOutput() JobConfigElementaryStreamVideoStreamPtrOutput

func (JobConfigElementaryStreamVideoStreamOutput) ToJobConfigElementaryStreamVideoStreamPtrOutputWithContext 

func (o JobConfigElementaryStreamVideoStreamOutput) ToJobConfigElementaryStreamVideoStreamPtrOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamPtrOutput

type JobConfigElementaryStreamVideoStreamPtrInput 

type JobConfigElementaryStreamVideoStreamPtrInput interface {
	pulumi.Input

	ToJobConfigElementaryStreamVideoStreamPtrOutput() JobConfigElementaryStreamVideoStreamPtrOutput
	ToJobConfigElementaryStreamVideoStreamPtrOutputWithContext(context.Context) JobConfigElementaryStreamVideoStreamPtrOutput
}

JobConfigElementaryStreamVideoStreamPtrInput is an input type that accepts JobConfigElementaryStreamVideoStreamArgs, JobConfigElementaryStreamVideoStreamPtr and JobConfigElementaryStreamVideoStreamPtrOutput values. You can construct a concrete instance of `JobConfigElementaryStreamVideoStreamPtrInput` via: 

        JobConfigElementaryStreamVideoStreamArgs{...}

or:

        nil

func JobConfigElementaryStreamVideoStreamPtr 

func JobConfigElementaryStreamVideoStreamPtr(v *JobConfigElementaryStreamVideoStreamArgs) JobConfigElementaryStreamVideoStreamPtrInput

type JobConfigElementaryStreamVideoStreamPtrOutput 

type JobConfigElementaryStreamVideoStreamPtrOutput struct{ *pulumi.OutputState }

func (JobConfigElementaryStreamVideoStreamPtrOutput) Elem 

func (o JobConfigElementaryStreamVideoStreamPtrOutput) Elem() JobConfigElementaryStreamVideoStreamOutput

func (JobConfigElementaryStreamVideoStreamPtrOutput) ElementType 

func (JobConfigElementaryStreamVideoStreamPtrOutput) ElementType() reflect.Type

func (JobConfigElementaryStreamVideoStreamPtrOutput) H264 

func (o JobConfigElementaryStreamVideoStreamPtrOutput) H264() JobConfigElementaryStreamVideoStreamH264PtrOutput

H264 codec settings Structure is documented below.

<a name="nestedH264"></a>The `h264` block supports:

func (JobConfigElementaryStreamVideoStreamPtrOutput) ToJobConfigElementaryStreamVideoStreamPtrOutput 

func (o JobConfigElementaryStreamVideoStreamPtrOutput) ToJobConfigElementaryStreamVideoStreamPtrOutput() JobConfigElementaryStreamVideoStreamPtrOutput

func (JobConfigElementaryStreamVideoStreamPtrOutput) ToJobConfigElementaryStreamVideoStreamPtrOutputWithContext 

func (o JobConfigElementaryStreamVideoStreamPtrOutput) ToJobConfigElementaryStreamVideoStreamPtrOutputWithContext(ctx context.Context) JobConfigElementaryStreamVideoStreamPtrOutput

type JobConfigEncryption 

type JobConfigEncryption struct {
	// Configuration for AES-128 encryption.
	Aes128 *JobConfigEncryptionAes128 `pulumi:"aes128"`
	// DRM system(s) to use; at least one must be specified. If a DRM system is omitted, it is considered disabled.
	// Structure is documented below.
	DrmSystems *JobConfigEncryptionDrmSystems `pulumi:"drmSystems"`
	// Identifier for this set of encryption options.
	Id string `pulumi:"id"`
	// Configuration for MPEG Common Encryption (MPEG-CENC).
	// Structure is documented below.
	MpegCenc *JobConfigEncryptionMpegCenc `pulumi:"mpegCenc"`
	// Configuration for SAMPLE-AES encryption.
	SampleAes *JobConfigEncryptionSampleAes `pulumi:"sampleAes"`
	// Configuration for secrets stored in Google Secret Manager.
	// Structure is documented below.
	SecretManagerKeySource *JobConfigEncryptionSecretManagerKeySource `pulumi:"secretManagerKeySource"`
}

type JobConfigEncryptionAes128 

type JobConfigEncryptionAes128 struct {
}

type JobConfigEncryptionAes128Args 

type JobConfigEncryptionAes128Args struct {
}

func (JobConfigEncryptionAes128Args) ElementType 

func (JobConfigEncryptionAes128Args) ElementType() reflect.Type

func (JobConfigEncryptionAes128Args) ToJobConfigEncryptionAes128Output 

func (i JobConfigEncryptionAes128Args) ToJobConfigEncryptionAes128Output() JobConfigEncryptionAes128Output

func (JobConfigEncryptionAes128Args) ToJobConfigEncryptionAes128OutputWithContext 

func (i JobConfigEncryptionAes128Args) ToJobConfigEncryptionAes128OutputWithContext(ctx context.Context) JobConfigEncryptionAes128Output

func (JobConfigEncryptionAes128Args) ToJobConfigEncryptionAes128PtrOutput 

func (i JobConfigEncryptionAes128Args) ToJobConfigEncryptionAes128PtrOutput() JobConfigEncryptionAes128PtrOutput

func (JobConfigEncryptionAes128Args) ToJobConfigEncryptionAes128PtrOutputWithContext 

func (i JobConfigEncryptionAes128Args) ToJobConfigEncryptionAes128PtrOutputWithContext(ctx context.Context) JobConfigEncryptionAes128PtrOutput

type JobConfigEncryptionAes128Input 

type JobConfigEncryptionAes128Input interface {
	pulumi.Input

	ToJobConfigEncryptionAes128Output() JobConfigEncryptionAes128Output
	ToJobConfigEncryptionAes128OutputWithContext(context.Context) JobConfigEncryptionAes128Output
}

JobConfigEncryptionAes128Input is an input type that accepts JobConfigEncryptionAes128Args and JobConfigEncryptionAes128Output values. You can construct a concrete instance of `JobConfigEncryptionAes128Input` via: 

JobConfigEncryptionAes128Args{...}

type JobConfigEncryptionAes128Output 

type JobConfigEncryptionAes128Output struct{ *pulumi.OutputState }

func (JobConfigEncryptionAes128Output) ElementType 

func (JobConfigEncryptionAes128Output) ElementType() reflect.Type

func (JobConfigEncryptionAes128Output) ToJobConfigEncryptionAes128Output 

func (o JobConfigEncryptionAes128Output) ToJobConfigEncryptionAes128Output() JobConfigEncryptionAes128Output

func (JobConfigEncryptionAes128Output) ToJobConfigEncryptionAes128OutputWithContext 

func (o JobConfigEncryptionAes128Output) ToJobConfigEncryptionAes128OutputWithContext(ctx context.Context) JobConfigEncryptionAes128Output

func (JobConfigEncryptionAes128Output) ToJobConfigEncryptionAes128PtrOutput 

func (o JobConfigEncryptionAes128Output) ToJobConfigEncryptionAes128PtrOutput() JobConfigEncryptionAes128PtrOutput

func (JobConfigEncryptionAes128Output) ToJobConfigEncryptionAes128PtrOutputWithContext 

func (o JobConfigEncryptionAes128Output) ToJobConfigEncryptionAes128PtrOutputWithContext(ctx context.Context) JobConfigEncryptionAes128PtrOutput

type JobConfigEncryptionAes128PtrInput 

type JobConfigEncryptionAes128PtrInput interface {
	pulumi.Input

	ToJobConfigEncryptionAes128PtrOutput() JobConfigEncryptionAes128PtrOutput
	ToJobConfigEncryptionAes128PtrOutputWithContext(context.Context) JobConfigEncryptionAes128PtrOutput
}

JobConfigEncryptionAes128PtrInput is an input type that accepts JobConfigEncryptionAes128Args, JobConfigEncryptionAes128Ptr and JobConfigEncryptionAes128PtrOutput values. You can construct a concrete instance of `JobConfigEncryptionAes128PtrInput` via: 

        JobConfigEncryptionAes128Args{...}

or:

        nil

func JobConfigEncryptionAes128Ptr 

func JobConfigEncryptionAes128Ptr(v *JobConfigEncryptionAes128Args) JobConfigEncryptionAes128PtrInput

type JobConfigEncryptionAes128PtrOutput 

type JobConfigEncryptionAes128PtrOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionAes128PtrOutput) Elem 

func (o JobConfigEncryptionAes128PtrOutput) Elem() JobConfigEncryptionAes128Output

func (JobConfigEncryptionAes128PtrOutput) ElementType 

func (JobConfigEncryptionAes128PtrOutput) ElementType() reflect.Type

func (JobConfigEncryptionAes128PtrOutput) ToJobConfigEncryptionAes128PtrOutput 

func (o JobConfigEncryptionAes128PtrOutput) ToJobConfigEncryptionAes128PtrOutput() JobConfigEncryptionAes128PtrOutput

func (JobConfigEncryptionAes128PtrOutput) ToJobConfigEncryptionAes128PtrOutputWithContext 

func (o JobConfigEncryptionAes128PtrOutput) ToJobConfigEncryptionAes128PtrOutputWithContext(ctx context.Context) JobConfigEncryptionAes128PtrOutput

type JobConfigEncryptionArgs 

type JobConfigEncryptionArgs struct {
	// Configuration for AES-128 encryption.
	Aes128 JobConfigEncryptionAes128PtrInput `pulumi:"aes128"`
	// DRM system(s) to use; at least one must be specified. If a DRM system is omitted, it is considered disabled.
	// Structure is documented below.
	DrmSystems JobConfigEncryptionDrmSystemsPtrInput `pulumi:"drmSystems"`
	// Identifier for this set of encryption options.
	Id pulumi.StringInput `pulumi:"id"`
	// Configuration for MPEG Common Encryption (MPEG-CENC).
	// Structure is documented below.
	MpegCenc JobConfigEncryptionMpegCencPtrInput `pulumi:"mpegCenc"`
	// Configuration for SAMPLE-AES encryption.
	SampleAes JobConfigEncryptionSampleAesPtrInput `pulumi:"sampleAes"`
	// Configuration for secrets stored in Google Secret Manager.
	// Structure is documented below.
	SecretManagerKeySource JobConfigEncryptionSecretManagerKeySourcePtrInput `pulumi:"secretManagerKeySource"`
}

func (JobConfigEncryptionArgs) ElementType 

func (JobConfigEncryptionArgs) ElementType() reflect.Type

func (JobConfigEncryptionArgs) ToJobConfigEncryptionOutput 

func (i JobConfigEncryptionArgs) ToJobConfigEncryptionOutput() JobConfigEncryptionOutput

func (JobConfigEncryptionArgs) ToJobConfigEncryptionOutputWithContext 

func (i JobConfigEncryptionArgs) ToJobConfigEncryptionOutputWithContext(ctx context.Context) JobConfigEncryptionOutput

type JobConfigEncryptionArray 

type JobConfigEncryptionArray []JobConfigEncryptionInput

func (JobConfigEncryptionArray) ElementType 

func (JobConfigEncryptionArray) ElementType() reflect.Type

func (JobConfigEncryptionArray) ToJobConfigEncryptionArrayOutput 

func (i JobConfigEncryptionArray) ToJobConfigEncryptionArrayOutput() JobConfigEncryptionArrayOutput

func (JobConfigEncryptionArray) ToJobConfigEncryptionArrayOutputWithContext 

func (i JobConfigEncryptionArray) ToJobConfigEncryptionArrayOutputWithContext(ctx context.Context) JobConfigEncryptionArrayOutput

type JobConfigEncryptionArrayInput 

type JobConfigEncryptionArrayInput interface {
	pulumi.Input

	ToJobConfigEncryptionArrayOutput() JobConfigEncryptionArrayOutput
	ToJobConfigEncryptionArrayOutputWithContext(context.Context) JobConfigEncryptionArrayOutput
}

JobConfigEncryptionArrayInput is an input type that accepts JobConfigEncryptionArray and JobConfigEncryptionArrayOutput values. You can construct a concrete instance of `JobConfigEncryptionArrayInput` via: 

JobConfigEncryptionArray{ JobConfigEncryptionArgs{...} }

type JobConfigEncryptionArrayOutput 

type JobConfigEncryptionArrayOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionArrayOutput) ElementType 

func (JobConfigEncryptionArrayOutput) ElementType() reflect.Type

func (JobConfigEncryptionArrayOutput) Index 

func (o JobConfigEncryptionArrayOutput) Index(i pulumi.IntInput) JobConfigEncryptionOutput

func (JobConfigEncryptionArrayOutput) ToJobConfigEncryptionArrayOutput 

func (o JobConfigEncryptionArrayOutput) ToJobConfigEncryptionArrayOutput() JobConfigEncryptionArrayOutput

func (JobConfigEncryptionArrayOutput) ToJobConfigEncryptionArrayOutputWithContext 

func (o JobConfigEncryptionArrayOutput) ToJobConfigEncryptionArrayOutputWithContext(ctx context.Context) JobConfigEncryptionArrayOutput

type JobConfigEncryptionDrmSystems 

type JobConfigEncryptionDrmSystems struct {
	// Clearkey configuration.
	Clearkey *JobConfigEncryptionDrmSystemsClearkey `pulumi:"clearkey"`
	// Fairplay configuration.
	Fairplay *JobConfigEncryptionDrmSystemsFairplay `pulumi:"fairplay"`
	// Playready configuration.
	Playready *JobConfigEncryptionDrmSystemsPlayready `pulumi:"playready"`
	// Widevine configuration.
	Widevine *JobConfigEncryptionDrmSystemsWidevine `pulumi:"widevine"`
}

type JobConfigEncryptionDrmSystemsArgs 

type JobConfigEncryptionDrmSystemsArgs struct {
	// Clearkey configuration.
	Clearkey JobConfigEncryptionDrmSystemsClearkeyPtrInput `pulumi:"clearkey"`
	// Fairplay configuration.
	Fairplay JobConfigEncryptionDrmSystemsFairplayPtrInput `pulumi:"fairplay"`
	// Playready configuration.
	Playready JobConfigEncryptionDrmSystemsPlayreadyPtrInput `pulumi:"playready"`
	// Widevine configuration.
	Widevine JobConfigEncryptionDrmSystemsWidevinePtrInput `pulumi:"widevine"`
}

func (JobConfigEncryptionDrmSystemsArgs) ElementType 

func (JobConfigEncryptionDrmSystemsArgs) ElementType() reflect.Type

func (JobConfigEncryptionDrmSystemsArgs) ToJobConfigEncryptionDrmSystemsOutput 

func (i JobConfigEncryptionDrmSystemsArgs) ToJobConfigEncryptionDrmSystemsOutput() JobConfigEncryptionDrmSystemsOutput

func (JobConfigEncryptionDrmSystemsArgs) ToJobConfigEncryptionDrmSystemsOutputWithContext 

func (i JobConfigEncryptionDrmSystemsArgs) ToJobConfigEncryptionDrmSystemsOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsOutput

func (JobConfigEncryptionDrmSystemsArgs) ToJobConfigEncryptionDrmSystemsPtrOutput 

func (i JobConfigEncryptionDrmSystemsArgs) ToJobConfigEncryptionDrmSystemsPtrOutput() JobConfigEncryptionDrmSystemsPtrOutput

func (JobConfigEncryptionDrmSystemsArgs) ToJobConfigEncryptionDrmSystemsPtrOutputWithContext 

func (i JobConfigEncryptionDrmSystemsArgs) ToJobConfigEncryptionDrmSystemsPtrOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsPtrOutput

type JobConfigEncryptionDrmSystemsClearkey 

type JobConfigEncryptionDrmSystemsClearkey struct {
}

type JobConfigEncryptionDrmSystemsClearkeyArgs 

type JobConfigEncryptionDrmSystemsClearkeyArgs struct {
}

func (JobConfigEncryptionDrmSystemsClearkeyArgs) ElementType 

func (JobConfigEncryptionDrmSystemsClearkeyArgs) ElementType() reflect.Type

func (JobConfigEncryptionDrmSystemsClearkeyArgs) ToJobConfigEncryptionDrmSystemsClearkeyOutput 

func (i JobConfigEncryptionDrmSystemsClearkeyArgs) ToJobConfigEncryptionDrmSystemsClearkeyOutput() JobConfigEncryptionDrmSystemsClearkeyOutput

func (JobConfigEncryptionDrmSystemsClearkeyArgs) ToJobConfigEncryptionDrmSystemsClearkeyOutputWithContext 

func (i JobConfigEncryptionDrmSystemsClearkeyArgs) ToJobConfigEncryptionDrmSystemsClearkeyOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsClearkeyOutput

func (JobConfigEncryptionDrmSystemsClearkeyArgs) ToJobConfigEncryptionDrmSystemsClearkeyPtrOutput 

func (i JobConfigEncryptionDrmSystemsClearkeyArgs) ToJobConfigEncryptionDrmSystemsClearkeyPtrOutput() JobConfigEncryptionDrmSystemsClearkeyPtrOutput

func (JobConfigEncryptionDrmSystemsClearkeyArgs) ToJobConfigEncryptionDrmSystemsClearkeyPtrOutputWithContext 

func (i JobConfigEncryptionDrmSystemsClearkeyArgs) ToJobConfigEncryptionDrmSystemsClearkeyPtrOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsClearkeyPtrOutput

type JobConfigEncryptionDrmSystemsClearkeyInput 

type JobConfigEncryptionDrmSystemsClearkeyInput interface {
	pulumi.Input

	ToJobConfigEncryptionDrmSystemsClearkeyOutput() JobConfigEncryptionDrmSystemsClearkeyOutput
	ToJobConfigEncryptionDrmSystemsClearkeyOutputWithContext(context.Context) JobConfigEncryptionDrmSystemsClearkeyOutput
}

JobConfigEncryptionDrmSystemsClearkeyInput is an input type that accepts JobConfigEncryptionDrmSystemsClearkeyArgs and JobConfigEncryptionDrmSystemsClearkeyOutput values. You can construct a concrete instance of `JobConfigEncryptionDrmSystemsClearkeyInput` via: 

JobConfigEncryptionDrmSystemsClearkeyArgs{...}

type JobConfigEncryptionDrmSystemsClearkeyOutput 

type JobConfigEncryptionDrmSystemsClearkeyOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionDrmSystemsClearkeyOutput) ElementType 

func (JobConfigEncryptionDrmSystemsClearkeyOutput) ElementType() reflect.Type

func (JobConfigEncryptionDrmSystemsClearkeyOutput) ToJobConfigEncryptionDrmSystemsClearkeyOutput 

func (o JobConfigEncryptionDrmSystemsClearkeyOutput) ToJobConfigEncryptionDrmSystemsClearkeyOutput() JobConfigEncryptionDrmSystemsClearkeyOutput

func (JobConfigEncryptionDrmSystemsClearkeyOutput) ToJobConfigEncryptionDrmSystemsClearkeyOutputWithContext 

func (o JobConfigEncryptionDrmSystemsClearkeyOutput) ToJobConfigEncryptionDrmSystemsClearkeyOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsClearkeyOutput

func (JobConfigEncryptionDrmSystemsClearkeyOutput) ToJobConfigEncryptionDrmSystemsClearkeyPtrOutput 

func (o JobConfigEncryptionDrmSystemsClearkeyOutput) ToJobConfigEncryptionDrmSystemsClearkeyPtrOutput() JobConfigEncryptionDrmSystemsClearkeyPtrOutput

func (JobConfigEncryptionDrmSystemsClearkeyOutput) ToJobConfigEncryptionDrmSystemsClearkeyPtrOutputWithContext 

func (o JobConfigEncryptionDrmSystemsClearkeyOutput) ToJobConfigEncryptionDrmSystemsClearkeyPtrOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsClearkeyPtrOutput

type JobConfigEncryptionDrmSystemsClearkeyPtrInput 

type JobConfigEncryptionDrmSystemsClearkeyPtrInput interface {
	pulumi.Input

	ToJobConfigEncryptionDrmSystemsClearkeyPtrOutput() JobConfigEncryptionDrmSystemsClearkeyPtrOutput
	ToJobConfigEncryptionDrmSystemsClearkeyPtrOutputWithContext(context.Context) JobConfigEncryptionDrmSystemsClearkeyPtrOutput
}

JobConfigEncryptionDrmSystemsClearkeyPtrInput is an input type that accepts JobConfigEncryptionDrmSystemsClearkeyArgs, JobConfigEncryptionDrmSystemsClearkeyPtr and JobConfigEncryptionDrmSystemsClearkeyPtrOutput values. You can construct a concrete instance of `JobConfigEncryptionDrmSystemsClearkeyPtrInput` via: 

        JobConfigEncryptionDrmSystemsClearkeyArgs{...}

or:

        nil

func JobConfigEncryptionDrmSystemsClearkeyPtr 

func JobConfigEncryptionDrmSystemsClearkeyPtr(v *JobConfigEncryptionDrmSystemsClearkeyArgs) JobConfigEncryptionDrmSystemsClearkeyPtrInput

type JobConfigEncryptionDrmSystemsClearkeyPtrOutput 

type JobConfigEncryptionDrmSystemsClearkeyPtrOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionDrmSystemsClearkeyPtrOutput) Elem 

func (o JobConfigEncryptionDrmSystemsClearkeyPtrOutput) Elem() JobConfigEncryptionDrmSystemsClearkeyOutput

func (JobConfigEncryptionDrmSystemsClearkeyPtrOutput) ElementType 

func (JobConfigEncryptionDrmSystemsClearkeyPtrOutput) ElementType() reflect.Type

func (JobConfigEncryptionDrmSystemsClearkeyPtrOutput) ToJobConfigEncryptionDrmSystemsClearkeyPtrOutput 

func (o JobConfigEncryptionDrmSystemsClearkeyPtrOutput) ToJobConfigEncryptionDrmSystemsClearkeyPtrOutput() JobConfigEncryptionDrmSystemsClearkeyPtrOutput

func (JobConfigEncryptionDrmSystemsClearkeyPtrOutput) ToJobConfigEncryptionDrmSystemsClearkeyPtrOutputWithContext 

func (o JobConfigEncryptionDrmSystemsClearkeyPtrOutput) ToJobConfigEncryptionDrmSystemsClearkeyPtrOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsClearkeyPtrOutput

type JobConfigEncryptionDrmSystemsFairplay 

type JobConfigEncryptionDrmSystemsFairplay struct {
}

type JobConfigEncryptionDrmSystemsFairplayArgs 

type JobConfigEncryptionDrmSystemsFairplayArgs struct {
}

func (JobConfigEncryptionDrmSystemsFairplayArgs) ElementType 

func (JobConfigEncryptionDrmSystemsFairplayArgs) ElementType() reflect.Type

func (JobConfigEncryptionDrmSystemsFairplayArgs) ToJobConfigEncryptionDrmSystemsFairplayOutput 

func (i JobConfigEncryptionDrmSystemsFairplayArgs) ToJobConfigEncryptionDrmSystemsFairplayOutput() JobConfigEncryptionDrmSystemsFairplayOutput

func (JobConfigEncryptionDrmSystemsFairplayArgs) ToJobConfigEncryptionDrmSystemsFairplayOutputWithContext 

func (i JobConfigEncryptionDrmSystemsFairplayArgs) ToJobConfigEncryptionDrmSystemsFairplayOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsFairplayOutput

func (JobConfigEncryptionDrmSystemsFairplayArgs) ToJobConfigEncryptionDrmSystemsFairplayPtrOutput 

func (i JobConfigEncryptionDrmSystemsFairplayArgs) ToJobConfigEncryptionDrmSystemsFairplayPtrOutput() JobConfigEncryptionDrmSystemsFairplayPtrOutput

func (JobConfigEncryptionDrmSystemsFairplayArgs) ToJobConfigEncryptionDrmSystemsFairplayPtrOutputWithContext 

func (i JobConfigEncryptionDrmSystemsFairplayArgs) ToJobConfigEncryptionDrmSystemsFairplayPtrOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsFairplayPtrOutput

type JobConfigEncryptionDrmSystemsFairplayInput 

type JobConfigEncryptionDrmSystemsFairplayInput interface {
	pulumi.Input

	ToJobConfigEncryptionDrmSystemsFairplayOutput() JobConfigEncryptionDrmSystemsFairplayOutput
	ToJobConfigEncryptionDrmSystemsFairplayOutputWithContext(context.Context) JobConfigEncryptionDrmSystemsFairplayOutput
}

JobConfigEncryptionDrmSystemsFairplayInput is an input type that accepts JobConfigEncryptionDrmSystemsFairplayArgs and JobConfigEncryptionDrmSystemsFairplayOutput values. You can construct a concrete instance of `JobConfigEncryptionDrmSystemsFairplayInput` via: 

JobConfigEncryptionDrmSystemsFairplayArgs{...}

type JobConfigEncryptionDrmSystemsFairplayOutput 

type JobConfigEncryptionDrmSystemsFairplayOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionDrmSystemsFairplayOutput) ElementType 

func (JobConfigEncryptionDrmSystemsFairplayOutput) ElementType() reflect.Type

func (JobConfigEncryptionDrmSystemsFairplayOutput) ToJobConfigEncryptionDrmSystemsFairplayOutput 

func (o JobConfigEncryptionDrmSystemsFairplayOutput) ToJobConfigEncryptionDrmSystemsFairplayOutput() JobConfigEncryptionDrmSystemsFairplayOutput

func (JobConfigEncryptionDrmSystemsFairplayOutput) ToJobConfigEncryptionDrmSystemsFairplayOutputWithContext 

func (o JobConfigEncryptionDrmSystemsFairplayOutput) ToJobConfigEncryptionDrmSystemsFairplayOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsFairplayOutput

func (JobConfigEncryptionDrmSystemsFairplayOutput) ToJobConfigEncryptionDrmSystemsFairplayPtrOutput 

func (o JobConfigEncryptionDrmSystemsFairplayOutput) ToJobConfigEncryptionDrmSystemsFairplayPtrOutput() JobConfigEncryptionDrmSystemsFairplayPtrOutput

func (JobConfigEncryptionDrmSystemsFairplayOutput) ToJobConfigEncryptionDrmSystemsFairplayPtrOutputWithContext 

func (o JobConfigEncryptionDrmSystemsFairplayOutput) ToJobConfigEncryptionDrmSystemsFairplayPtrOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsFairplayPtrOutput

type JobConfigEncryptionDrmSystemsFairplayPtrInput 

type JobConfigEncryptionDrmSystemsFairplayPtrInput interface {
	pulumi.Input

	ToJobConfigEncryptionDrmSystemsFairplayPtrOutput() JobConfigEncryptionDrmSystemsFairplayPtrOutput
	ToJobConfigEncryptionDrmSystemsFairplayPtrOutputWithContext(context.Context) JobConfigEncryptionDrmSystemsFairplayPtrOutput
}

JobConfigEncryptionDrmSystemsFairplayPtrInput is an input type that accepts JobConfigEncryptionDrmSystemsFairplayArgs, JobConfigEncryptionDrmSystemsFairplayPtr and JobConfigEncryptionDrmSystemsFairplayPtrOutput values. You can construct a concrete instance of `JobConfigEncryptionDrmSystemsFairplayPtrInput` via: 

        JobConfigEncryptionDrmSystemsFairplayArgs{...}

or:

        nil

func JobConfigEncryptionDrmSystemsFairplayPtr 

func JobConfigEncryptionDrmSystemsFairplayPtr(v *JobConfigEncryptionDrmSystemsFairplayArgs) JobConfigEncryptionDrmSystemsFairplayPtrInput

type JobConfigEncryptionDrmSystemsFairplayPtrOutput 

type JobConfigEncryptionDrmSystemsFairplayPtrOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionDrmSystemsFairplayPtrOutput) Elem 

func (o JobConfigEncryptionDrmSystemsFairplayPtrOutput) Elem() JobConfigEncryptionDrmSystemsFairplayOutput

func (JobConfigEncryptionDrmSystemsFairplayPtrOutput) ElementType 

func (JobConfigEncryptionDrmSystemsFairplayPtrOutput) ElementType() reflect.Type

func (JobConfigEncryptionDrmSystemsFairplayPtrOutput) ToJobConfigEncryptionDrmSystemsFairplayPtrOutput 

func (o JobConfigEncryptionDrmSystemsFairplayPtrOutput) ToJobConfigEncryptionDrmSystemsFairplayPtrOutput() JobConfigEncryptionDrmSystemsFairplayPtrOutput

func (JobConfigEncryptionDrmSystemsFairplayPtrOutput) ToJobConfigEncryptionDrmSystemsFairplayPtrOutputWithContext 

func (o JobConfigEncryptionDrmSystemsFairplayPtrOutput) ToJobConfigEncryptionDrmSystemsFairplayPtrOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsFairplayPtrOutput

type JobConfigEncryptionDrmSystemsInput 

type JobConfigEncryptionDrmSystemsInput interface {
	pulumi.Input

	ToJobConfigEncryptionDrmSystemsOutput() JobConfigEncryptionDrmSystemsOutput
	ToJobConfigEncryptionDrmSystemsOutputWithContext(context.Context) JobConfigEncryptionDrmSystemsOutput
}

JobConfigEncryptionDrmSystemsInput is an input type that accepts JobConfigEncryptionDrmSystemsArgs and JobConfigEncryptionDrmSystemsOutput values. You can construct a concrete instance of `JobConfigEncryptionDrmSystemsInput` via: 

JobConfigEncryptionDrmSystemsArgs{...}

type JobConfigEncryptionDrmSystemsOutput 

type JobConfigEncryptionDrmSystemsOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionDrmSystemsOutput) Clearkey 

func (o JobConfigEncryptionDrmSystemsOutput) Clearkey() JobConfigEncryptionDrmSystemsClearkeyPtrOutput

Clearkey configuration.

func (JobConfigEncryptionDrmSystemsOutput) ElementType 

func (JobConfigEncryptionDrmSystemsOutput) ElementType() reflect.Type

func (JobConfigEncryptionDrmSystemsOutput) Fairplay 

func (o JobConfigEncryptionDrmSystemsOutput) Fairplay() JobConfigEncryptionDrmSystemsFairplayPtrOutput

Fairplay configuration.

func (JobConfigEncryptionDrmSystemsOutput) Playready 

func (o JobConfigEncryptionDrmSystemsOutput) Playready() JobConfigEncryptionDrmSystemsPlayreadyPtrOutput

Playready configuration.

func (JobConfigEncryptionDrmSystemsOutput) ToJobConfigEncryptionDrmSystemsOutput 

func (o JobConfigEncryptionDrmSystemsOutput) ToJobConfigEncryptionDrmSystemsOutput() JobConfigEncryptionDrmSystemsOutput

func (JobConfigEncryptionDrmSystemsOutput) ToJobConfigEncryptionDrmSystemsOutputWithContext 

func (o JobConfigEncryptionDrmSystemsOutput) ToJobConfigEncryptionDrmSystemsOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsOutput

func (JobConfigEncryptionDrmSystemsOutput) ToJobConfigEncryptionDrmSystemsPtrOutput 

func (o JobConfigEncryptionDrmSystemsOutput) ToJobConfigEncryptionDrmSystemsPtrOutput() JobConfigEncryptionDrmSystemsPtrOutput

func (JobConfigEncryptionDrmSystemsOutput) ToJobConfigEncryptionDrmSystemsPtrOutputWithContext 

func (o JobConfigEncryptionDrmSystemsOutput) ToJobConfigEncryptionDrmSystemsPtrOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsPtrOutput

func (JobConfigEncryptionDrmSystemsOutput) Widevine 

func (o JobConfigEncryptionDrmSystemsOutput) Widevine() JobConfigEncryptionDrmSystemsWidevinePtrOutput

Widevine configuration.

type JobConfigEncryptionDrmSystemsPlayready 

type JobConfigEncryptionDrmSystemsPlayready struct {
}

type JobConfigEncryptionDrmSystemsPlayreadyArgs 

type JobConfigEncryptionDrmSystemsPlayreadyArgs struct {
}

func (JobConfigEncryptionDrmSystemsPlayreadyArgs) ElementType 

func (JobConfigEncryptionDrmSystemsPlayreadyArgs) ElementType() reflect.Type

func (JobConfigEncryptionDrmSystemsPlayreadyArgs) ToJobConfigEncryptionDrmSystemsPlayreadyOutput 

func (i JobConfigEncryptionDrmSystemsPlayreadyArgs) ToJobConfigEncryptionDrmSystemsPlayreadyOutput() JobConfigEncryptionDrmSystemsPlayreadyOutput

func (JobConfigEncryptionDrmSystemsPlayreadyArgs) ToJobConfigEncryptionDrmSystemsPlayreadyOutputWithContext 

func (i JobConfigEncryptionDrmSystemsPlayreadyArgs) ToJobConfigEncryptionDrmSystemsPlayreadyOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsPlayreadyOutput

func (JobConfigEncryptionDrmSystemsPlayreadyArgs) ToJobConfigEncryptionDrmSystemsPlayreadyPtrOutput 

func (i JobConfigEncryptionDrmSystemsPlayreadyArgs) ToJobConfigEncryptionDrmSystemsPlayreadyPtrOutput() JobConfigEncryptionDrmSystemsPlayreadyPtrOutput

func (JobConfigEncryptionDrmSystemsPlayreadyArgs) ToJobConfigEncryptionDrmSystemsPlayreadyPtrOutputWithContext 

func (i JobConfigEncryptionDrmSystemsPlayreadyArgs) ToJobConfigEncryptionDrmSystemsPlayreadyPtrOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsPlayreadyPtrOutput

type JobConfigEncryptionDrmSystemsPlayreadyInput 

type JobConfigEncryptionDrmSystemsPlayreadyInput interface {
	pulumi.Input

	ToJobConfigEncryptionDrmSystemsPlayreadyOutput() JobConfigEncryptionDrmSystemsPlayreadyOutput
	ToJobConfigEncryptionDrmSystemsPlayreadyOutputWithContext(context.Context) JobConfigEncryptionDrmSystemsPlayreadyOutput
}

JobConfigEncryptionDrmSystemsPlayreadyInput is an input type that accepts JobConfigEncryptionDrmSystemsPlayreadyArgs and JobConfigEncryptionDrmSystemsPlayreadyOutput values. You can construct a concrete instance of `JobConfigEncryptionDrmSystemsPlayreadyInput` via: 

JobConfigEncryptionDrmSystemsPlayreadyArgs{...}

type JobConfigEncryptionDrmSystemsPlayreadyOutput 

type JobConfigEncryptionDrmSystemsPlayreadyOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionDrmSystemsPlayreadyOutput) ElementType 

func (JobConfigEncryptionDrmSystemsPlayreadyOutput) ElementType() reflect.Type

func (JobConfigEncryptionDrmSystemsPlayreadyOutput) ToJobConfigEncryptionDrmSystemsPlayreadyOutput 

func (o JobConfigEncryptionDrmSystemsPlayreadyOutput) ToJobConfigEncryptionDrmSystemsPlayreadyOutput() JobConfigEncryptionDrmSystemsPlayreadyOutput

func (JobConfigEncryptionDrmSystemsPlayreadyOutput) ToJobConfigEncryptionDrmSystemsPlayreadyOutputWithContext 

func (o JobConfigEncryptionDrmSystemsPlayreadyOutput) ToJobConfigEncryptionDrmSystemsPlayreadyOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsPlayreadyOutput

func (JobConfigEncryptionDrmSystemsPlayreadyOutput) ToJobConfigEncryptionDrmSystemsPlayreadyPtrOutput 

func (o JobConfigEncryptionDrmSystemsPlayreadyOutput) ToJobConfigEncryptionDrmSystemsPlayreadyPtrOutput() JobConfigEncryptionDrmSystemsPlayreadyPtrOutput

func (JobConfigEncryptionDrmSystemsPlayreadyOutput) ToJobConfigEncryptionDrmSystemsPlayreadyPtrOutputWithContext 

func (o JobConfigEncryptionDrmSystemsPlayreadyOutput) ToJobConfigEncryptionDrmSystemsPlayreadyPtrOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsPlayreadyPtrOutput

type JobConfigEncryptionDrmSystemsPlayreadyPtrInput 

type JobConfigEncryptionDrmSystemsPlayreadyPtrInput interface {
	pulumi.Input

	ToJobConfigEncryptionDrmSystemsPlayreadyPtrOutput() JobConfigEncryptionDrmSystemsPlayreadyPtrOutput
	ToJobConfigEncryptionDrmSystemsPlayreadyPtrOutputWithContext(context.Context) JobConfigEncryptionDrmSystemsPlayreadyPtrOutput
}

JobConfigEncryptionDrmSystemsPlayreadyPtrInput is an input type that accepts JobConfigEncryptionDrmSystemsPlayreadyArgs, JobConfigEncryptionDrmSystemsPlayreadyPtr and JobConfigEncryptionDrmSystemsPlayreadyPtrOutput values. You can construct a concrete instance of `JobConfigEncryptionDrmSystemsPlayreadyPtrInput` via: 

        JobConfigEncryptionDrmSystemsPlayreadyArgs{...}

or:

        nil

func JobConfigEncryptionDrmSystemsPlayreadyPtr 

func JobConfigEncryptionDrmSystemsPlayreadyPtr(v *JobConfigEncryptionDrmSystemsPlayreadyArgs) JobConfigEncryptionDrmSystemsPlayreadyPtrInput

type JobConfigEncryptionDrmSystemsPlayreadyPtrOutput 

type JobConfigEncryptionDrmSystemsPlayreadyPtrOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionDrmSystemsPlayreadyPtrOutput) Elem 

func (o JobConfigEncryptionDrmSystemsPlayreadyPtrOutput) Elem() JobConfigEncryptionDrmSystemsPlayreadyOutput

func (JobConfigEncryptionDrmSystemsPlayreadyPtrOutput) ElementType 

func (JobConfigEncryptionDrmSystemsPlayreadyPtrOutput) ElementType() reflect.Type

func (JobConfigEncryptionDrmSystemsPlayreadyPtrOutput) ToJobConfigEncryptionDrmSystemsPlayreadyPtrOutput 

func (o JobConfigEncryptionDrmSystemsPlayreadyPtrOutput) ToJobConfigEncryptionDrmSystemsPlayreadyPtrOutput() JobConfigEncryptionDrmSystemsPlayreadyPtrOutput

func (JobConfigEncryptionDrmSystemsPlayreadyPtrOutput) ToJobConfigEncryptionDrmSystemsPlayreadyPtrOutputWithContext 

func (o JobConfigEncryptionDrmSystemsPlayreadyPtrOutput) ToJobConfigEncryptionDrmSystemsPlayreadyPtrOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsPlayreadyPtrOutput

type JobConfigEncryptionDrmSystemsPtrInput 

type JobConfigEncryptionDrmSystemsPtrInput interface {
	pulumi.Input

	ToJobConfigEncryptionDrmSystemsPtrOutput() JobConfigEncryptionDrmSystemsPtrOutput
	ToJobConfigEncryptionDrmSystemsPtrOutputWithContext(context.Context) JobConfigEncryptionDrmSystemsPtrOutput
}

JobConfigEncryptionDrmSystemsPtrInput is an input type that accepts JobConfigEncryptionDrmSystemsArgs, JobConfigEncryptionDrmSystemsPtr and JobConfigEncryptionDrmSystemsPtrOutput values. You can construct a concrete instance of `JobConfigEncryptionDrmSystemsPtrInput` via: 

        JobConfigEncryptionDrmSystemsArgs{...}

or:

        nil

func JobConfigEncryptionDrmSystemsPtr 

func JobConfigEncryptionDrmSystemsPtr(v *JobConfigEncryptionDrmSystemsArgs) JobConfigEncryptionDrmSystemsPtrInput

type JobConfigEncryptionDrmSystemsPtrOutput 

type JobConfigEncryptionDrmSystemsPtrOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionDrmSystemsPtrOutput) Clearkey 

func (o JobConfigEncryptionDrmSystemsPtrOutput) Clearkey() JobConfigEncryptionDrmSystemsClearkeyPtrOutput

Clearkey configuration.

func (JobConfigEncryptionDrmSystemsPtrOutput) Elem 

func (o JobConfigEncryptionDrmSystemsPtrOutput) Elem() JobConfigEncryptionDrmSystemsOutput

func (JobConfigEncryptionDrmSystemsPtrOutput) ElementType 

func (JobConfigEncryptionDrmSystemsPtrOutput) ElementType() reflect.Type

func (JobConfigEncryptionDrmSystemsPtrOutput) Fairplay 

func (o JobConfigEncryptionDrmSystemsPtrOutput) Fairplay() JobConfigEncryptionDrmSystemsFairplayPtrOutput

Fairplay configuration.

func (JobConfigEncryptionDrmSystemsPtrOutput) Playready 

func (o JobConfigEncryptionDrmSystemsPtrOutput) Playready() JobConfigEncryptionDrmSystemsPlayreadyPtrOutput

Playready configuration.

func (JobConfigEncryptionDrmSystemsPtrOutput) ToJobConfigEncryptionDrmSystemsPtrOutput 

func (o JobConfigEncryptionDrmSystemsPtrOutput) ToJobConfigEncryptionDrmSystemsPtrOutput() JobConfigEncryptionDrmSystemsPtrOutput

func (JobConfigEncryptionDrmSystemsPtrOutput) ToJobConfigEncryptionDrmSystemsPtrOutputWithContext 

func (o JobConfigEncryptionDrmSystemsPtrOutput) ToJobConfigEncryptionDrmSystemsPtrOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsPtrOutput

func (JobConfigEncryptionDrmSystemsPtrOutput) Widevine 

func (o JobConfigEncryptionDrmSystemsPtrOutput) Widevine() JobConfigEncryptionDrmSystemsWidevinePtrOutput

Widevine configuration.

type JobConfigEncryptionDrmSystemsWidevine 

type JobConfigEncryptionDrmSystemsWidevine struct {
}

type JobConfigEncryptionDrmSystemsWidevineArgs 

type JobConfigEncryptionDrmSystemsWidevineArgs struct {
}

func (JobConfigEncryptionDrmSystemsWidevineArgs) ElementType 

func (JobConfigEncryptionDrmSystemsWidevineArgs) ElementType() reflect.Type

func (JobConfigEncryptionDrmSystemsWidevineArgs) ToJobConfigEncryptionDrmSystemsWidevineOutput 

func (i JobConfigEncryptionDrmSystemsWidevineArgs) ToJobConfigEncryptionDrmSystemsWidevineOutput() JobConfigEncryptionDrmSystemsWidevineOutput

func (JobConfigEncryptionDrmSystemsWidevineArgs) ToJobConfigEncryptionDrmSystemsWidevineOutputWithContext 

func (i JobConfigEncryptionDrmSystemsWidevineArgs) ToJobConfigEncryptionDrmSystemsWidevineOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsWidevineOutput

func (JobConfigEncryptionDrmSystemsWidevineArgs) ToJobConfigEncryptionDrmSystemsWidevinePtrOutput 

func (i JobConfigEncryptionDrmSystemsWidevineArgs) ToJobConfigEncryptionDrmSystemsWidevinePtrOutput() JobConfigEncryptionDrmSystemsWidevinePtrOutput

func (JobConfigEncryptionDrmSystemsWidevineArgs) ToJobConfigEncryptionDrmSystemsWidevinePtrOutputWithContext 

func (i JobConfigEncryptionDrmSystemsWidevineArgs) ToJobConfigEncryptionDrmSystemsWidevinePtrOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsWidevinePtrOutput

type JobConfigEncryptionDrmSystemsWidevineInput 

type JobConfigEncryptionDrmSystemsWidevineInput interface {
	pulumi.Input

	ToJobConfigEncryptionDrmSystemsWidevineOutput() JobConfigEncryptionDrmSystemsWidevineOutput
	ToJobConfigEncryptionDrmSystemsWidevineOutputWithContext(context.Context) JobConfigEncryptionDrmSystemsWidevineOutput
}

JobConfigEncryptionDrmSystemsWidevineInput is an input type that accepts JobConfigEncryptionDrmSystemsWidevineArgs and JobConfigEncryptionDrmSystemsWidevineOutput values. You can construct a concrete instance of `JobConfigEncryptionDrmSystemsWidevineInput` via: 

JobConfigEncryptionDrmSystemsWidevineArgs{...}

type JobConfigEncryptionDrmSystemsWidevineOutput 

type JobConfigEncryptionDrmSystemsWidevineOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionDrmSystemsWidevineOutput) ElementType 

func (JobConfigEncryptionDrmSystemsWidevineOutput) ElementType() reflect.Type

func (JobConfigEncryptionDrmSystemsWidevineOutput) ToJobConfigEncryptionDrmSystemsWidevineOutput 

func (o JobConfigEncryptionDrmSystemsWidevineOutput) ToJobConfigEncryptionDrmSystemsWidevineOutput() JobConfigEncryptionDrmSystemsWidevineOutput

func (JobConfigEncryptionDrmSystemsWidevineOutput) ToJobConfigEncryptionDrmSystemsWidevineOutputWithContext 

func (o JobConfigEncryptionDrmSystemsWidevineOutput) ToJobConfigEncryptionDrmSystemsWidevineOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsWidevineOutput

func (JobConfigEncryptionDrmSystemsWidevineOutput) ToJobConfigEncryptionDrmSystemsWidevinePtrOutput 

func (o JobConfigEncryptionDrmSystemsWidevineOutput) ToJobConfigEncryptionDrmSystemsWidevinePtrOutput() JobConfigEncryptionDrmSystemsWidevinePtrOutput

func (JobConfigEncryptionDrmSystemsWidevineOutput) ToJobConfigEncryptionDrmSystemsWidevinePtrOutputWithContext 

func (o JobConfigEncryptionDrmSystemsWidevineOutput) ToJobConfigEncryptionDrmSystemsWidevinePtrOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsWidevinePtrOutput

type JobConfigEncryptionDrmSystemsWidevinePtrInput 

type JobConfigEncryptionDrmSystemsWidevinePtrInput interface {
	pulumi.Input

	ToJobConfigEncryptionDrmSystemsWidevinePtrOutput() JobConfigEncryptionDrmSystemsWidevinePtrOutput
	ToJobConfigEncryptionDrmSystemsWidevinePtrOutputWithContext(context.Context) JobConfigEncryptionDrmSystemsWidevinePtrOutput
}

JobConfigEncryptionDrmSystemsWidevinePtrInput is an input type that accepts JobConfigEncryptionDrmSystemsWidevineArgs, JobConfigEncryptionDrmSystemsWidevinePtr and JobConfigEncryptionDrmSystemsWidevinePtrOutput values. You can construct a concrete instance of `JobConfigEncryptionDrmSystemsWidevinePtrInput` via: 

        JobConfigEncryptionDrmSystemsWidevineArgs{...}

or:

        nil

func JobConfigEncryptionDrmSystemsWidevinePtr 

func JobConfigEncryptionDrmSystemsWidevinePtr(v *JobConfigEncryptionDrmSystemsWidevineArgs) JobConfigEncryptionDrmSystemsWidevinePtrInput

type JobConfigEncryptionDrmSystemsWidevinePtrOutput 

type JobConfigEncryptionDrmSystemsWidevinePtrOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionDrmSystemsWidevinePtrOutput) Elem 

func (o JobConfigEncryptionDrmSystemsWidevinePtrOutput) Elem() JobConfigEncryptionDrmSystemsWidevineOutput

func (JobConfigEncryptionDrmSystemsWidevinePtrOutput) ElementType 

func (JobConfigEncryptionDrmSystemsWidevinePtrOutput) ElementType() reflect.Type

func (JobConfigEncryptionDrmSystemsWidevinePtrOutput) ToJobConfigEncryptionDrmSystemsWidevinePtrOutput 

func (o JobConfigEncryptionDrmSystemsWidevinePtrOutput) ToJobConfigEncryptionDrmSystemsWidevinePtrOutput() JobConfigEncryptionDrmSystemsWidevinePtrOutput

func (JobConfigEncryptionDrmSystemsWidevinePtrOutput) ToJobConfigEncryptionDrmSystemsWidevinePtrOutputWithContext 

func (o JobConfigEncryptionDrmSystemsWidevinePtrOutput) ToJobConfigEncryptionDrmSystemsWidevinePtrOutputWithContext(ctx context.Context) JobConfigEncryptionDrmSystemsWidevinePtrOutput

type JobConfigEncryptionInput 

type JobConfigEncryptionInput interface {
	pulumi.Input

	ToJobConfigEncryptionOutput() JobConfigEncryptionOutput
	ToJobConfigEncryptionOutputWithContext(context.Context) JobConfigEncryptionOutput
}

JobConfigEncryptionInput is an input type that accepts JobConfigEncryptionArgs and JobConfigEncryptionOutput values. You can construct a concrete instance of `JobConfigEncryptionInput` via: 

JobConfigEncryptionArgs{...}

type JobConfigEncryptionMpegCenc 

type JobConfigEncryptionMpegCenc struct {
	// Specify the encryption scheme.
	Scheme string `pulumi:"scheme"`
}

type JobConfigEncryptionMpegCencArgs 

type JobConfigEncryptionMpegCencArgs struct {
	// Specify the encryption scheme.
	Scheme pulumi.StringInput `pulumi:"scheme"`
}

func (JobConfigEncryptionMpegCencArgs) ElementType 

func (JobConfigEncryptionMpegCencArgs) ElementType() reflect.Type

func (JobConfigEncryptionMpegCencArgs) ToJobConfigEncryptionMpegCencOutput 

func (i JobConfigEncryptionMpegCencArgs) ToJobConfigEncryptionMpegCencOutput() JobConfigEncryptionMpegCencOutput

func (JobConfigEncryptionMpegCencArgs) ToJobConfigEncryptionMpegCencOutputWithContext 

func (i JobConfigEncryptionMpegCencArgs) ToJobConfigEncryptionMpegCencOutputWithContext(ctx context.Context) JobConfigEncryptionMpegCencOutput

func (JobConfigEncryptionMpegCencArgs) ToJobConfigEncryptionMpegCencPtrOutput 

func (i JobConfigEncryptionMpegCencArgs) ToJobConfigEncryptionMpegCencPtrOutput() JobConfigEncryptionMpegCencPtrOutput

func (JobConfigEncryptionMpegCencArgs) ToJobConfigEncryptionMpegCencPtrOutputWithContext 

func (i JobConfigEncryptionMpegCencArgs) ToJobConfigEncryptionMpegCencPtrOutputWithContext(ctx context.Context) JobConfigEncryptionMpegCencPtrOutput

type JobConfigEncryptionMpegCencInput 

type JobConfigEncryptionMpegCencInput interface {
	pulumi.Input

	ToJobConfigEncryptionMpegCencOutput() JobConfigEncryptionMpegCencOutput
	ToJobConfigEncryptionMpegCencOutputWithContext(context.Context) JobConfigEncryptionMpegCencOutput
}

JobConfigEncryptionMpegCencInput is an input type that accepts JobConfigEncryptionMpegCencArgs and JobConfigEncryptionMpegCencOutput values. You can construct a concrete instance of `JobConfigEncryptionMpegCencInput` via: 

JobConfigEncryptionMpegCencArgs{...}

type JobConfigEncryptionMpegCencOutput 

type JobConfigEncryptionMpegCencOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionMpegCencOutput) ElementType 

func (JobConfigEncryptionMpegCencOutput) ElementType() reflect.Type

func (JobConfigEncryptionMpegCencOutput) Scheme 

func (o JobConfigEncryptionMpegCencOutput) Scheme() pulumi.StringOutput

Specify the encryption scheme.

func (JobConfigEncryptionMpegCencOutput) ToJobConfigEncryptionMpegCencOutput 

func (o JobConfigEncryptionMpegCencOutput) ToJobConfigEncryptionMpegCencOutput() JobConfigEncryptionMpegCencOutput

func (JobConfigEncryptionMpegCencOutput) ToJobConfigEncryptionMpegCencOutputWithContext 

func (o JobConfigEncryptionMpegCencOutput) ToJobConfigEncryptionMpegCencOutputWithContext(ctx context.Context) JobConfigEncryptionMpegCencOutput

func (JobConfigEncryptionMpegCencOutput) ToJobConfigEncryptionMpegCencPtrOutput 

func (o JobConfigEncryptionMpegCencOutput) ToJobConfigEncryptionMpegCencPtrOutput() JobConfigEncryptionMpegCencPtrOutput

func (JobConfigEncryptionMpegCencOutput) ToJobConfigEncryptionMpegCencPtrOutputWithContext 

func (o JobConfigEncryptionMpegCencOutput) ToJobConfigEncryptionMpegCencPtrOutputWithContext(ctx context.Context) JobConfigEncryptionMpegCencPtrOutput

type JobConfigEncryptionMpegCencPtrInput 

type JobConfigEncryptionMpegCencPtrInput interface {
	pulumi.Input

	ToJobConfigEncryptionMpegCencPtrOutput() JobConfigEncryptionMpegCencPtrOutput
	ToJobConfigEncryptionMpegCencPtrOutputWithContext(context.Context) JobConfigEncryptionMpegCencPtrOutput
}

JobConfigEncryptionMpegCencPtrInput is an input type that accepts JobConfigEncryptionMpegCencArgs, JobConfigEncryptionMpegCencPtr and JobConfigEncryptionMpegCencPtrOutput values. You can construct a concrete instance of `JobConfigEncryptionMpegCencPtrInput` via: 

        JobConfigEncryptionMpegCencArgs{...}

or:

        nil

func JobConfigEncryptionMpegCencPtr 

func JobConfigEncryptionMpegCencPtr(v *JobConfigEncryptionMpegCencArgs) JobConfigEncryptionMpegCencPtrInput

type JobConfigEncryptionMpegCencPtrOutput 

type JobConfigEncryptionMpegCencPtrOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionMpegCencPtrOutput) Elem 

func (o JobConfigEncryptionMpegCencPtrOutput) Elem() JobConfigEncryptionMpegCencOutput

func (JobConfigEncryptionMpegCencPtrOutput) ElementType 

func (JobConfigEncryptionMpegCencPtrOutput) ElementType() reflect.Type

func (JobConfigEncryptionMpegCencPtrOutput) Scheme 

func (o JobConfigEncryptionMpegCencPtrOutput) Scheme() pulumi.StringPtrOutput

Specify the encryption scheme.

func (JobConfigEncryptionMpegCencPtrOutput) ToJobConfigEncryptionMpegCencPtrOutput 

func (o JobConfigEncryptionMpegCencPtrOutput) ToJobConfigEncryptionMpegCencPtrOutput() JobConfigEncryptionMpegCencPtrOutput

func (JobConfigEncryptionMpegCencPtrOutput) ToJobConfigEncryptionMpegCencPtrOutputWithContext 

func (o JobConfigEncryptionMpegCencPtrOutput) ToJobConfigEncryptionMpegCencPtrOutputWithContext(ctx context.Context) JobConfigEncryptionMpegCencPtrOutput

type JobConfigEncryptionOutput 

type JobConfigEncryptionOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionOutput) Aes128 

func (o JobConfigEncryptionOutput) Aes128() JobConfigEncryptionAes128PtrOutput

Configuration for AES-128 encryption.

func (JobConfigEncryptionOutput) DrmSystems 

func (o JobConfigEncryptionOutput) DrmSystems() JobConfigEncryptionDrmSystemsPtrOutput

DRM system(s) to use; at least one must be specified. If a DRM system is omitted, it is considered disabled. Structure is documented below.

func (JobConfigEncryptionOutput) ElementType 

func (JobConfigEncryptionOutput) ElementType() reflect.Type

func (JobConfigEncryptionOutput) Id 

func (o JobConfigEncryptionOutput) Id() pulumi.StringOutput

Identifier for this set of encryption options.

func (JobConfigEncryptionOutput) MpegCenc 

func (o JobConfigEncryptionOutput) MpegCenc() JobConfigEncryptionMpegCencPtrOutput

Configuration for MPEG Common Encryption (MPEG-CENC). Structure is documented below.

func (JobConfigEncryptionOutput) SampleAes 

func (o JobConfigEncryptionOutput) SampleAes() JobConfigEncryptionSampleAesPtrOutput

Configuration for SAMPLE-AES encryption.

func (JobConfigEncryptionOutput) SecretManagerKeySource 

func (o JobConfigEncryptionOutput) SecretManagerKeySource() JobConfigEncryptionSecretManagerKeySourcePtrOutput

Configuration for secrets stored in Google Secret Manager. Structure is documented below.

func (JobConfigEncryptionOutput) ToJobConfigEncryptionOutput 

func (o JobConfigEncryptionOutput) ToJobConfigEncryptionOutput() JobConfigEncryptionOutput

func (JobConfigEncryptionOutput) ToJobConfigEncryptionOutputWithContext 

func (o JobConfigEncryptionOutput) ToJobConfigEncryptionOutputWithContext(ctx context.Context) JobConfigEncryptionOutput

type JobConfigEncryptionSampleAes 

type JobConfigEncryptionSampleAes struct {
}

type JobConfigEncryptionSampleAesArgs 

type JobConfigEncryptionSampleAesArgs struct {
}

func (JobConfigEncryptionSampleAesArgs) ElementType 

func (JobConfigEncryptionSampleAesArgs) ElementType() reflect.Type

func (JobConfigEncryptionSampleAesArgs) ToJobConfigEncryptionSampleAesOutput 

func (i JobConfigEncryptionSampleAesArgs) ToJobConfigEncryptionSampleAesOutput() JobConfigEncryptionSampleAesOutput

func (JobConfigEncryptionSampleAesArgs) ToJobConfigEncryptionSampleAesOutputWithContext 

func (i JobConfigEncryptionSampleAesArgs) ToJobConfigEncryptionSampleAesOutputWithContext(ctx context.Context) JobConfigEncryptionSampleAesOutput

func (JobConfigEncryptionSampleAesArgs) ToJobConfigEncryptionSampleAesPtrOutput 

func (i JobConfigEncryptionSampleAesArgs) ToJobConfigEncryptionSampleAesPtrOutput() JobConfigEncryptionSampleAesPtrOutput

func (JobConfigEncryptionSampleAesArgs) ToJobConfigEncryptionSampleAesPtrOutputWithContext 

func (i JobConfigEncryptionSampleAesArgs) ToJobConfigEncryptionSampleAesPtrOutputWithContext(ctx context.Context) JobConfigEncryptionSampleAesPtrOutput

type JobConfigEncryptionSampleAesInput 

type JobConfigEncryptionSampleAesInput interface {
	pulumi.Input

	ToJobConfigEncryptionSampleAesOutput() JobConfigEncryptionSampleAesOutput
	ToJobConfigEncryptionSampleAesOutputWithContext(context.Context) JobConfigEncryptionSampleAesOutput
}

JobConfigEncryptionSampleAesInput is an input type that accepts JobConfigEncryptionSampleAesArgs and JobConfigEncryptionSampleAesOutput values. You can construct a concrete instance of `JobConfigEncryptionSampleAesInput` via: 

JobConfigEncryptionSampleAesArgs{...}

type JobConfigEncryptionSampleAesOutput 

type JobConfigEncryptionSampleAesOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionSampleAesOutput) ElementType 

func (JobConfigEncryptionSampleAesOutput) ElementType() reflect.Type

func (JobConfigEncryptionSampleAesOutput) ToJobConfigEncryptionSampleAesOutput 

func (o JobConfigEncryptionSampleAesOutput) ToJobConfigEncryptionSampleAesOutput() JobConfigEncryptionSampleAesOutput

func (JobConfigEncryptionSampleAesOutput) ToJobConfigEncryptionSampleAesOutputWithContext 

func (o JobConfigEncryptionSampleAesOutput) ToJobConfigEncryptionSampleAesOutputWithContext(ctx context.Context) JobConfigEncryptionSampleAesOutput

func (JobConfigEncryptionSampleAesOutput) ToJobConfigEncryptionSampleAesPtrOutput 

func (o JobConfigEncryptionSampleAesOutput) ToJobConfigEncryptionSampleAesPtrOutput() JobConfigEncryptionSampleAesPtrOutput

func (JobConfigEncryptionSampleAesOutput) ToJobConfigEncryptionSampleAesPtrOutputWithContext 

func (o JobConfigEncryptionSampleAesOutput) ToJobConfigEncryptionSampleAesPtrOutputWithContext(ctx context.Context) JobConfigEncryptionSampleAesPtrOutput

type JobConfigEncryptionSampleAesPtrInput 

type JobConfigEncryptionSampleAesPtrInput interface {
	pulumi.Input

	ToJobConfigEncryptionSampleAesPtrOutput() JobConfigEncryptionSampleAesPtrOutput
	ToJobConfigEncryptionSampleAesPtrOutputWithContext(context.Context) JobConfigEncryptionSampleAesPtrOutput
}

JobConfigEncryptionSampleAesPtrInput is an input type that accepts JobConfigEncryptionSampleAesArgs, JobConfigEncryptionSampleAesPtr and JobConfigEncryptionSampleAesPtrOutput values. You can construct a concrete instance of `JobConfigEncryptionSampleAesPtrInput` via: 

        JobConfigEncryptionSampleAesArgs{...}

or:

        nil

func JobConfigEncryptionSampleAesPtr 

func JobConfigEncryptionSampleAesPtr(v *JobConfigEncryptionSampleAesArgs) JobConfigEncryptionSampleAesPtrInput

type JobConfigEncryptionSampleAesPtrOutput 

type JobConfigEncryptionSampleAesPtrOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionSampleAesPtrOutput) Elem 

func (o JobConfigEncryptionSampleAesPtrOutput) Elem() JobConfigEncryptionSampleAesOutput

func (JobConfigEncryptionSampleAesPtrOutput) ElementType 

func (JobConfigEncryptionSampleAesPtrOutput) ElementType() reflect.Type

func (JobConfigEncryptionSampleAesPtrOutput) ToJobConfigEncryptionSampleAesPtrOutput 

func (o JobConfigEncryptionSampleAesPtrOutput) ToJobConfigEncryptionSampleAesPtrOutput() JobConfigEncryptionSampleAesPtrOutput

func (JobConfigEncryptionSampleAesPtrOutput) ToJobConfigEncryptionSampleAesPtrOutputWithContext 

func (o JobConfigEncryptionSampleAesPtrOutput) ToJobConfigEncryptionSampleAesPtrOutputWithContext(ctx context.Context) JobConfigEncryptionSampleAesPtrOutput

type JobConfigEncryptionSecretManagerKeySource 

type JobConfigEncryptionSecretManagerKeySource struct {
	// The name of the Secret Version containing the encryption key in the following format: projects/{project}/secrets/{secret_id}/versions/{version_number}.
	SecretVersion string `pulumi:"secretVersion"`
}

type JobConfigEncryptionSecretManagerKeySourceArgs 

type JobConfigEncryptionSecretManagerKeySourceArgs struct {
	// The name of the Secret Version containing the encryption key in the following format: projects/{project}/secrets/{secret_id}/versions/{version_number}.
	SecretVersion pulumi.StringInput `pulumi:"secretVersion"`
}

func (JobConfigEncryptionSecretManagerKeySourceArgs) ElementType 

func (JobConfigEncryptionSecretManagerKeySourceArgs) ElementType() reflect.Type

func (JobConfigEncryptionSecretManagerKeySourceArgs) ToJobConfigEncryptionSecretManagerKeySourceOutput 

func (i JobConfigEncryptionSecretManagerKeySourceArgs) ToJobConfigEncryptionSecretManagerKeySourceOutput() JobConfigEncryptionSecretManagerKeySourceOutput

func (JobConfigEncryptionSecretManagerKeySourceArgs) ToJobConfigEncryptionSecretManagerKeySourceOutputWithContext 

func (i JobConfigEncryptionSecretManagerKeySourceArgs) ToJobConfigEncryptionSecretManagerKeySourceOutputWithContext(ctx context.Context) JobConfigEncryptionSecretManagerKeySourceOutput

func (JobConfigEncryptionSecretManagerKeySourceArgs) ToJobConfigEncryptionSecretManagerKeySourcePtrOutput 

func (i JobConfigEncryptionSecretManagerKeySourceArgs) ToJobConfigEncryptionSecretManagerKeySourcePtrOutput() JobConfigEncryptionSecretManagerKeySourcePtrOutput

func (JobConfigEncryptionSecretManagerKeySourceArgs) ToJobConfigEncryptionSecretManagerKeySourcePtrOutputWithContext 

func (i JobConfigEncryptionSecretManagerKeySourceArgs) ToJobConfigEncryptionSecretManagerKeySourcePtrOutputWithContext(ctx context.Context) JobConfigEncryptionSecretManagerKeySourcePtrOutput

type JobConfigEncryptionSecretManagerKeySourceInput 

type JobConfigEncryptionSecretManagerKeySourceInput interface {
	pulumi.Input

	ToJobConfigEncryptionSecretManagerKeySourceOutput() JobConfigEncryptionSecretManagerKeySourceOutput
	ToJobConfigEncryptionSecretManagerKeySourceOutputWithContext(context.Context) JobConfigEncryptionSecretManagerKeySourceOutput
}

JobConfigEncryptionSecretManagerKeySourceInput is an input type that accepts JobConfigEncryptionSecretManagerKeySourceArgs and JobConfigEncryptionSecretManagerKeySourceOutput values. You can construct a concrete instance of `JobConfigEncryptionSecretManagerKeySourceInput` via: 

JobConfigEncryptionSecretManagerKeySourceArgs{...}

type JobConfigEncryptionSecretManagerKeySourceOutput 

type JobConfigEncryptionSecretManagerKeySourceOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionSecretManagerKeySourceOutput) ElementType 

func (JobConfigEncryptionSecretManagerKeySourceOutput) ElementType() reflect.Type

func (JobConfigEncryptionSecretManagerKeySourceOutput) SecretVersion 

func (o JobConfigEncryptionSecretManagerKeySourceOutput) SecretVersion() pulumi.StringOutput

The name of the Secret Version containing the encryption key in the following format: projects/{project}/secrets/{secret_id}/versions/{version_number}.

func (JobConfigEncryptionSecretManagerKeySourceOutput) ToJobConfigEncryptionSecretManagerKeySourceOutput 

func (o JobConfigEncryptionSecretManagerKeySourceOutput) ToJobConfigEncryptionSecretManagerKeySourceOutput() JobConfigEncryptionSecretManagerKeySourceOutput

func (JobConfigEncryptionSecretManagerKeySourceOutput) ToJobConfigEncryptionSecretManagerKeySourceOutputWithContext 

func (o JobConfigEncryptionSecretManagerKeySourceOutput) ToJobConfigEncryptionSecretManagerKeySourceOutputWithContext(ctx context.Context) JobConfigEncryptionSecretManagerKeySourceOutput

func (JobConfigEncryptionSecretManagerKeySourceOutput) ToJobConfigEncryptionSecretManagerKeySourcePtrOutput 

func (o JobConfigEncryptionSecretManagerKeySourceOutput) ToJobConfigEncryptionSecretManagerKeySourcePtrOutput() JobConfigEncryptionSecretManagerKeySourcePtrOutput

func (JobConfigEncryptionSecretManagerKeySourceOutput) ToJobConfigEncryptionSecretManagerKeySourcePtrOutputWithContext 

func (o JobConfigEncryptionSecretManagerKeySourceOutput) ToJobConfigEncryptionSecretManagerKeySourcePtrOutputWithContext(ctx context.Context) JobConfigEncryptionSecretManagerKeySourcePtrOutput

type JobConfigEncryptionSecretManagerKeySourcePtrInput 

type JobConfigEncryptionSecretManagerKeySourcePtrInput interface {
	pulumi.Input

	ToJobConfigEncryptionSecretManagerKeySourcePtrOutput() JobConfigEncryptionSecretManagerKeySourcePtrOutput
	ToJobConfigEncryptionSecretManagerKeySourcePtrOutputWithContext(context.Context) JobConfigEncryptionSecretManagerKeySourcePtrOutput
}

JobConfigEncryptionSecretManagerKeySourcePtrInput is an input type that accepts JobConfigEncryptionSecretManagerKeySourceArgs, JobConfigEncryptionSecretManagerKeySourcePtr and JobConfigEncryptionSecretManagerKeySourcePtrOutput values. You can construct a concrete instance of `JobConfigEncryptionSecretManagerKeySourcePtrInput` via: 

        JobConfigEncryptionSecretManagerKeySourceArgs{...}

or:

        nil

func JobConfigEncryptionSecretManagerKeySourcePtr 

func JobConfigEncryptionSecretManagerKeySourcePtr(v *JobConfigEncryptionSecretManagerKeySourceArgs) JobConfigEncryptionSecretManagerKeySourcePtrInput

type JobConfigEncryptionSecretManagerKeySourcePtrOutput 

type JobConfigEncryptionSecretManagerKeySourcePtrOutput struct{ *pulumi.OutputState }

func (JobConfigEncryptionSecretManagerKeySourcePtrOutput) Elem 

func (o JobConfigEncryptionSecretManagerKeySourcePtrOutput) Elem() JobConfigEncryptionSecretManagerKeySourceOutput

func (JobConfigEncryptionSecretManagerKeySourcePtrOutput) ElementType 

func (JobConfigEncryptionSecretManagerKeySourcePtrOutput) ElementType() reflect.Type

func (JobConfigEncryptionSecretManagerKeySourcePtrOutput) SecretVersion 

func (o JobConfigEncryptionSecretManagerKeySourcePtrOutput) SecretVersion() pulumi.StringPtrOutput

The name of the Secret Version containing the encryption key in the following format: projects/{project}/secrets/{secret_id}/versions/{version_number}.

func (JobConfigEncryptionSecretManagerKeySourcePtrOutput) ToJobConfigEncryptionSecretManagerKeySourcePtrOutput 

func (o JobConfigEncryptionSecretManagerKeySourcePtrOutput) ToJobConfigEncryptionSecretManagerKeySourcePtrOutput() JobConfigEncryptionSecretManagerKeySourcePtrOutput

func (JobConfigEncryptionSecretManagerKeySourcePtrOutput) ToJobConfigEncryptionSecretManagerKeySourcePtrOutputWithContext 

func (o JobConfigEncryptionSecretManagerKeySourcePtrOutput) ToJobConfigEncryptionSecretManagerKeySourcePtrOutputWithContext(ctx context.Context) JobConfigEncryptionSecretManagerKeySourcePtrOutput

type JobConfigInput 

type JobConfigInput interface {
	pulumi.Input

	ToJobConfigOutput() JobConfigOutput
	ToJobConfigOutputWithContext(context.Context) JobConfigOutput
}

JobConfigInput is an input type that accepts JobConfigArgs and JobConfigOutput values. You can construct a concrete instance of `JobConfigInput` via: 

JobConfigArgs{...}

type JobConfigInputType 

type JobConfigInputType struct {
	// A unique key for this input. Must be specified when using advanced mapping and edit lists.
	Key *string `pulumi:"key"`
	// URI of the media. Input files must be at least 5 seconds in duration and stored in Cloud Storage (for example, gs://bucket/inputs/file.mp4).
	// If empty, the value is populated from Job.input_uri.
	Uri *string `pulumi:"uri"`
}

type JobConfigInputTypeArgs 

type JobConfigInputTypeArgs struct {
	// A unique key for this input. Must be specified when using advanced mapping and edit lists.
	Key pulumi.StringPtrInput `pulumi:"key"`
	// URI of the media. Input files must be at least 5 seconds in duration and stored in Cloud Storage (for example, gs://bucket/inputs/file.mp4).
	// If empty, the value is populated from Job.input_uri.
	Uri pulumi.StringPtrInput `pulumi:"uri"`
}

func (JobConfigInputTypeArgs) ElementType 

func (JobConfigInputTypeArgs) ElementType() reflect.Type

func (JobConfigInputTypeArgs) ToJobConfigInputTypeOutput 

func (i JobConfigInputTypeArgs) ToJobConfigInputTypeOutput() JobConfigInputTypeOutput

func (JobConfigInputTypeArgs) ToJobConfigInputTypeOutputWithContext 

func (i JobConfigInputTypeArgs) ToJobConfigInputTypeOutputWithContext(ctx context.Context) JobConfigInputTypeOutput

type JobConfigInputTypeArray 

type JobConfigInputTypeArray []JobConfigInputTypeInput

func (JobConfigInputTypeArray) ElementType 

func (JobConfigInputTypeArray) ElementType() reflect.Type

func (JobConfigInputTypeArray) ToJobConfigInputTypeArrayOutput 

func (i JobConfigInputTypeArray) ToJobConfigInputTypeArrayOutput() JobConfigInputTypeArrayOutput

func (JobConfigInputTypeArray) ToJobConfigInputTypeArrayOutputWithContext 

func (i JobConfigInputTypeArray) ToJobConfigInputTypeArrayOutputWithContext(ctx context.Context) JobConfigInputTypeArrayOutput

type JobConfigInputTypeArrayInput 

type JobConfigInputTypeArrayInput interface {
	pulumi.Input

	ToJobConfigInputTypeArrayOutput() JobConfigInputTypeArrayOutput
	ToJobConfigInputTypeArrayOutputWithContext(context.Context) JobConfigInputTypeArrayOutput
}

JobConfigInputTypeArrayInput is an input type that accepts JobConfigInputTypeArray and JobConfigInputTypeArrayOutput values. You can construct a concrete instance of `JobConfigInputTypeArrayInput` via: 

JobConfigInputTypeArray{ JobConfigInputTypeArgs{...} }

type JobConfigInputTypeArrayOutput 

type JobConfigInputTypeArrayOutput struct{ *pulumi.OutputState }

func (JobConfigInputTypeArrayOutput) ElementType 

func (JobConfigInputTypeArrayOutput) ElementType() reflect.Type

func (JobConfigInputTypeArrayOutput) Index 

func (o JobConfigInputTypeArrayOutput) Index(i pulumi.IntInput) JobConfigInputTypeOutput

func (JobConfigInputTypeArrayOutput) ToJobConfigInputTypeArrayOutput 

func (o JobConfigInputTypeArrayOutput) ToJobConfigInputTypeArrayOutput() JobConfigInputTypeArrayOutput

func (JobConfigInputTypeArrayOutput) ToJobConfigInputTypeArrayOutputWithContext 

func (o JobConfigInputTypeArrayOutput) ToJobConfigInputTypeArrayOutputWithContext(ctx context.Context) JobConfigInputTypeArrayOutput

type JobConfigInputTypeInput 

type JobConfigInputTypeInput interface {
	pulumi.Input

	ToJobConfigInputTypeOutput() JobConfigInputTypeOutput
	ToJobConfigInputTypeOutputWithContext(context.Context) JobConfigInputTypeOutput
}

JobConfigInputTypeInput is an input type that accepts JobConfigInputTypeArgs and JobConfigInputTypeOutput values. You can construct a concrete instance of `JobConfigInputTypeInput` via: 

JobConfigInputTypeArgs{...}

type JobConfigInputTypeOutput 

type JobConfigInputTypeOutput struct{ *pulumi.OutputState }

func (JobConfigInputTypeOutput) ElementType 

func (JobConfigInputTypeOutput) ElementType() reflect.Type

func (JobConfigInputTypeOutput) Key 

func (o JobConfigInputTypeOutput) Key() pulumi.StringPtrOutput

A unique key for this input. Must be specified when using advanced mapping and edit lists.

func (JobConfigInputTypeOutput) ToJobConfigInputTypeOutput 

func (o JobConfigInputTypeOutput) ToJobConfigInputTypeOutput() JobConfigInputTypeOutput

func (JobConfigInputTypeOutput) ToJobConfigInputTypeOutputWithContext 

func (o JobConfigInputTypeOutput) ToJobConfigInputTypeOutputWithContext(ctx context.Context) JobConfigInputTypeOutput

func (JobConfigInputTypeOutput) Uri 

func (o JobConfigInputTypeOutput) Uri() pulumi.StringPtrOutput

URI of the media. Input files must be at least 5 seconds in duration and stored in Cloud Storage (for example, gs://bucket/inputs/file.mp4). If empty, the value is populated from Job.input_uri.

type JobConfigManifest 

type JobConfigManifest struct {
	// The name of the generated file. The default is `manifest`.
	FileName *string `pulumi:"fileName"`
	// List of user supplied MuxStream.key values that should appear in this manifest.
	MuxStreams []string `pulumi:"muxStreams"`
	// Type of the manifest.
	// Possible values are: `MANIFEST_TYPE_UNSPECIFIED`, `HLS`, `DASH`.
	Type *string `pulumi:"type"`
}

type JobConfigManifestArgs 

type JobConfigManifestArgs struct {
	// The name of the generated file. The default is `manifest`.
	FileName pulumi.StringPtrInput `pulumi:"fileName"`
	// List of user supplied MuxStream.key values that should appear in this manifest.
	MuxStreams pulumi.StringArrayInput `pulumi:"muxStreams"`
	// Type of the manifest.
	// Possible values are: `MANIFEST_TYPE_UNSPECIFIED`, `HLS`, `DASH`.
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (JobConfigManifestArgs) ElementType 

func (JobConfigManifestArgs) ElementType() reflect.Type

func (JobConfigManifestArgs) ToJobConfigManifestOutput 

func (i JobConfigManifestArgs) ToJobConfigManifestOutput() JobConfigManifestOutput

func (JobConfigManifestArgs) ToJobConfigManifestOutputWithContext 

func (i JobConfigManifestArgs) ToJobConfigManifestOutputWithContext(ctx context.Context) JobConfigManifestOutput

type JobConfigManifestArray 

type JobConfigManifestArray []JobConfigManifestInput

func (JobConfigManifestArray) ElementType 

func (JobConfigManifestArray) ElementType() reflect.Type

func (JobConfigManifestArray) ToJobConfigManifestArrayOutput 

func (i JobConfigManifestArray) ToJobConfigManifestArrayOutput() JobConfigManifestArrayOutput

func (JobConfigManifestArray) ToJobConfigManifestArrayOutputWithContext 

func (i JobConfigManifestArray) ToJobConfigManifestArrayOutputWithContext(ctx context.Context) JobConfigManifestArrayOutput

type JobConfigManifestArrayInput 

type JobConfigManifestArrayInput interface {
	pulumi.Input

	ToJobConfigManifestArrayOutput() JobConfigManifestArrayOutput
	ToJobConfigManifestArrayOutputWithContext(context.Context) JobConfigManifestArrayOutput
}

JobConfigManifestArrayInput is an input type that accepts JobConfigManifestArray and JobConfigManifestArrayOutput values. You can construct a concrete instance of `JobConfigManifestArrayInput` via: 

JobConfigManifestArray{ JobConfigManifestArgs{...} }

type JobConfigManifestArrayOutput 

type JobConfigManifestArrayOutput struct{ *pulumi.OutputState }

func (JobConfigManifestArrayOutput) ElementType 

func (JobConfigManifestArrayOutput) ElementType() reflect.Type

func (JobConfigManifestArrayOutput) Index 

func (o JobConfigManifestArrayOutput) Index(i pulumi.IntInput) JobConfigManifestOutput

func (JobConfigManifestArrayOutput) ToJobConfigManifestArrayOutput 

func (o JobConfigManifestArrayOutput) ToJobConfigManifestArrayOutput() JobConfigManifestArrayOutput

func (JobConfigManifestArrayOutput) ToJobConfigManifestArrayOutputWithContext 

func (o JobConfigManifestArrayOutput) ToJobConfigManifestArrayOutputWithContext(ctx context.Context) JobConfigManifestArrayOutput

type JobConfigManifestInput 

type JobConfigManifestInput interface {
	pulumi.Input

	ToJobConfigManifestOutput() JobConfigManifestOutput
	ToJobConfigManifestOutputWithContext(context.Context) JobConfigManifestOutput
}

JobConfigManifestInput is an input type that accepts JobConfigManifestArgs and JobConfigManifestOutput values. You can construct a concrete instance of `JobConfigManifestInput` via: 

JobConfigManifestArgs{...}

type JobConfigManifestOutput 

type JobConfigManifestOutput struct{ *pulumi.OutputState }

func (JobConfigManifestOutput) ElementType 

func (JobConfigManifestOutput) ElementType() reflect.Type

func (JobConfigManifestOutput) FileName 

func (o JobConfigManifestOutput) FileName() pulumi.StringPtrOutput

The name of the generated file. The default is `manifest`.

func (JobConfigManifestOutput) MuxStreams 

func (o JobConfigManifestOutput) MuxStreams() pulumi.StringArrayOutput

List of user supplied MuxStream.key values that should appear in this manifest.

func (JobConfigManifestOutput) ToJobConfigManifestOutput 

func (o JobConfigManifestOutput) ToJobConfigManifestOutput() JobConfigManifestOutput

func (JobConfigManifestOutput) ToJobConfigManifestOutputWithContext 

func (o JobConfigManifestOutput) ToJobConfigManifestOutputWithContext(ctx context.Context) JobConfigManifestOutput

func (JobConfigManifestOutput) Type 

func (o JobConfigManifestOutput) Type() pulumi.StringPtrOutput

Type of the manifest. Possible values are: `MANIFEST_TYPE_UNSPECIFIED`, `HLS`, `DASH`.

type JobConfigMuxStream 

type JobConfigMuxStream struct {
	// The container format. The default is `mp4`.
	Container *string `pulumi:"container"`
	// List of ElementaryStream.key values multiplexed in this stream.
	ElementaryStreams []string `pulumi:"elementaryStreams"`
	// Identifier of the encryption configuration to use.
	EncryptionId *string `pulumi:"encryptionId"`
	// The name of the generated file.
	FileName *string `pulumi:"fileName"`
	// A unique key for this multiplexed stream.
	Key *string `pulumi:"key"`
	// Segment settings for ts, fmp4 and vtt.
	// Structure is documented below.
	SegmentSettings *JobConfigMuxStreamSegmentSettings `pulumi:"segmentSettings"`
}

type JobConfigMuxStreamArgs 

type JobConfigMuxStreamArgs struct {
	// The container format. The default is `mp4`.
	Container pulumi.StringPtrInput `pulumi:"container"`
	// List of ElementaryStream.key values multiplexed in this stream.
	ElementaryStreams pulumi.StringArrayInput `pulumi:"elementaryStreams"`
	// Identifier of the encryption configuration to use.
	EncryptionId pulumi.StringPtrInput `pulumi:"encryptionId"`
	// The name of the generated file.
	FileName pulumi.StringPtrInput `pulumi:"fileName"`
	// A unique key for this multiplexed stream.
	Key pulumi.StringPtrInput `pulumi:"key"`
	// Segment settings for ts, fmp4 and vtt.
	// Structure is documented below.
	SegmentSettings JobConfigMuxStreamSegmentSettingsPtrInput `pulumi:"segmentSettings"`
}

func (JobConfigMuxStreamArgs) ElementType 

func (JobConfigMuxStreamArgs) ElementType() reflect.Type

func (JobConfigMuxStreamArgs) ToJobConfigMuxStreamOutput 

func (i JobConfigMuxStreamArgs) ToJobConfigMuxStreamOutput() JobConfigMuxStreamOutput

func (JobConfigMuxStreamArgs) ToJobConfigMuxStreamOutputWithContext 

func (i JobConfigMuxStreamArgs) ToJobConfigMuxStreamOutputWithContext(ctx context.Context) JobConfigMuxStreamOutput

type JobConfigMuxStreamArray 

type JobConfigMuxStreamArray []JobConfigMuxStreamInput

func (JobConfigMuxStreamArray) ElementType 

func (JobConfigMuxStreamArray) ElementType() reflect.Type

func (JobConfigMuxStreamArray) ToJobConfigMuxStreamArrayOutput 

func (i JobConfigMuxStreamArray) ToJobConfigMuxStreamArrayOutput() JobConfigMuxStreamArrayOutput

func (JobConfigMuxStreamArray) ToJobConfigMuxStreamArrayOutputWithContext 

func (i JobConfigMuxStreamArray) ToJobConfigMuxStreamArrayOutputWithContext(ctx context.Context) JobConfigMuxStreamArrayOutput

type JobConfigMuxStreamArrayInput 

type JobConfigMuxStreamArrayInput interface {
	pulumi.Input

	ToJobConfigMuxStreamArrayOutput() JobConfigMuxStreamArrayOutput
	ToJobConfigMuxStreamArrayOutputWithContext(context.Context) JobConfigMuxStreamArrayOutput
}

JobConfigMuxStreamArrayInput is an input type that accepts JobConfigMuxStreamArray and JobConfigMuxStreamArrayOutput values. You can construct a concrete instance of `JobConfigMuxStreamArrayInput` via: 

JobConfigMuxStreamArray{ JobConfigMuxStreamArgs{...} }

type JobConfigMuxStreamArrayOutput 

type JobConfigMuxStreamArrayOutput struct{ *pulumi.OutputState }

func (JobConfigMuxStreamArrayOutput) ElementType 

func (JobConfigMuxStreamArrayOutput) ElementType() reflect.Type

func (JobConfigMuxStreamArrayOutput) Index 

func (o JobConfigMuxStreamArrayOutput) Index(i pulumi.IntInput) JobConfigMuxStreamOutput

func (JobConfigMuxStreamArrayOutput) ToJobConfigMuxStreamArrayOutput 

func (o JobConfigMuxStreamArrayOutput) ToJobConfigMuxStreamArrayOutput() JobConfigMuxStreamArrayOutput

func (JobConfigMuxStreamArrayOutput) ToJobConfigMuxStreamArrayOutputWithContext 

func (o JobConfigMuxStreamArrayOutput) ToJobConfigMuxStreamArrayOutputWithContext(ctx context.Context) JobConfigMuxStreamArrayOutput

type JobConfigMuxStreamInput 

type JobConfigMuxStreamInput interface {
	pulumi.Input

	ToJobConfigMuxStreamOutput() JobConfigMuxStreamOutput
	ToJobConfigMuxStreamOutputWithContext(context.Context) JobConfigMuxStreamOutput
}

JobConfigMuxStreamInput is an input type that accepts JobConfigMuxStreamArgs and JobConfigMuxStreamOutput values. You can construct a concrete instance of `JobConfigMuxStreamInput` via: 

JobConfigMuxStreamArgs{...}

type JobConfigMuxStreamOutput 

type JobConfigMuxStreamOutput struct{ *pulumi.OutputState }

func (JobConfigMuxStreamOutput) Container 

func (o JobConfigMuxStreamOutput) Container() pulumi.StringPtrOutput

The container format. The default is `mp4`.

func (JobConfigMuxStreamOutput) ElementType 

func (JobConfigMuxStreamOutput) ElementType() reflect.Type

func (JobConfigMuxStreamOutput) ElementaryStreams 

func (o JobConfigMuxStreamOutput) ElementaryStreams() pulumi.StringArrayOutput

List of ElementaryStream.key values multiplexed in this stream.

func (JobConfigMuxStreamOutput) EncryptionId 

func (o JobConfigMuxStreamOutput) EncryptionId() pulumi.StringPtrOutput

Identifier of the encryption configuration to use.

func (JobConfigMuxStreamOutput) FileName 

func (o JobConfigMuxStreamOutput) FileName() pulumi.StringPtrOutput

The name of the generated file.

func (JobConfigMuxStreamOutput) Key 

func (o JobConfigMuxStreamOutput) Key() pulumi.StringPtrOutput

A unique key for this multiplexed stream.

func (JobConfigMuxStreamOutput) SegmentSettings 

func (o JobConfigMuxStreamOutput) SegmentSettings() JobConfigMuxStreamSegmentSettingsPtrOutput

Segment settings for ts, fmp4 and vtt. Structure is documented below.

func (JobConfigMuxStreamOutput) ToJobConfigMuxStreamOutput 

func (o JobConfigMuxStreamOutput) ToJobConfigMuxStreamOutput() JobConfigMuxStreamOutput

func (JobConfigMuxStreamOutput) ToJobConfigMuxStreamOutputWithContext 

func (o JobConfigMuxStreamOutput) ToJobConfigMuxStreamOutputWithContext(ctx context.Context) JobConfigMuxStreamOutput

type JobConfigMuxStreamSegmentSettings 

type JobConfigMuxStreamSegmentSettings struct {
	// Duration of the segments in seconds. The default is `6.0s`.
	SegmentDuration *string `pulumi:"segmentDuration"`
}

type JobConfigMuxStreamSegmentSettingsArgs 

type JobConfigMuxStreamSegmentSettingsArgs struct {
	// Duration of the segments in seconds. The default is `6.0s`.
	SegmentDuration pulumi.StringPtrInput `pulumi:"segmentDuration"`
}

func (JobConfigMuxStreamSegmentSettingsArgs) ElementType 

func (JobConfigMuxStreamSegmentSettingsArgs) ElementType() reflect.Type

func (JobConfigMuxStreamSegmentSettingsArgs) ToJobConfigMuxStreamSegmentSettingsOutput 

func (i JobConfigMuxStreamSegmentSettingsArgs) ToJobConfigMuxStreamSegmentSettingsOutput() JobConfigMuxStreamSegmentSettingsOutput

func (JobConfigMuxStreamSegmentSettingsArgs) ToJobConfigMuxStreamSegmentSettingsOutputWithContext 

func (i JobConfigMuxStreamSegmentSettingsArgs) ToJobConfigMuxStreamSegmentSettingsOutputWithContext(ctx context.Context) JobConfigMuxStreamSegmentSettingsOutput

func (JobConfigMuxStreamSegmentSettingsArgs) ToJobConfigMuxStreamSegmentSettingsPtrOutput 

func (i JobConfigMuxStreamSegmentSettingsArgs) ToJobConfigMuxStreamSegmentSettingsPtrOutput() JobConfigMuxStreamSegmentSettingsPtrOutput

func (JobConfigMuxStreamSegmentSettingsArgs) ToJobConfigMuxStreamSegmentSettingsPtrOutputWithContext 

func (i JobConfigMuxStreamSegmentSettingsArgs) ToJobConfigMuxStreamSegmentSettingsPtrOutputWithContext(ctx context.Context) JobConfigMuxStreamSegmentSettingsPtrOutput

type JobConfigMuxStreamSegmentSettingsInput 

type JobConfigMuxStreamSegmentSettingsInput interface {
	pulumi.Input

	ToJobConfigMuxStreamSegmentSettingsOutput() JobConfigMuxStreamSegmentSettingsOutput
	ToJobConfigMuxStreamSegmentSettingsOutputWithContext(context.Context) JobConfigMuxStreamSegmentSettingsOutput
}

JobConfigMuxStreamSegmentSettingsInput is an input type that accepts JobConfigMuxStreamSegmentSettingsArgs and JobConfigMuxStreamSegmentSettingsOutput values. You can construct a concrete instance of `JobConfigMuxStreamSegmentSettingsInput` via: 

JobConfigMuxStreamSegmentSettingsArgs{...}

type JobConfigMuxStreamSegmentSettingsOutput 

type JobConfigMuxStreamSegmentSettingsOutput struct{ *pulumi.OutputState }

func (JobConfigMuxStreamSegmentSettingsOutput) ElementType 

func (JobConfigMuxStreamSegmentSettingsOutput) ElementType() reflect.Type

func (JobConfigMuxStreamSegmentSettingsOutput) SegmentDuration 

func (o JobConfigMuxStreamSegmentSettingsOutput) SegmentDuration() pulumi.StringPtrOutput

Duration of the segments in seconds. The default is `6.0s`.

func (JobConfigMuxStreamSegmentSettingsOutput) ToJobConfigMuxStreamSegmentSettingsOutput 

func (o JobConfigMuxStreamSegmentSettingsOutput) ToJobConfigMuxStreamSegmentSettingsOutput() JobConfigMuxStreamSegmentSettingsOutput

func (JobConfigMuxStreamSegmentSettingsOutput) ToJobConfigMuxStreamSegmentSettingsOutputWithContext 

func (o JobConfigMuxStreamSegmentSettingsOutput) ToJobConfigMuxStreamSegmentSettingsOutputWithContext(ctx context.Context) JobConfigMuxStreamSegmentSettingsOutput

func (JobConfigMuxStreamSegmentSettingsOutput) ToJobConfigMuxStreamSegmentSettingsPtrOutput 

func (o JobConfigMuxStreamSegmentSettingsOutput) ToJobConfigMuxStreamSegmentSettingsPtrOutput() JobConfigMuxStreamSegmentSettingsPtrOutput

func (JobConfigMuxStreamSegmentSettingsOutput) ToJobConfigMuxStreamSegmentSettingsPtrOutputWithContext 

func (o JobConfigMuxStreamSegmentSettingsOutput) ToJobConfigMuxStreamSegmentSettingsPtrOutputWithContext(ctx context.Context) JobConfigMuxStreamSegmentSettingsPtrOutput

type JobConfigMuxStreamSegmentSettingsPtrInput 

type JobConfigMuxStreamSegmentSettingsPtrInput interface {
	pulumi.Input

	ToJobConfigMuxStreamSegmentSettingsPtrOutput() JobConfigMuxStreamSegmentSettingsPtrOutput
	ToJobConfigMuxStreamSegmentSettingsPtrOutputWithContext(context.Context) JobConfigMuxStreamSegmentSettingsPtrOutput
}

JobConfigMuxStreamSegmentSettingsPtrInput is an input type that accepts JobConfigMuxStreamSegmentSettingsArgs, JobConfigMuxStreamSegmentSettingsPtr and JobConfigMuxStreamSegmentSettingsPtrOutput values. You can construct a concrete instance of `JobConfigMuxStreamSegmentSettingsPtrInput` via: 

        JobConfigMuxStreamSegmentSettingsArgs{...}

or:

        nil

func JobConfigMuxStreamSegmentSettingsPtr 

func JobConfigMuxStreamSegmentSettingsPtr(v *JobConfigMuxStreamSegmentSettingsArgs) JobConfigMuxStreamSegmentSettingsPtrInput

type JobConfigMuxStreamSegmentSettingsPtrOutput 

type JobConfigMuxStreamSegmentSettingsPtrOutput struct{ *pulumi.OutputState }

func (JobConfigMuxStreamSegmentSettingsPtrOutput) Elem 

func (o JobConfigMuxStreamSegmentSettingsPtrOutput) Elem() JobConfigMuxStreamSegmentSettingsOutput

func (JobConfigMuxStreamSegmentSettingsPtrOutput) ElementType 

func (JobConfigMuxStreamSegmentSettingsPtrOutput) ElementType() reflect.Type

func (JobConfigMuxStreamSegmentSettingsPtrOutput) SegmentDuration 

func (o JobConfigMuxStreamSegmentSettingsPtrOutput) SegmentDuration() pulumi.StringPtrOutput

Duration of the segments in seconds. The default is `6.0s`.

func (JobConfigMuxStreamSegmentSettingsPtrOutput) ToJobConfigMuxStreamSegmentSettingsPtrOutput 

func (o JobConfigMuxStreamSegmentSettingsPtrOutput) ToJobConfigMuxStreamSegmentSettingsPtrOutput() JobConfigMuxStreamSegmentSettingsPtrOutput

func (JobConfigMuxStreamSegmentSettingsPtrOutput) ToJobConfigMuxStreamSegmentSettingsPtrOutputWithContext 

func (o JobConfigMuxStreamSegmentSettingsPtrOutput) ToJobConfigMuxStreamSegmentSettingsPtrOutputWithContext(ctx context.Context) JobConfigMuxStreamSegmentSettingsPtrOutput

type JobConfigOutput 

type JobConfigOutput struct{ *pulumi.OutputState }

func (JobConfigOutput) AdBreaks 

func (o JobConfigOutput) AdBreaks() JobConfigAdBreakArrayOutput

Ad break. Structure is documented below.

func (JobConfigOutput) EditLists 

func (o JobConfigOutput) EditLists() JobConfigEditListArrayOutput

List of input assets stored in Cloud Storage. Structure is documented below.

func (JobConfigOutput) ElementType 

func (JobConfigOutput) ElementType() reflect.Type

func (JobConfigOutput) ElementaryStreams 

func (o JobConfigOutput) ElementaryStreams() JobConfigElementaryStreamArrayOutput

List of input assets stored in Cloud Storage. Structure is documented below.

func (JobConfigOutput) Encryptions 

func (o JobConfigOutput) Encryptions() JobConfigEncryptionArrayOutput

List of encryption configurations for the content. Structure is documented below.

func (JobConfigOutput) Inputs 

func (o JobConfigOutput) Inputs() JobConfigInputTypeArrayOutput

List of input assets stored in Cloud Storage. Structure is documented below.

func (JobConfigOutput) Manifests 

func (o JobConfigOutput) Manifests() JobConfigManifestArrayOutput

Manifest configuration. Structure is documented below.

func (JobConfigOutput) MuxStreams 

func (o JobConfigOutput) MuxStreams() JobConfigMuxStreamArrayOutput

Multiplexing settings for output stream. Structure is documented below.

func (JobConfigOutput) Output 

func (o JobConfigOutput) Output() JobConfigOutputTypePtrOutput

Location of output file(s) in a Cloud Storage bucket. Structure is documented below.

func (JobConfigOutput) Overlays 

func (o JobConfigOutput) Overlays() JobConfigOverlayArrayOutput

List of overlays on the output video, in descending Z-order. Structure is documented below.

func (JobConfigOutput) PubsubDestination 

func (o JobConfigOutput) PubsubDestination() JobConfigPubsubDestinationPtrOutput

Pub/Sub destination. Structure is documented below.

func (JobConfigOutput) ToJobConfigOutput 

func (o JobConfigOutput) ToJobConfigOutput() JobConfigOutput

func (JobConfigOutput) ToJobConfigOutputWithContext 

func (o JobConfigOutput) ToJobConfigOutputWithContext(ctx context.Context) JobConfigOutput

func (JobConfigOutput) ToJobConfigPtrOutput 

func (o JobConfigOutput) ToJobConfigPtrOutput() JobConfigPtrOutput

func (JobConfigOutput) ToJobConfigPtrOutputWithContext 

func (o JobConfigOutput) ToJobConfigPtrOutputWithContext(ctx context.Context) JobConfigPtrOutput

type JobConfigOutputType 

type JobConfigOutputType struct {
	// URI for the output file(s). For example, gs://my-bucket/outputs/.
	Uri *string `pulumi:"uri"`
}

type JobConfigOutputTypeArgs 

type JobConfigOutputTypeArgs struct {
	// URI for the output file(s). For example, gs://my-bucket/outputs/.
	Uri pulumi.StringPtrInput `pulumi:"uri"`
}

func (JobConfigOutputTypeArgs) ElementType 

func (JobConfigOutputTypeArgs) ElementType() reflect.Type

func (JobConfigOutputTypeArgs) ToJobConfigOutputTypeOutput 

func (i JobConfigOutputTypeArgs) ToJobConfigOutputTypeOutput() JobConfigOutputTypeOutput

func (JobConfigOutputTypeArgs) ToJobConfigOutputTypeOutputWithContext 

func (i JobConfigOutputTypeArgs) ToJobConfigOutputTypeOutputWithContext(ctx context.Context) JobConfigOutputTypeOutput

func (JobConfigOutputTypeArgs) ToJobConfigOutputTypePtrOutput 

func (i JobConfigOutputTypeArgs) ToJobConfigOutputTypePtrOutput() JobConfigOutputTypePtrOutput

func (JobConfigOutputTypeArgs) ToJobConfigOutputTypePtrOutputWithContext 

func (i JobConfigOutputTypeArgs) ToJobConfigOutputTypePtrOutputWithContext(ctx context.Context) JobConfigOutputTypePtrOutput

type JobConfigOutputTypeInput 

type JobConfigOutputTypeInput interface {
	pulumi.Input

	ToJobConfigOutputTypeOutput() JobConfigOutputTypeOutput
	ToJobConfigOutputTypeOutputWithContext(context.Context) JobConfigOutputTypeOutput
}

JobConfigOutputTypeInput is an input type that accepts JobConfigOutputTypeArgs and JobConfigOutputTypeOutput values. You can construct a concrete instance of `JobConfigOutputTypeInput` via: 

JobConfigOutputTypeArgs{...}

type JobConfigOutputTypeOutput 

type JobConfigOutputTypeOutput struct{ *pulumi.OutputState }

func (JobConfigOutputTypeOutput) ElementType 

func (JobConfigOutputTypeOutput) ElementType() reflect.Type

func (JobConfigOutputTypeOutput) ToJobConfigOutputTypeOutput 

func (o JobConfigOutputTypeOutput) ToJobConfigOutputTypeOutput() JobConfigOutputTypeOutput

func (JobConfigOutputTypeOutput) ToJobConfigOutputTypeOutputWithContext 

func (o JobConfigOutputTypeOutput) ToJobConfigOutputTypeOutputWithContext(ctx context.Context) JobConfigOutputTypeOutput

func (JobConfigOutputTypeOutput) ToJobConfigOutputTypePtrOutput 

func (o JobConfigOutputTypeOutput) ToJobConfigOutputTypePtrOutput() JobConfigOutputTypePtrOutput

func (JobConfigOutputTypeOutput) ToJobConfigOutputTypePtrOutputWithContext 

func (o JobConfigOutputTypeOutput) ToJobConfigOutputTypePtrOutputWithContext(ctx context.Context) JobConfigOutputTypePtrOutput

func (JobConfigOutputTypeOutput) Uri 

func (o JobConfigOutputTypeOutput) Uri() pulumi.StringPtrOutput

URI for the output file(s). For example, gs://my-bucket/outputs/.

type JobConfigOutputTypePtrInput 

type JobConfigOutputTypePtrInput interface {
	pulumi.Input

	ToJobConfigOutputTypePtrOutput() JobConfigOutputTypePtrOutput
	ToJobConfigOutputTypePtrOutputWithContext(context.Context) JobConfigOutputTypePtrOutput
}

JobConfigOutputTypePtrInput is an input type that accepts JobConfigOutputTypeArgs, JobConfigOutputTypePtr and JobConfigOutputTypePtrOutput values. You can construct a concrete instance of `JobConfigOutputTypePtrInput` via: 

        JobConfigOutputTypeArgs{...}

or:

        nil

func JobConfigOutputTypePtr 

func JobConfigOutputTypePtr(v *JobConfigOutputTypeArgs) JobConfigOutputTypePtrInput

type JobConfigOutputTypePtrOutput 

type JobConfigOutputTypePtrOutput struct{ *pulumi.OutputState }

func (JobConfigOutputTypePtrOutput) Elem 

func (o JobConfigOutputTypePtrOutput) Elem() JobConfigOutputTypeOutput

func (JobConfigOutputTypePtrOutput) ElementType 

func (JobConfigOutputTypePtrOutput) ElementType() reflect.Type

func (JobConfigOutputTypePtrOutput) ToJobConfigOutputTypePtrOutput 

func (o JobConfigOutputTypePtrOutput) ToJobConfigOutputTypePtrOutput() JobConfigOutputTypePtrOutput

func (JobConfigOutputTypePtrOutput) ToJobConfigOutputTypePtrOutputWithContext 

func (o JobConfigOutputTypePtrOutput) ToJobConfigOutputTypePtrOutputWithContext(ctx context.Context) JobConfigOutputTypePtrOutput

func (JobConfigOutputTypePtrOutput) Uri 

func (o JobConfigOutputTypePtrOutput) Uri() pulumi.StringPtrOutput

URI for the output file(s). For example, gs://my-bucket/outputs/.

type JobConfigOverlay 

type JobConfigOverlay struct {
	// List of animations. The list should be chronological, without any time overlap.
	// Structure is documented below.
	Animations []JobConfigOverlayAnimation `pulumi:"animations"`
	// Image overlay.
	// Structure is documented below.
	Image *JobConfigOverlayImage `pulumi:"image"`
}

type JobConfigOverlayAnimation 

type JobConfigOverlayAnimation struct {
	// Display overlay object with fade animation.
	// Structure is documented below.
	AnimationFade *JobConfigOverlayAnimationAnimationFade `pulumi:"animationFade"`
}

type JobConfigOverlayAnimationAnimationFade 

type JobConfigOverlayAnimationAnimationFade struct {
	// The time to end the fade animation, in seconds.
	EndTimeOffset *string `pulumi:"endTimeOffset"`
	// Required. Type of fade animation: `FADE_IN` or `FADE_OUT`.
	// The possible values are:
	// * `FADE_TYPE_UNSPECIFIED`: The fade type is not specified.
	// * `FADE_IN`: Fade the overlay object into view.
	// * `FADE_OUT`: Fade the overlay object out of view.
	//   Possible values are: `FADE_TYPE_UNSPECIFIED`, `FADE_IN`, `FADE_OUT`.
	FadeType string `pulumi:"fadeType"`
	// The time to start the fade animation, in seconds.
	StartTimeOffset *string `pulumi:"startTimeOffset"`
	// Normalized coordinates based on output video resolution.
	// Structure is documented below.
	Xy *JobConfigOverlayAnimationAnimationFadeXy `pulumi:"xy"`
}

type JobConfigOverlayAnimationAnimationFadeArgs 

type JobConfigOverlayAnimationAnimationFadeArgs struct {
	// The time to end the fade animation, in seconds.
	EndTimeOffset pulumi.StringPtrInput `pulumi:"endTimeOffset"`
	// Required. Type of fade animation: `FADE_IN` or `FADE_OUT`.
	// The possible values are:
	// * `FADE_TYPE_UNSPECIFIED`: The fade type is not specified.
	// * `FADE_IN`: Fade the overlay object into view.
	// * `FADE_OUT`: Fade the overlay object out of view.
	//   Possible values are: `FADE_TYPE_UNSPECIFIED`, `FADE_IN`, `FADE_OUT`.
	FadeType pulumi.StringInput `pulumi:"fadeType"`
	// The time to start the fade animation, in seconds.
	StartTimeOffset pulumi.StringPtrInput `pulumi:"startTimeOffset"`
	// Normalized coordinates based on output video resolution.
	// Structure is documented below.
	Xy JobConfigOverlayAnimationAnimationFadeXyPtrInput `pulumi:"xy"`
}

func (JobConfigOverlayAnimationAnimationFadeArgs) ElementType 

func (JobConfigOverlayAnimationAnimationFadeArgs) ElementType() reflect.Type

func (JobConfigOverlayAnimationAnimationFadeArgs) ToJobConfigOverlayAnimationAnimationFadeOutput 

func (i JobConfigOverlayAnimationAnimationFadeArgs) ToJobConfigOverlayAnimationAnimationFadeOutput() JobConfigOverlayAnimationAnimationFadeOutput

func (JobConfigOverlayAnimationAnimationFadeArgs) ToJobConfigOverlayAnimationAnimationFadeOutputWithContext 

func (i JobConfigOverlayAnimationAnimationFadeArgs) ToJobConfigOverlayAnimationAnimationFadeOutputWithContext(ctx context.Context) JobConfigOverlayAnimationAnimationFadeOutput

func (JobConfigOverlayAnimationAnimationFadeArgs) ToJobConfigOverlayAnimationAnimationFadePtrOutput 

func (i JobConfigOverlayAnimationAnimationFadeArgs) ToJobConfigOverlayAnimationAnimationFadePtrOutput() JobConfigOverlayAnimationAnimationFadePtrOutput

func (JobConfigOverlayAnimationAnimationFadeArgs) ToJobConfigOverlayAnimationAnimationFadePtrOutputWithContext 

func (i JobConfigOverlayAnimationAnimationFadeArgs) ToJobConfigOverlayAnimationAnimationFadePtrOutputWithContext(ctx context.Context) JobConfigOverlayAnimationAnimationFadePtrOutput

type JobConfigOverlayAnimationAnimationFadeInput 

type JobConfigOverlayAnimationAnimationFadeInput interface {
	pulumi.Input

	ToJobConfigOverlayAnimationAnimationFadeOutput() JobConfigOverlayAnimationAnimationFadeOutput
	ToJobConfigOverlayAnimationAnimationFadeOutputWithContext(context.Context) JobConfigOverlayAnimationAnimationFadeOutput
}

JobConfigOverlayAnimationAnimationFadeInput is an input type that accepts JobConfigOverlayAnimationAnimationFadeArgs and JobConfigOverlayAnimationAnimationFadeOutput values. You can construct a concrete instance of `JobConfigOverlayAnimationAnimationFadeInput` via: 

JobConfigOverlayAnimationAnimationFadeArgs{...}

type JobConfigOverlayAnimationAnimationFadeOutput 

type JobConfigOverlayAnimationAnimationFadeOutput struct{ *pulumi.OutputState }

func (JobConfigOverlayAnimationAnimationFadeOutput) ElementType 

func (JobConfigOverlayAnimationAnimationFadeOutput) ElementType() reflect.Type

func (JobConfigOverlayAnimationAnimationFadeOutput) EndTimeOffset 

func (o JobConfigOverlayAnimationAnimationFadeOutput) EndTimeOffset() pulumi.StringPtrOutput

The time to end the fade animation, in seconds.

func (JobConfigOverlayAnimationAnimationFadeOutput) FadeType 

func (o JobConfigOverlayAnimationAnimationFadeOutput) FadeType() pulumi.StringOutput

Required. Type of fade animation: `FADE_IN` or `FADE_OUT`. The possible values are:

  • `FADE_TYPE_UNSPECIFIED`: The fade type is not specified.
  • `FADE_IN`: Fade the overlay object into view.
  • `FADE_OUT`: Fade the overlay object out of view. Possible values are: `FADE_TYPE_UNSPECIFIED`, `FADE_IN`, `FADE_OUT`.

func (JobConfigOverlayAnimationAnimationFadeOutput) StartTimeOffset 

func (o JobConfigOverlayAnimationAnimationFadeOutput) StartTimeOffset() pulumi.StringPtrOutput

The time to start the fade animation, in seconds.

func (JobConfigOverlayAnimationAnimationFadeOutput) ToJobConfigOverlayAnimationAnimationFadeOutput 

func (o JobConfigOverlayAnimationAnimationFadeOutput) ToJobConfigOverlayAnimationAnimationFadeOutput() JobConfigOverlayAnimationAnimationFadeOutput

func (JobConfigOverlayAnimationAnimationFadeOutput) ToJobConfigOverlayAnimationAnimationFadeOutputWithContext 

func (o JobConfigOverlayAnimationAnimationFadeOutput) ToJobConfigOverlayAnimationAnimationFadeOutputWithContext(ctx context.Context) JobConfigOverlayAnimationAnimationFadeOutput

func (JobConfigOverlayAnimationAnimationFadeOutput) ToJobConfigOverlayAnimationAnimationFadePtrOutput 

func (o JobConfigOverlayAnimationAnimationFadeOutput) ToJobConfigOverlayAnimationAnimationFadePtrOutput() JobConfigOverlayAnimationAnimationFadePtrOutput

func (JobConfigOverlayAnimationAnimationFadeOutput) ToJobConfigOverlayAnimationAnimationFadePtrOutputWithContext 

func (o JobConfigOverlayAnimationAnimationFadeOutput) ToJobConfigOverlayAnimationAnimationFadePtrOutputWithContext(ctx context.Context) JobConfigOverlayAnimationAnimationFadePtrOutput

func (JobConfigOverlayAnimationAnimationFadeOutput) Xy 

func (o JobConfigOverlayAnimationAnimationFadeOutput) Xy() JobConfigOverlayAnimationAnimationFadeXyPtrOutput

Normalized coordinates based on output video resolution. Structure is documented below.

type JobConfigOverlayAnimationAnimationFadePtrInput 

type JobConfigOverlayAnimationAnimationFadePtrInput interface {
	pulumi.Input

	ToJobConfigOverlayAnimationAnimationFadePtrOutput() JobConfigOverlayAnimationAnimationFadePtrOutput
	ToJobConfigOverlayAnimationAnimationFadePtrOutputWithContext(context.Context) JobConfigOverlayAnimationAnimationFadePtrOutput
}

JobConfigOverlayAnimationAnimationFadePtrInput is an input type that accepts JobConfigOverlayAnimationAnimationFadeArgs, JobConfigOverlayAnimationAnimationFadePtr and JobConfigOverlayAnimationAnimationFadePtrOutput values. You can construct a concrete instance of `JobConfigOverlayAnimationAnimationFadePtrInput` via: 

        JobConfigOverlayAnimationAnimationFadeArgs{...}

or:

        nil

func JobConfigOverlayAnimationAnimationFadePtr 

func JobConfigOverlayAnimationAnimationFadePtr(v *JobConfigOverlayAnimationAnimationFadeArgs) JobConfigOverlayAnimationAnimationFadePtrInput

type JobConfigOverlayAnimationAnimationFadePtrOutput 

type JobConfigOverlayAnimationAnimationFadePtrOutput struct{ *pulumi.OutputState }

func (JobConfigOverlayAnimationAnimationFadePtrOutput) Elem 

func (o JobConfigOverlayAnimationAnimationFadePtrOutput) Elem() JobConfigOverlayAnimationAnimationFadeOutput

func (JobConfigOverlayAnimationAnimationFadePtrOutput) ElementType 

func (JobConfigOverlayAnimationAnimationFadePtrOutput) ElementType() reflect.Type

func (JobConfigOverlayAnimationAnimationFadePtrOutput) EndTimeOffset 

func (o JobConfigOverlayAnimationAnimationFadePtrOutput) EndTimeOffset() pulumi.StringPtrOutput

The time to end the fade animation, in seconds.

func (JobConfigOverlayAnimationAnimationFadePtrOutput) FadeType 

func (o JobConfigOverlayAnimationAnimationFadePtrOutput) FadeType() pulumi.StringPtrOutput

Required. Type of fade animation: `FADE_IN` or `FADE_OUT`. The possible values are:

  • `FADE_TYPE_UNSPECIFIED`: The fade type is not specified.
  • `FADE_IN`: Fade the overlay object into view.
  • `FADE_OUT`: Fade the overlay object out of view. Possible values are: `FADE_TYPE_UNSPECIFIED`, `FADE_IN`, `FADE_OUT`.

func (JobConfigOverlayAnimationAnimationFadePtrOutput) StartTimeOffset 

func (o JobConfigOverlayAnimationAnimationFadePtrOutput) StartTimeOffset() pulumi.StringPtrOutput

The time to start the fade animation, in seconds.

func (JobConfigOverlayAnimationAnimationFadePtrOutput) ToJobConfigOverlayAnimationAnimationFadePtrOutput 

func (o JobConfigOverlayAnimationAnimationFadePtrOutput) ToJobConfigOverlayAnimationAnimationFadePtrOutput() JobConfigOverlayAnimationAnimationFadePtrOutput

func (JobConfigOverlayAnimationAnimationFadePtrOutput) ToJobConfigOverlayAnimationAnimationFadePtrOutputWithContext 

func (o JobConfigOverlayAnimationAnimationFadePtrOutput) ToJobConfigOverlayAnimationAnimationFadePtrOutputWithContext(ctx context.Context) JobConfigOverlayAnimationAnimationFadePtrOutput

func (JobConfigOverlayAnimationAnimationFadePtrOutput) Xy 

func (o JobConfigOverlayAnimationAnimationFadePtrOutput) Xy() JobConfigOverlayAnimationAnimationFadeXyPtrOutput

Normalized coordinates based on output video resolution. Structure is documented below.

type JobConfigOverlayAnimationAnimationFadeXy 

type JobConfigOverlayAnimationAnimationFadeXy struct {
	// Normalized x coordinate.
	X *float64 `pulumi:"x"`
	// Normalized y coordinate.
	Y *float64 `pulumi:"y"`
}

type JobConfigOverlayAnimationAnimationFadeXyArgs 

type JobConfigOverlayAnimationAnimationFadeXyArgs struct {
	// Normalized x coordinate.
	X pulumi.Float64PtrInput `pulumi:"x"`
	// Normalized y coordinate.
	Y pulumi.Float64PtrInput `pulumi:"y"`
}

func (JobConfigOverlayAnimationAnimationFadeXyArgs) ElementType 

func (JobConfigOverlayAnimationAnimationFadeXyArgs) ElementType() reflect.Type

func (JobConfigOverlayAnimationAnimationFadeXyArgs) ToJobConfigOverlayAnimationAnimationFadeXyOutput 

func (i JobConfigOverlayAnimationAnimationFadeXyArgs) ToJobConfigOverlayAnimationAnimationFadeXyOutput() JobConfigOverlayAnimationAnimationFadeXyOutput

func (JobConfigOverlayAnimationAnimationFadeXyArgs) ToJobConfigOverlayAnimationAnimationFadeXyOutputWithContext 

func (i JobConfigOverlayAnimationAnimationFadeXyArgs) ToJobConfigOverlayAnimationAnimationFadeXyOutputWithContext(ctx context.Context) JobConfigOverlayAnimationAnimationFadeXyOutput

func (JobConfigOverlayAnimationAnimationFadeXyArgs) ToJobConfigOverlayAnimationAnimationFadeXyPtrOutput 

func (i JobConfigOverlayAnimationAnimationFadeXyArgs) ToJobConfigOverlayAnimationAnimationFadeXyPtrOutput() JobConfigOverlayAnimationAnimationFadeXyPtrOutput

func (JobConfigOverlayAnimationAnimationFadeXyArgs) ToJobConfigOverlayAnimationAnimationFadeXyPtrOutputWithContext 

func (i JobConfigOverlayAnimationAnimationFadeXyArgs) ToJobConfigOverlayAnimationAnimationFadeXyPtrOutputWithContext(ctx context.Context) JobConfigOverlayAnimationAnimationFadeXyPtrOutput

type JobConfigOverlayAnimationAnimationFadeXyInput 

type JobConfigOverlayAnimationAnimationFadeXyInput interface {
	pulumi.Input

	ToJobConfigOverlayAnimationAnimationFadeXyOutput() JobConfigOverlayAnimationAnimationFadeXyOutput
	ToJobConfigOverlayAnimationAnimationFadeXyOutputWithContext(context.Context) JobConfigOverlayAnimationAnimationFadeXyOutput
}

JobConfigOverlayAnimationAnimationFadeXyInput is an input type that accepts JobConfigOverlayAnimationAnimationFadeXyArgs and JobConfigOverlayAnimationAnimationFadeXyOutput values. You can construct a concrete instance of `JobConfigOverlayAnimationAnimationFadeXyInput` via: 

JobConfigOverlayAnimationAnimationFadeXyArgs{...}

type JobConfigOverlayAnimationAnimationFadeXyOutput 

type JobConfigOverlayAnimationAnimationFadeXyOutput struct{ *pulumi.OutputState }

func (JobConfigOverlayAnimationAnimationFadeXyOutput) ElementType 

func (JobConfigOverlayAnimationAnimationFadeXyOutput) ElementType() reflect.Type

func (JobConfigOverlayAnimationAnimationFadeXyOutput) ToJobConfigOverlayAnimationAnimationFadeXyOutput 

func (o JobConfigOverlayAnimationAnimationFadeXyOutput) ToJobConfigOverlayAnimationAnimationFadeXyOutput() JobConfigOverlayAnimationAnimationFadeXyOutput

func (JobConfigOverlayAnimationAnimationFadeXyOutput) ToJobConfigOverlayAnimationAnimationFadeXyOutputWithContext 

func (o JobConfigOverlayAnimationAnimationFadeXyOutput) ToJobConfigOverlayAnimationAnimationFadeXyOutputWithContext(ctx context.Context) JobConfigOverlayAnimationAnimationFadeXyOutput

func (JobConfigOverlayAnimationAnimationFadeXyOutput) ToJobConfigOverlayAnimationAnimationFadeXyPtrOutput 

func (o JobConfigOverlayAnimationAnimationFadeXyOutput) ToJobConfigOverlayAnimationAnimationFadeXyPtrOutput() JobConfigOverlayAnimationAnimationFadeXyPtrOutput

func (JobConfigOverlayAnimationAnimationFadeXyOutput) ToJobConfigOverlayAnimationAnimationFadeXyPtrOutputWithContext 

func (o JobConfigOverlayAnimationAnimationFadeXyOutput) ToJobConfigOverlayAnimationAnimationFadeXyPtrOutputWithContext(ctx context.Context) JobConfigOverlayAnimationAnimationFadeXyPtrOutput

func (JobConfigOverlayAnimationAnimationFadeXyOutput) X 

func (o JobConfigOverlayAnimationAnimationFadeXyOutput) X() pulumi.Float64PtrOutput

Normalized x coordinate.

func (JobConfigOverlayAnimationAnimationFadeXyOutput) Y 

func (o JobConfigOverlayAnimationAnimationFadeXyOutput) Y() pulumi.Float64PtrOutput

Normalized y coordinate.

type JobConfigOverlayAnimationAnimationFadeXyPtrInput 

type JobConfigOverlayAnimationAnimationFadeXyPtrInput interface {
	pulumi.Input

	ToJobConfigOverlayAnimationAnimationFadeXyPtrOutput() JobConfigOverlayAnimationAnimationFadeXyPtrOutput
	ToJobConfigOverlayAnimationAnimationFadeXyPtrOutputWithContext(context.Context) JobConfigOverlayAnimationAnimationFadeXyPtrOutput
}

JobConfigOverlayAnimationAnimationFadeXyPtrInput is an input type that accepts JobConfigOverlayAnimationAnimationFadeXyArgs, JobConfigOverlayAnimationAnimationFadeXyPtr and JobConfigOverlayAnimationAnimationFadeXyPtrOutput values. You can construct a concrete instance of `JobConfigOverlayAnimationAnimationFadeXyPtrInput` via: 

        JobConfigOverlayAnimationAnimationFadeXyArgs{...}

or:

        nil

func JobConfigOverlayAnimationAnimationFadeXyPtr 

func JobConfigOverlayAnimationAnimationFadeXyPtr(v *JobConfigOverlayAnimationAnimationFadeXyArgs) JobConfigOverlayAnimationAnimationFadeXyPtrInput

type JobConfigOverlayAnimationAnimationFadeXyPtrOutput 

type JobConfigOverlayAnimationAnimationFadeXyPtrOutput struct{ *pulumi.OutputState }

func (JobConfigOverlayAnimationAnimationFadeXyPtrOutput) Elem 

func (o JobConfigOverlayAnimationAnimationFadeXyPtrOutput) Elem() JobConfigOverlayAnimationAnimationFadeXyOutput

func (JobConfigOverlayAnimationAnimationFadeXyPtrOutput) ElementType 

func (JobConfigOverlayAnimationAnimationFadeXyPtrOutput) ElementType() reflect.Type

func (JobConfigOverlayAnimationAnimationFadeXyPtrOutput) ToJobConfigOverlayAnimationAnimationFadeXyPtrOutput 

func (o JobConfigOverlayAnimationAnimationFadeXyPtrOutput) ToJobConfigOverlayAnimationAnimationFadeXyPtrOutput() JobConfigOverlayAnimationAnimationFadeXyPtrOutput

func (JobConfigOverlayAnimationAnimationFadeXyPtrOutput) ToJobConfigOverlayAnimationAnimationFadeXyPtrOutputWithContext 

func (o JobConfigOverlayAnimationAnimationFadeXyPtrOutput) ToJobConfigOverlayAnimationAnimationFadeXyPtrOutputWithContext(ctx context.Context) JobConfigOverlayAnimationAnimationFadeXyPtrOutput

func (JobConfigOverlayAnimationAnimationFadeXyPtrOutput) X 

func (o JobConfigOverlayAnimationAnimationFadeXyPtrOutput) X() pulumi.Float64PtrOutput

Normalized x coordinate.

func (JobConfigOverlayAnimationAnimationFadeXyPtrOutput) Y 

func (o JobConfigOverlayAnimationAnimationFadeXyPtrOutput) Y() pulumi.Float64PtrOutput

Normalized y coordinate.

type JobConfigOverlayAnimationArgs 

type JobConfigOverlayAnimationArgs struct {
	// Display overlay object with fade animation.
	// Structure is documented below.
	AnimationFade JobConfigOverlayAnimationAnimationFadePtrInput `pulumi:"animationFade"`
}

func (JobConfigOverlayAnimationArgs) ElementType 

func (JobConfigOverlayAnimationArgs) ElementType() reflect.Type

func (JobConfigOverlayAnimationArgs) ToJobConfigOverlayAnimationOutput 

func (i JobConfigOverlayAnimationArgs) ToJobConfigOverlayAnimationOutput() JobConfigOverlayAnimationOutput

func (JobConfigOverlayAnimationArgs) ToJobConfigOverlayAnimationOutputWithContext 

func (i JobConfigOverlayAnimationArgs) ToJobConfigOverlayAnimationOutputWithContext(ctx context.Context) JobConfigOverlayAnimationOutput

type JobConfigOverlayAnimationArray 

type JobConfigOverlayAnimationArray []JobConfigOverlayAnimationInput

func (JobConfigOverlayAnimationArray) ElementType 

func (JobConfigOverlayAnimationArray) ElementType() reflect.Type

func (JobConfigOverlayAnimationArray) ToJobConfigOverlayAnimationArrayOutput 

func (i JobConfigOverlayAnimationArray) ToJobConfigOverlayAnimationArrayOutput() JobConfigOverlayAnimationArrayOutput

func (JobConfigOverlayAnimationArray) ToJobConfigOverlayAnimationArrayOutputWithContext 

func (i JobConfigOverlayAnimationArray) ToJobConfigOverlayAnimationArrayOutputWithContext(ctx context.Context) JobConfigOverlayAnimationArrayOutput

type JobConfigOverlayAnimationArrayInput 

type JobConfigOverlayAnimationArrayInput interface {
	pulumi.Input

	ToJobConfigOverlayAnimationArrayOutput() JobConfigOverlayAnimationArrayOutput
	ToJobConfigOverlayAnimationArrayOutputWithContext(context.Context) JobConfigOverlayAnimationArrayOutput
}

JobConfigOverlayAnimationArrayInput is an input type that accepts JobConfigOverlayAnimationArray and JobConfigOverlayAnimationArrayOutput values. You can construct a concrete instance of `JobConfigOverlayAnimationArrayInput` via: 

JobConfigOverlayAnimationArray{ JobConfigOverlayAnimationArgs{...} }

type JobConfigOverlayAnimationArrayOutput 

type JobConfigOverlayAnimationArrayOutput struct{ *pulumi.OutputState }

func (JobConfigOverlayAnimationArrayOutput) ElementType 

func (JobConfigOverlayAnimationArrayOutput) ElementType() reflect.Type

func (JobConfigOverlayAnimationArrayOutput) Index 

func (o JobConfigOverlayAnimationArrayOutput) Index(i pulumi.IntInput) JobConfigOverlayAnimationOutput

func (JobConfigOverlayAnimationArrayOutput) ToJobConfigOverlayAnimationArrayOutput 

func (o JobConfigOverlayAnimationArrayOutput) ToJobConfigOverlayAnimationArrayOutput() JobConfigOverlayAnimationArrayOutput

func (JobConfigOverlayAnimationArrayOutput) ToJobConfigOverlayAnimationArrayOutputWithContext 

func (o JobConfigOverlayAnimationArrayOutput) ToJobConfigOverlayAnimationArrayOutputWithContext(ctx context.Context) JobConfigOverlayAnimationArrayOutput

type JobConfigOverlayAnimationInput 

type JobConfigOverlayAnimationInput interface {
	pulumi.Input

	ToJobConfigOverlayAnimationOutput() JobConfigOverlayAnimationOutput
	ToJobConfigOverlayAnimationOutputWithContext(context.Context) JobConfigOverlayAnimationOutput
}

JobConfigOverlayAnimationInput is an input type that accepts JobConfigOverlayAnimationArgs and JobConfigOverlayAnimationOutput values. You can construct a concrete instance of `JobConfigOverlayAnimationInput` via: 

JobConfigOverlayAnimationArgs{...}

type JobConfigOverlayAnimationOutput 

type JobConfigOverlayAnimationOutput struct{ *pulumi.OutputState }

func (JobConfigOverlayAnimationOutput) AnimationFade 

func (o JobConfigOverlayAnimationOutput) AnimationFade() JobConfigOverlayAnimationAnimationFadePtrOutput

Display overlay object with fade animation. Structure is documented below.

func (JobConfigOverlayAnimationOutput) ElementType 

func (JobConfigOverlayAnimationOutput) ElementType() reflect.Type

func (JobConfigOverlayAnimationOutput) ToJobConfigOverlayAnimationOutput 

func (o JobConfigOverlayAnimationOutput) ToJobConfigOverlayAnimationOutput() JobConfigOverlayAnimationOutput

func (JobConfigOverlayAnimationOutput) ToJobConfigOverlayAnimationOutputWithContext 

func (o JobConfigOverlayAnimationOutput) ToJobConfigOverlayAnimationOutputWithContext(ctx context.Context) JobConfigOverlayAnimationOutput

type JobConfigOverlayArgs 

type JobConfigOverlayArgs struct {
	// List of animations. The list should be chronological, without any time overlap.
	// Structure is documented below.
	Animations JobConfigOverlayAnimationArrayInput `pulumi:"animations"`
	// Image overlay.
	// Structure is documented below.
	Image JobConfigOverlayImagePtrInput `pulumi:"image"`
}

func (JobConfigOverlayArgs) ElementType 

func (JobConfigOverlayArgs) ElementType() reflect.Type

func (JobConfigOverlayArgs) ToJobConfigOverlayOutput 

func (i JobConfigOverlayArgs) ToJobConfigOverlayOutput() JobConfigOverlayOutput

func (JobConfigOverlayArgs) ToJobConfigOverlayOutputWithContext 

func (i JobConfigOverlayArgs) ToJobConfigOverlayOutputWithContext(ctx context.Context) JobConfigOverlayOutput

type JobConfigOverlayArray 

type JobConfigOverlayArray []JobConfigOverlayInput

func (JobConfigOverlayArray) ElementType 

func (JobConfigOverlayArray) ElementType() reflect.Type

func (JobConfigOverlayArray) ToJobConfigOverlayArrayOutput 

func (i JobConfigOverlayArray) ToJobConfigOverlayArrayOutput() JobConfigOverlayArrayOutput

func (JobConfigOverlayArray) ToJobConfigOverlayArrayOutputWithContext 

func (i JobConfigOverlayArray) ToJobConfigOverlayArrayOutputWithContext(ctx context.Context) JobConfigOverlayArrayOutput

type JobConfigOverlayArrayInput 

type JobConfigOverlayArrayInput interface {
	pulumi.Input

	ToJobConfigOverlayArrayOutput() JobConfigOverlayArrayOutput
	ToJobConfigOverlayArrayOutputWithContext(context.Context) JobConfigOverlayArrayOutput
}

JobConfigOverlayArrayInput is an input type that accepts JobConfigOverlayArray and JobConfigOverlayArrayOutput values. You can construct a concrete instance of `JobConfigOverlayArrayInput` via: 

JobConfigOverlayArray{ JobConfigOverlayArgs{...} }

type JobConfigOverlayArrayOutput 

type JobConfigOverlayArrayOutput struct{ *pulumi.OutputState }

func (JobConfigOverlayArrayOutput) ElementType 

func (JobConfigOverlayArrayOutput) ElementType() reflect.Type

func (JobConfigOverlayArrayOutput) Index 

func (o JobConfigOverlayArrayOutput) Index(i pulumi.IntInput) JobConfigOverlayOutput

func (JobConfigOverlayArrayOutput) ToJobConfigOverlayArrayOutput 

func (o JobConfigOverlayArrayOutput) ToJobConfigOverlayArrayOutput() JobConfigOverlayArrayOutput

func (JobConfigOverlayArrayOutput) ToJobConfigOverlayArrayOutputWithContext 

func (o JobConfigOverlayArrayOutput) ToJobConfigOverlayArrayOutputWithContext(ctx context.Context) JobConfigOverlayArrayOutput

type JobConfigOverlayImage 

type JobConfigOverlayImage struct {
	// URI of the image in Cloud Storage. For example, gs://bucket/inputs/image.png.
	Uri string `pulumi:"uri"`
}

type JobConfigOverlayImageArgs 

type JobConfigOverlayImageArgs struct {
	// URI of the image in Cloud Storage. For example, gs://bucket/inputs/image.png.
	Uri pulumi.StringInput `pulumi:"uri"`
}

func (JobConfigOverlayImageArgs) ElementType 

func (JobConfigOverlayImageArgs) ElementType() reflect.Type

func (JobConfigOverlayImageArgs) ToJobConfigOverlayImageOutput 

func (i JobConfigOverlayImageArgs) ToJobConfigOverlayImageOutput() JobConfigOverlayImageOutput

func (JobConfigOverlayImageArgs) ToJobConfigOverlayImageOutputWithContext 

func (i JobConfigOverlayImageArgs) ToJobConfigOverlayImageOutputWithContext(ctx context.Context) JobConfigOverlayImageOutput

func (JobConfigOverlayImageArgs) ToJobConfigOverlayImagePtrOutput 

func (i JobConfigOverlayImageArgs) ToJobConfigOverlayImagePtrOutput() JobConfigOverlayImagePtrOutput

func (JobConfigOverlayImageArgs) ToJobConfigOverlayImagePtrOutputWithContext 

func (i JobConfigOverlayImageArgs) ToJobConfigOverlayImagePtrOutputWithContext(ctx context.Context) JobConfigOverlayImagePtrOutput

type JobConfigOverlayImageInput 

type JobConfigOverlayImageInput interface {
	pulumi.Input

	ToJobConfigOverlayImageOutput() JobConfigOverlayImageOutput
	ToJobConfigOverlayImageOutputWithContext(context.Context) JobConfigOverlayImageOutput
}

JobConfigOverlayImageInput is an input type that accepts JobConfigOverlayImageArgs and JobConfigOverlayImageOutput values. You can construct a concrete instance of `JobConfigOverlayImageInput` via: 

JobConfigOverlayImageArgs{...}

type JobConfigOverlayImageOutput 

type JobConfigOverlayImageOutput struct{ *pulumi.OutputState }

func (JobConfigOverlayImageOutput) ElementType 

func (JobConfigOverlayImageOutput) ElementType() reflect.Type

func (JobConfigOverlayImageOutput) ToJobConfigOverlayImageOutput 

func (o JobConfigOverlayImageOutput) ToJobConfigOverlayImageOutput() JobConfigOverlayImageOutput

func (JobConfigOverlayImageOutput) ToJobConfigOverlayImageOutputWithContext 

func (o JobConfigOverlayImageOutput) ToJobConfigOverlayImageOutputWithContext(ctx context.Context) JobConfigOverlayImageOutput

func (JobConfigOverlayImageOutput) ToJobConfigOverlayImagePtrOutput 

func (o JobConfigOverlayImageOutput) ToJobConfigOverlayImagePtrOutput() JobConfigOverlayImagePtrOutput

func (JobConfigOverlayImageOutput) ToJobConfigOverlayImagePtrOutputWithContext 

func (o JobConfigOverlayImageOutput) ToJobConfigOverlayImagePtrOutputWithContext(ctx context.Context) JobConfigOverlayImagePtrOutput

func (JobConfigOverlayImageOutput) Uri 

func (o JobConfigOverlayImageOutput) Uri() pulumi.StringOutput

URI of the image in Cloud Storage. For example, gs://bucket/inputs/image.png.

type JobConfigOverlayImagePtrInput 

type JobConfigOverlayImagePtrInput interface {
	pulumi.Input

	ToJobConfigOverlayImagePtrOutput() JobConfigOverlayImagePtrOutput
	ToJobConfigOverlayImagePtrOutputWithContext(context.Context) JobConfigOverlayImagePtrOutput
}

JobConfigOverlayImagePtrInput is an input type that accepts JobConfigOverlayImageArgs, JobConfigOverlayImagePtr and JobConfigOverlayImagePtrOutput values. You can construct a concrete instance of `JobConfigOverlayImagePtrInput` via: 

        JobConfigOverlayImageArgs{...}

or:

        nil

func JobConfigOverlayImagePtr 

func JobConfigOverlayImagePtr(v *JobConfigOverlayImageArgs) JobConfigOverlayImagePtrInput

type JobConfigOverlayImagePtrOutput 

type JobConfigOverlayImagePtrOutput struct{ *pulumi.OutputState }

func (JobConfigOverlayImagePtrOutput) Elem 

func (o JobConfigOverlayImagePtrOutput) Elem() JobConfigOverlayImageOutput

func (JobConfigOverlayImagePtrOutput) ElementType 

func (JobConfigOverlayImagePtrOutput) ElementType() reflect.Type

func (JobConfigOverlayImagePtrOutput) ToJobConfigOverlayImagePtrOutput 

func (o JobConfigOverlayImagePtrOutput) ToJobConfigOverlayImagePtrOutput() JobConfigOverlayImagePtrOutput

func (JobConfigOverlayImagePtrOutput) ToJobConfigOverlayImagePtrOutputWithContext 

func (o JobConfigOverlayImagePtrOutput) ToJobConfigOverlayImagePtrOutputWithContext(ctx context.Context) JobConfigOverlayImagePtrOutput

func (JobConfigOverlayImagePtrOutput) Uri 

func (o JobConfigOverlayImagePtrOutput) Uri() pulumi.StringPtrOutput

URI of the image in Cloud Storage. For example, gs://bucket/inputs/image.png.

type JobConfigOverlayInput 

type JobConfigOverlayInput interface {
	pulumi.Input

	ToJobConfigOverlayOutput() JobConfigOverlayOutput
	ToJobConfigOverlayOutputWithContext(context.Context) JobConfigOverlayOutput
}

JobConfigOverlayInput is an input type that accepts JobConfigOverlayArgs and JobConfigOverlayOutput values. You can construct a concrete instance of `JobConfigOverlayInput` via: 

JobConfigOverlayArgs{...}

type JobConfigOverlayOutput 

type JobConfigOverlayOutput struct{ *pulumi.OutputState }

func (JobConfigOverlayOutput) Animations 

func (o JobConfigOverlayOutput) Animations() JobConfigOverlayAnimationArrayOutput

List of animations. The list should be chronological, without any time overlap. Structure is documented below.

func (JobConfigOverlayOutput) ElementType 

func (JobConfigOverlayOutput) ElementType() reflect.Type

func (JobConfigOverlayOutput) Image 

func (o JobConfigOverlayOutput) Image() JobConfigOverlayImagePtrOutput

Image overlay. Structure is documented below.

func (JobConfigOverlayOutput) ToJobConfigOverlayOutput 

func (o JobConfigOverlayOutput) ToJobConfigOverlayOutput() JobConfigOverlayOutput

func (JobConfigOverlayOutput) ToJobConfigOverlayOutputWithContext 

func (o JobConfigOverlayOutput) ToJobConfigOverlayOutputWithContext(ctx context.Context) JobConfigOverlayOutput

type JobConfigPtrInput 

type JobConfigPtrInput interface {
	pulumi.Input

	ToJobConfigPtrOutput() JobConfigPtrOutput
	ToJobConfigPtrOutputWithContext(context.Context) JobConfigPtrOutput
}

JobConfigPtrInput is an input type that accepts JobConfigArgs, JobConfigPtr and JobConfigPtrOutput values. You can construct a concrete instance of `JobConfigPtrInput` via: 

        JobConfigArgs{...}

or:

        nil

func JobConfigPtr 

func JobConfigPtr(v *JobConfigArgs) JobConfigPtrInput

type JobConfigPtrOutput 

type JobConfigPtrOutput struct{ *pulumi.OutputState }

func (JobConfigPtrOutput) AdBreaks 

func (o JobConfigPtrOutput) AdBreaks() JobConfigAdBreakArrayOutput

Ad break. Structure is documented below.

func (JobConfigPtrOutput) EditLists 

func (o JobConfigPtrOutput) EditLists() JobConfigEditListArrayOutput

List of input assets stored in Cloud Storage. Structure is documented below.

func (JobConfigPtrOutput) Elem 

func (o JobConfigPtrOutput) Elem() JobConfigOutput

func (JobConfigPtrOutput) ElementType 

func (JobConfigPtrOutput) ElementType() reflect.Type

func (JobConfigPtrOutput) ElementaryStreams 

func (o JobConfigPtrOutput) ElementaryStreams() JobConfigElementaryStreamArrayOutput

List of input assets stored in Cloud Storage. Structure is documented below.

func (JobConfigPtrOutput) Encryptions 

func (o JobConfigPtrOutput) Encryptions() JobConfigEncryptionArrayOutput

List of encryption configurations for the content. Structure is documented below.

func (JobConfigPtrOutput) Inputs 

func (o JobConfigPtrOutput) Inputs() JobConfigInputTypeArrayOutput

List of input assets stored in Cloud Storage. Structure is documented below.

func (JobConfigPtrOutput) Manifests 

func (o JobConfigPtrOutput) Manifests() JobConfigManifestArrayOutput

Manifest configuration. Structure is documented below.

func (JobConfigPtrOutput) MuxStreams 

func (o JobConfigPtrOutput) MuxStreams() JobConfigMuxStreamArrayOutput

Multiplexing settings for output stream. Structure is documented below.

func (JobConfigPtrOutput) Output 

func (o JobConfigPtrOutput) Output() JobConfigOutputTypePtrOutput

Location of output file(s) in a Cloud Storage bucket. Structure is documented below.

func (JobConfigPtrOutput) Overlays 

func (o JobConfigPtrOutput) Overlays() JobConfigOverlayArrayOutput

List of overlays on the output video, in descending Z-order. Structure is documented below.

func (JobConfigPtrOutput) PubsubDestination 

func (o JobConfigPtrOutput) PubsubDestination() JobConfigPubsubDestinationPtrOutput

Pub/Sub destination. Structure is documented below.

func (JobConfigPtrOutput) ToJobConfigPtrOutput 

func (o JobConfigPtrOutput) ToJobConfigPtrOutput() JobConfigPtrOutput

func (JobConfigPtrOutput) ToJobConfigPtrOutputWithContext 

func (o JobConfigPtrOutput) ToJobConfigPtrOutputWithContext(ctx context.Context) JobConfigPtrOutput

type JobConfigPubsubDestination 

type JobConfigPubsubDestination struct {
	// The name of the Pub/Sub topic to publish job completion notification to. For example: projects/{project}/topics/{topic}.
	Topic *string `pulumi:"topic"`
}

type JobConfigPubsubDestinationArgs 

type JobConfigPubsubDestinationArgs struct {
	// The name of the Pub/Sub topic to publish job completion notification to. For example: projects/{project}/topics/{topic}.
	Topic pulumi.StringPtrInput `pulumi:"topic"`
}

func (JobConfigPubsubDestinationArgs) ElementType 

func (JobConfigPubsubDestinationArgs) ElementType() reflect.Type

func (JobConfigPubsubDestinationArgs) ToJobConfigPubsubDestinationOutput 

func (i JobConfigPubsubDestinationArgs) ToJobConfigPubsubDestinationOutput() JobConfigPubsubDestinationOutput

func (JobConfigPubsubDestinationArgs) ToJobConfigPubsubDestinationOutputWithContext 

func (i JobConfigPubsubDestinationArgs) ToJobConfigPubsubDestinationOutputWithContext(ctx context.Context) JobConfigPubsubDestinationOutput

func (JobConfigPubsubDestinationArgs) ToJobConfigPubsubDestinationPtrOutput 

func (i JobConfigPubsubDestinationArgs) ToJobConfigPubsubDestinationPtrOutput() JobConfigPubsubDestinationPtrOutput

func (JobConfigPubsubDestinationArgs) ToJobConfigPubsubDestinationPtrOutputWithContext 

func (i JobConfigPubsubDestinationArgs) ToJobConfigPubsubDestinationPtrOutputWithContext(ctx context.Context) JobConfigPubsubDestinationPtrOutput

type JobConfigPubsubDestinationInput 

type JobConfigPubsubDestinationInput interface {
	pulumi.Input

	ToJobConfigPubsubDestinationOutput() JobConfigPubsubDestinationOutput
	ToJobConfigPubsubDestinationOutputWithContext(context.Context) JobConfigPubsubDestinationOutput
}

JobConfigPubsubDestinationInput is an input type that accepts JobConfigPubsubDestinationArgs and JobConfigPubsubDestinationOutput values. You can construct a concrete instance of `JobConfigPubsubDestinationInput` via: 

JobConfigPubsubDestinationArgs{...}

type JobConfigPubsubDestinationOutput 

type JobConfigPubsubDestinationOutput struct{ *pulumi.OutputState }

func (JobConfigPubsubDestinationOutput) ElementType 

func (JobConfigPubsubDestinationOutput) ElementType() reflect.Type

func (JobConfigPubsubDestinationOutput) ToJobConfigPubsubDestinationOutput 

func (o JobConfigPubsubDestinationOutput) ToJobConfigPubsubDestinationOutput() JobConfigPubsubDestinationOutput

func (JobConfigPubsubDestinationOutput) ToJobConfigPubsubDestinationOutputWithContext 

func (o JobConfigPubsubDestinationOutput) ToJobConfigPubsubDestinationOutputWithContext(ctx context.Context) JobConfigPubsubDestinationOutput

func (JobConfigPubsubDestinationOutput) ToJobConfigPubsubDestinationPtrOutput 

func (o JobConfigPubsubDestinationOutput) ToJobConfigPubsubDestinationPtrOutput() JobConfigPubsubDestinationPtrOutput

func (JobConfigPubsubDestinationOutput) ToJobConfigPubsubDestinationPtrOutputWithContext 

func (o JobConfigPubsubDestinationOutput) ToJobConfigPubsubDestinationPtrOutputWithContext(ctx context.Context) JobConfigPubsubDestinationPtrOutput

func (JobConfigPubsubDestinationOutput) Topic 

func (o JobConfigPubsubDestinationOutput) Topic() pulumi.StringPtrOutput

The name of the Pub/Sub topic to publish job completion notification to. For example: projects/{project}/topics/{topic}.

type JobConfigPubsubDestinationPtrInput 

type JobConfigPubsubDestinationPtrInput interface {
	pulumi.Input

	ToJobConfigPubsubDestinationPtrOutput() JobConfigPubsubDestinationPtrOutput
	ToJobConfigPubsubDestinationPtrOutputWithContext(context.Context) JobConfigPubsubDestinationPtrOutput
}

JobConfigPubsubDestinationPtrInput is an input type that accepts JobConfigPubsubDestinationArgs, JobConfigPubsubDestinationPtr and JobConfigPubsubDestinationPtrOutput values. You can construct a concrete instance of `JobConfigPubsubDestinationPtrInput` via: 

        JobConfigPubsubDestinationArgs{...}

or:

        nil

func JobConfigPubsubDestinationPtr 

func JobConfigPubsubDestinationPtr(v *JobConfigPubsubDestinationArgs) JobConfigPubsubDestinationPtrInput

type JobConfigPubsubDestinationPtrOutput 

type JobConfigPubsubDestinationPtrOutput struct{ *pulumi.OutputState }

func (JobConfigPubsubDestinationPtrOutput) Elem 

func (o JobConfigPubsubDestinationPtrOutput) Elem() JobConfigPubsubDestinationOutput

func (JobConfigPubsubDestinationPtrOutput) ElementType 

func (JobConfigPubsubDestinationPtrOutput) ElementType() reflect.Type

func (JobConfigPubsubDestinationPtrOutput) ToJobConfigPubsubDestinationPtrOutput 

func (o JobConfigPubsubDestinationPtrOutput) ToJobConfigPubsubDestinationPtrOutput() JobConfigPubsubDestinationPtrOutput

func (JobConfigPubsubDestinationPtrOutput) ToJobConfigPubsubDestinationPtrOutputWithContext 

func (o JobConfigPubsubDestinationPtrOutput) ToJobConfigPubsubDestinationPtrOutputWithContext(ctx context.Context) JobConfigPubsubDestinationPtrOutput

func (JobConfigPubsubDestinationPtrOutput) Topic 

func (o JobConfigPubsubDestinationPtrOutput) Topic() pulumi.StringPtrOutput

The name of the Pub/Sub topic to publish job completion notification to. For example: projects/{project}/topics/{topic}.

type JobInput 

type JobInput interface {
	pulumi.Input

	ToJobOutput() JobOutput
	ToJobOutputWithContext(ctx context.Context) JobOutput
}

type JobMap 

type JobMap map[string]JobInput

func (JobMap) ElementType 

func (JobMap) ElementType() reflect.Type

func (JobMap) ToJobMapOutput 

func (i JobMap) ToJobMapOutput() JobMapOutput

func (JobMap) ToJobMapOutputWithContext 

func (i JobMap) ToJobMapOutputWithContext(ctx context.Context) JobMapOutput

type JobMapInput 

type JobMapInput interface {
	pulumi.Input

	ToJobMapOutput() JobMapOutput
	ToJobMapOutputWithContext(context.Context) JobMapOutput
}

JobMapInput is an input type that accepts JobMap and JobMapOutput values. You can construct a concrete instance of `JobMapInput` via: 

JobMap{ "key": JobArgs{...} }

type JobMapOutput 

type JobMapOutput struct{ *pulumi.OutputState }

func (JobMapOutput) ElementType 

func (JobMapOutput) ElementType() reflect.Type

func (JobMapOutput) MapIndex 

func (o JobMapOutput) MapIndex(k pulumi.StringInput) JobOutput

func (JobMapOutput) ToJobMapOutput 

func (o JobMapOutput) ToJobMapOutput() JobMapOutput

func (JobMapOutput) ToJobMapOutputWithContext 

func (o JobMapOutput) ToJobMapOutputWithContext(ctx context.Context) JobMapOutput

type JobOutput 

type JobOutput struct{ *pulumi.OutputState }

func (JobOutput) Config 

func (o JobOutput) Config() JobConfigOutput

The configuration for this template. Structure is documented below.

func (JobOutput) CreateTime 

func (o JobOutput) CreateTime() pulumi.StringOutput

The time the job was created.

func (JobOutput) EffectiveLabels 

func (o JobOutput) EffectiveLabels() pulumi.StringMapOutput

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

func (JobOutput) ElementType 

func (JobOutput) ElementType() reflect.Type

func (JobOutput) EndTime 

func (o JobOutput) EndTime() pulumi.StringOutput

The time the transcoding finished.

func (JobOutput) Labels 

func (o JobOutput) Labels() pulumi.StringMapOutput

The labels associated with this job. You can use these to organize and group your jobs.

**Note**: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field `effectiveLabels` for all of the labels present on the resource.

func (JobOutput) Location 

func (o JobOutput) Location() pulumi.StringOutput

The location of the transcoding job resource.

***

func (JobOutput) Name 

func (o JobOutput) Name() pulumi.StringOutput

The resource name of the job.

func (JobOutput) Project 

func (o JobOutput) Project() pulumi.StringOutput

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

func (JobOutput) PulumiLabels 

func (o JobOutput) PulumiLabels() pulumi.StringMapOutput

The combination of labels configured directly on the resource and default labels configured on the provider.

func (JobOutput) StartTime 

func (o JobOutput) StartTime() pulumi.StringOutput

The time the transcoding started.

func (JobOutput) State 

func (o JobOutput) State() pulumi.StringOutput

The current state of the job.

func (JobOutput) TemplateId 

func (o JobOutput) TemplateId() pulumi.StringOutput

Specify the templateId to use for populating Job.config. The default is preset/web-hd, which is the only supported preset.

func (JobOutput) ToJobOutput 

func (o JobOutput) ToJobOutput() JobOutput

func (JobOutput) ToJobOutputWithContext 

func (o JobOutput) ToJobOutputWithContext(ctx context.Context) JobOutput

type JobState 

type JobState struct {
	// The configuration for this template.
	// Structure is documented below.
	Config JobConfigPtrInput
	// The time the job was created.
	CreateTime pulumi.StringPtrInput
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapInput
	// The time the transcoding finished.
	EndTime pulumi.StringPtrInput
	// The labels associated with this job. You can use these to organize and group your jobs.
	//
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the resource.
	Labels pulumi.StringMapInput
	// The location of the transcoding job resource.
	//
	// ***
	Location pulumi.StringPtrInput
	// The resource name of the job.
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapInput
	// The time the transcoding started.
	StartTime pulumi.StringPtrInput
	// The current state of the job.
	State pulumi.StringPtrInput
	// Specify the templateId to use for populating Job.config.
	// The default is preset/web-hd, which is the only supported preset.
	TemplateId pulumi.StringPtrInput
}

func (JobState) ElementType 

func (JobState) ElementType() reflect.Type

type JobTemplate 

type JobTemplate struct {
	pulumi.CustomResourceState

	// The configuration for this template.
	// Structure is documented below.
	Config JobTemplateConfigOutput `pulumi:"config"`
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapOutput `pulumi:"effectiveLabels"`
	// ID to use for the Transcoding job template.
	JobTemplateId pulumi.StringOutput `pulumi:"jobTemplateId"`
	// The labels associated with this job template. You can use these to organize and group your job templates.
	//
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the resource.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// The location of the transcoding job template resource.
	//
	// ***
	Location pulumi.StringOutput `pulumi:"location"`
	// The resource name of the job template.
	Name pulumi.StringOutput `pulumi:"name"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapOutput `pulumi:"pulumiLabels"`
}

Transcoding Job Template Resource

To get more information about JobTemplate, see:

* [API documentation](https://cloud.google.com/transcoder/docs/reference/rest/v1/projects.locations.jobTemplates) * How-to Guides

## Example Usage

### Transcoder Job Template Basic

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/transcoder"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := transcoder.NewJobTemplate(ctx, "default", &transcoder.JobTemplateArgs{
			JobTemplateId: pulumi.String("example-job-template"),
			Location:      pulumi.String("us-central1"),
			Config: &transcoder.JobTemplateConfigArgs{
				Inputs: transcoder.JobTemplateConfigInputTypeArray{
					&transcoder.JobTemplateConfigInputTypeArgs{
						Key: pulumi.String("input0"),
					},
				},
				EditLists: transcoder.JobTemplateConfigEditListArray{
					&transcoder.JobTemplateConfigEditListArgs{
						Key: pulumi.String("atom0"),
						Inputs: pulumi.StringArray{
							pulumi.String("input0"),
						},
						StartTimeOffset: pulumi.String("0s"),
					},
				},
				AdBreaks: transcoder.JobTemplateConfigAdBreakArray{
					&transcoder.JobTemplateConfigAdBreakArgs{
						StartTimeOffset: pulumi.String("3.500s"),
					},
				},
				ElementaryStreams: transcoder.JobTemplateConfigElementaryStreamArray{
					&transcoder.JobTemplateConfigElementaryStreamArgs{
						Key: pulumi.String("video-stream0"),
						VideoStream: &transcoder.JobTemplateConfigElementaryStreamVideoStreamArgs{
							H264: &transcoder.JobTemplateConfigElementaryStreamVideoStreamH264Args{
								WidthPixels:     pulumi.Int(640),
								HeightPixels:    pulumi.Int(360),
								BitrateBps:      pulumi.Int(550000),
								FrameRate:       pulumi.Int(60),
								PixelFormat:     pulumi.String("yuv420p"),
								RateControlMode: pulumi.String("vbr"),
								CrfLevel:        pulumi.Int(21),
								GopDuration:     pulumi.String("3s"),
								VbvSizeBits:     pulumi.Int(550000),
								VbvFullnessBits: pulumi.Int(495000),
								EntropyCoder:    pulumi.String("cabac"),
								Profile:         pulumi.String("high"),
								Preset:          pulumi.String("veryfast"),
							},
						},
					},
					&transcoder.JobTemplateConfigElementaryStreamArgs{
						Key: pulumi.String("video-stream1"),
						VideoStream: &transcoder.JobTemplateConfigElementaryStreamVideoStreamArgs{
							H264: &transcoder.JobTemplateConfigElementaryStreamVideoStreamH264Args{
								WidthPixels:     pulumi.Int(1280),
								HeightPixels:    pulumi.Int(720),
								BitrateBps:      pulumi.Int(550000),
								FrameRate:       pulumi.Int(60),
								PixelFormat:     pulumi.String("yuv420p"),
								RateControlMode: pulumi.String("vbr"),
								CrfLevel:        pulumi.Int(21),
								GopDuration:     pulumi.String("3s"),
								VbvSizeBits:     pulumi.Int(2500000),
								VbvFullnessBits: pulumi.Int(2250000),
								EntropyCoder:    pulumi.String("cabac"),
								Profile:         pulumi.String("high"),
								Preset:          pulumi.String("veryfast"),
							},
						},
					},
					&transcoder.JobTemplateConfigElementaryStreamArgs{
						Key: pulumi.String("audio-stream0"),
						AudioStream: &transcoder.JobTemplateConfigElementaryStreamAudioStreamArgs{
							Codec:        pulumi.String("aac"),
							BitrateBps:   pulumi.Int(64000),
							ChannelCount: pulumi.Int(2),
							ChannelLayouts: pulumi.StringArray{
								pulumi.String("fl"),
								pulumi.String("fr"),
							},
							SampleRateHertz: pulumi.Int(48000),
						},
					},
				},
				MuxStreams: transcoder.JobTemplateConfigMuxStreamArray{
					&transcoder.JobTemplateConfigMuxStreamArgs{
						Key:       pulumi.String("sd"),
						FileName:  pulumi.String("sd.mp4"),
						Container: pulumi.String("mp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream0"),
							pulumi.String("audio-stream0"),
						},
					},
					&transcoder.JobTemplateConfigMuxStreamArgs{
						Key:       pulumi.String("hd"),
						FileName:  pulumi.String("hd.mp4"),
						Container: pulumi.String("mp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream1"),
							pulumi.String("audio-stream0"),
						},
					},
				},
			},
			Labels: pulumi.StringMap{
				"label": pulumi.String("key"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Transcoder Job Template Overlays

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/transcoder"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := transcoder.NewJobTemplate(ctx, "default", &transcoder.JobTemplateArgs{
			JobTemplateId: pulumi.String("example-job-template"),
			Location:      pulumi.String("us-central1"),
			Config: &transcoder.JobTemplateConfigArgs{
				Inputs: transcoder.JobTemplateConfigInputTypeArray{
					&transcoder.JobTemplateConfigInputTypeArgs{
						Key: pulumi.String("input0"),
						Uri: pulumi.String("gs://example/example.mp4"),
					},
				},
				Output: &transcoder.JobTemplateConfigOutputTypeArgs{
					Uri: pulumi.String("gs://example/outputs/"),
				},
				EditLists: transcoder.JobTemplateConfigEditListArray{
					&transcoder.JobTemplateConfigEditListArgs{
						Key: pulumi.String("atom0"),
						Inputs: pulumi.StringArray{
							pulumi.String("input0"),
						},
						StartTimeOffset: pulumi.String("0s"),
					},
				},
				AdBreaks: transcoder.JobTemplateConfigAdBreakArray{
					&transcoder.JobTemplateConfigAdBreakArgs{
						StartTimeOffset: pulumi.String("3.500s"),
					},
				},
				Overlays: transcoder.JobTemplateConfigOverlayArray{
					&transcoder.JobTemplateConfigOverlayArgs{
						Animations: transcoder.JobTemplateConfigOverlayAnimationArray{
							&transcoder.JobTemplateConfigOverlayAnimationArgs{
								AnimationFade: &transcoder.JobTemplateConfigOverlayAnimationAnimationFadeArgs{
									FadeType:        pulumi.String("FADE_IN"),
									StartTimeOffset: pulumi.String("1.500s"),
									EndTimeOffset:   pulumi.String("3.500s"),
									Xy: &transcoder.JobTemplateConfigOverlayAnimationAnimationFadeXyArgs{
										X: pulumi.Float64(1),
										Y: pulumi.Float64(0.5),
									},
								},
							},
						},
						Image: &transcoder.JobTemplateConfigOverlayImageArgs{
							Uri: pulumi.String("gs://example/overlay.png"),
						},
					},
				},
				ElementaryStreams: transcoder.JobTemplateConfigElementaryStreamArray{
					&transcoder.JobTemplateConfigElementaryStreamArgs{
						Key: pulumi.String("video-stream0"),
						VideoStream: &transcoder.JobTemplateConfigElementaryStreamVideoStreamArgs{
							H264: &transcoder.JobTemplateConfigElementaryStreamVideoStreamH264Args{
								WidthPixels:     pulumi.Int(640),
								HeightPixels:    pulumi.Int(360),
								BitrateBps:      pulumi.Int(550000),
								FrameRate:       pulumi.Int(60),
								PixelFormat:     pulumi.String("yuv420p"),
								RateControlMode: pulumi.String("vbr"),
								CrfLevel:        pulumi.Int(21),
								GopDuration:     pulumi.String("3s"),
								VbvSizeBits:     pulumi.Int(550000),
								VbvFullnessBits: pulumi.Int(495000),
								EntropyCoder:    pulumi.String("cabac"),
								Profile:         pulumi.String("high"),
								Preset:          pulumi.String("veryfast"),
							},
						},
					},
					&transcoder.JobTemplateConfigElementaryStreamArgs{
						Key: pulumi.String("video-stream1"),
						VideoStream: &transcoder.JobTemplateConfigElementaryStreamVideoStreamArgs{
							H264: &transcoder.JobTemplateConfigElementaryStreamVideoStreamH264Args{
								WidthPixels:     pulumi.Int(1280),
								HeightPixels:    pulumi.Int(720),
								BitrateBps:      pulumi.Int(550000),
								FrameRate:       pulumi.Int(60),
								PixelFormat:     pulumi.String("yuv420p"),
								RateControlMode: pulumi.String("vbr"),
								CrfLevel:        pulumi.Int(21),
								GopDuration:     pulumi.String("3s"),
								VbvSizeBits:     pulumi.Int(2500000),
								VbvFullnessBits: pulumi.Int(2250000),
								EntropyCoder:    pulumi.String("cabac"),
								Profile:         pulumi.String("high"),
								Preset:          pulumi.String("veryfast"),
							},
						},
					},
					&transcoder.JobTemplateConfigElementaryStreamArgs{
						Key: pulumi.String("audio-stream0"),
						AudioStream: &transcoder.JobTemplateConfigElementaryStreamAudioStreamArgs{
							Codec:        pulumi.String("aac"),
							BitrateBps:   pulumi.Int(64000),
							ChannelCount: pulumi.Int(2),
							ChannelLayouts: pulumi.StringArray{
								pulumi.String("fl"),
								pulumi.String("fr"),
							},
							SampleRateHertz: pulumi.Int(48000),
						},
					},
				},
				MuxStreams: transcoder.JobTemplateConfigMuxStreamArray{
					&transcoder.JobTemplateConfigMuxStreamArgs{
						Key:       pulumi.String("sd"),
						FileName:  pulumi.String("sd.mp4"),
						Container: pulumi.String("mp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream0"),
							pulumi.String("audio-stream0"),
						},
					},
					&transcoder.JobTemplateConfigMuxStreamArgs{
						Key:       pulumi.String("hd"),
						FileName:  pulumi.String("hd.mp4"),
						Container: pulumi.String("mp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream1"),
							pulumi.String("audio-stream0"),
						},
					},
				},
			},
			Labels: pulumi.StringMap{
				"label": pulumi.String("key"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Transcoder Job Template Encryptions

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/secretmanager"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/transcoder"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		encryptionKey, err := secretmanager.NewSecret(ctx, "encryption_key", &secretmanager.SecretArgs{
			SecretId: pulumi.String("transcoder-encryption-key"),
			Replication: &secretmanager.SecretReplicationArgs{
				Auto: &secretmanager.SecretReplicationAutoArgs{},
			},
		})
		if err != nil {
			return err
		}
		encryptionKeySecretVersion, err := secretmanager.NewSecretVersion(ctx, "encryption_key", &secretmanager.SecretVersionArgs{
			Secret:     encryptionKey.Name,
			SecretData: pulumi.String("4A67F2C1B8E93A4F6D3E7890A1BC23DF"),
		})
		if err != nil {
			return err
		}
		_, err = transcoder.NewJobTemplate(ctx, "default", &transcoder.JobTemplateArgs{
			JobTemplateId: pulumi.String("example-job-template"),
			Location:      pulumi.String("us-central1"),
			Config: &transcoder.JobTemplateConfigArgs{
				ElementaryStreams: transcoder.JobTemplateConfigElementaryStreamArray{
					&transcoder.JobTemplateConfigElementaryStreamArgs{
						Key: pulumi.String("es_video"),
						VideoStream: &transcoder.JobTemplateConfigElementaryStreamVideoStreamArgs{
							H264: &transcoder.JobTemplateConfigElementaryStreamVideoStreamH264Args{
								Profile:      pulumi.String("main"),
								HeightPixels: pulumi.Int(600),
								WidthPixels:  pulumi.Int(800),
								BitrateBps:   pulumi.Int(1000000),
								FrameRate:    pulumi.Int(60),
							},
						},
					},
					&transcoder.JobTemplateConfigElementaryStreamArgs{
						Key: pulumi.String("es_audio"),
						AudioStream: &transcoder.JobTemplateConfigElementaryStreamAudioStreamArgs{
							Codec:        pulumi.String("aac"),
							ChannelCount: pulumi.Int(2),
							BitrateBps:   pulumi.Int(160000),
						},
					},
				},
				Encryptions: transcoder.JobTemplateConfigEncryptionArray{
					&transcoder.JobTemplateConfigEncryptionArgs{
						Id: pulumi.String("aes-128"),
						SecretManagerKeySource: &transcoder.JobTemplateConfigEncryptionSecretManagerKeySourceArgs{
							SecretVersion: encryptionKeySecretVersion.Name,
						},
						DrmSystems: &transcoder.JobTemplateConfigEncryptionDrmSystemsArgs{
							Clearkey: &transcoder.JobTemplateConfigEncryptionDrmSystemsClearkeyArgs{},
						},
						Aes128: &transcoder.JobTemplateConfigEncryptionAes128Args{},
					},
					&transcoder.JobTemplateConfigEncryptionArgs{
						Id: pulumi.String("cenc"),
						SecretManagerKeySource: &transcoder.JobTemplateConfigEncryptionSecretManagerKeySourceArgs{
							SecretVersion: encryptionKeySecretVersion.Name,
						},
						DrmSystems: &transcoder.JobTemplateConfigEncryptionDrmSystemsArgs{
							Widevine: &transcoder.JobTemplateConfigEncryptionDrmSystemsWidevineArgs{},
						},
						MpegCenc: &transcoder.JobTemplateConfigEncryptionMpegCencArgs{
							Scheme: pulumi.String("cenc"),
						},
					},
					&transcoder.JobTemplateConfigEncryptionArgs{
						Id: pulumi.String("cbcs"),
						SecretManagerKeySource: &transcoder.JobTemplateConfigEncryptionSecretManagerKeySourceArgs{
							SecretVersion: encryptionKeySecretVersion.Name,
						},
						DrmSystems: &transcoder.JobTemplateConfigEncryptionDrmSystemsArgs{
							Widevine: &transcoder.JobTemplateConfigEncryptionDrmSystemsWidevineArgs{},
						},
						MpegCenc: &transcoder.JobTemplateConfigEncryptionMpegCencArgs{
							Scheme: pulumi.String("cbcs"),
						},
					},
				},
				MuxStreams: transcoder.JobTemplateConfigMuxStreamArray{
					&transcoder.JobTemplateConfigMuxStreamArgs{
						Key:       pulumi.String("ts_aes128"),
						Container: pulumi.String("ts"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("es_video"),
							pulumi.String("es_audio"),
						},
						SegmentSettings: &transcoder.JobTemplateConfigMuxStreamSegmentSettingsArgs{
							SegmentDuration: pulumi.String("6s"),
						},
						EncryptionId: pulumi.String("aes-128"),
					},
					&transcoder.JobTemplateConfigMuxStreamArgs{
						Key:       pulumi.String("fmp4_cenc_video"),
						Container: pulumi.String("fmp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("es_video"),
						},
						SegmentSettings: &transcoder.JobTemplateConfigMuxStreamSegmentSettingsArgs{
							SegmentDuration: pulumi.String("6s"),
						},
						EncryptionId: pulumi.String("cenc"),
					},
					&transcoder.JobTemplateConfigMuxStreamArgs{
						Key:       pulumi.String("fmp4_cenc_audio"),
						Container: pulumi.String("fmp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("es_audio"),
						},
						SegmentSettings: &transcoder.JobTemplateConfigMuxStreamSegmentSettingsArgs{
							SegmentDuration: pulumi.String("6s"),
						},
						EncryptionId: pulumi.String("cenc"),
					},
					&transcoder.JobTemplateConfigMuxStreamArgs{
						Key:       pulumi.String("fmp4_cbcs_video"),
						Container: pulumi.String("fmp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("es_video"),
						},
						SegmentSettings: &transcoder.JobTemplateConfigMuxStreamSegmentSettingsArgs{
							SegmentDuration: pulumi.String("6s"),
						},
						EncryptionId: pulumi.String("cbcs"),
					},
					&transcoder.JobTemplateConfigMuxStreamArgs{
						Key:       pulumi.String("fmp4_cbcs_audio"),
						Container: pulumi.String("fmp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("es_audio"),
						},
						SegmentSettings: &transcoder.JobTemplateConfigMuxStreamSegmentSettingsArgs{
							SegmentDuration: pulumi.String("6s"),
						},
						EncryptionId: pulumi.String("cbcs"),
					},
				},
				Manifests: transcoder.JobTemplateConfigManifestArray{
					&transcoder.JobTemplateConfigManifestArgs{
						FileName: pulumi.String("manifest_aes128.m3u8"),
						Type:     pulumi.String("HLS"),
						MuxStreams: pulumi.StringArray{
							pulumi.String("ts_aes128"),
						},
					},
					&transcoder.JobTemplateConfigManifestArgs{
						FileName: pulumi.String("manifest_cenc.mpd"),
						Type:     pulumi.String("DASH"),
						MuxStreams: pulumi.StringArray{
							pulumi.String("fmp4_cenc_video"),
							pulumi.String("fmp4_cenc_audio"),
						},
					},
					&transcoder.JobTemplateConfigManifestArgs{
						FileName: pulumi.String("manifest_cbcs.mpd"),
						Type:     pulumi.String("DASH"),
						MuxStreams: pulumi.StringArray{
							pulumi.String("fmp4_cbcs_video"),
							pulumi.String("fmp4_cbcs_audio"),
						},
					},
				},
			},
			Labels: pulumi.StringMap{
				"label": pulumi.String("key"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Transcoder Job Template Pubsub

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/pubsub"
"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/transcoder"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		transcoderNotifications, err := pubsub.NewTopic(ctx, "transcoder_notifications", &pubsub.TopicArgs{
			Name: pulumi.String("transcoder-notifications"),
		})
		if err != nil {
			return err
		}
		_, err = transcoder.NewJobTemplate(ctx, "default", &transcoder.JobTemplateArgs{
			JobTemplateId: pulumi.String("example-job-template"),
			Location:      pulumi.String("us-central1"),
			Config: &transcoder.JobTemplateConfigArgs{
				Inputs: transcoder.JobTemplateConfigInputTypeArray{
					&transcoder.JobTemplateConfigInputTypeArgs{
						Key: pulumi.String("input0"),
						Uri: pulumi.String("gs://example/example.mp4"),
					},
				},
				Output: &transcoder.JobTemplateConfigOutputTypeArgs{
					Uri: pulumi.String("gs://example/outputs/"),
				},
				EditLists: transcoder.JobTemplateConfigEditListArray{
					&transcoder.JobTemplateConfigEditListArgs{
						Key: pulumi.String("atom0"),
						Inputs: pulumi.StringArray{
							pulumi.String("input0"),
						},
						StartTimeOffset: pulumi.String("0s"),
					},
				},
				AdBreaks: transcoder.JobTemplateConfigAdBreakArray{
					&transcoder.JobTemplateConfigAdBreakArgs{
						StartTimeOffset: pulumi.String("3.500s"),
					},
				},
				ElementaryStreams: transcoder.JobTemplateConfigElementaryStreamArray{
					&transcoder.JobTemplateConfigElementaryStreamArgs{
						Key: pulumi.String("video-stream0"),
						VideoStream: &transcoder.JobTemplateConfigElementaryStreamVideoStreamArgs{
							H264: &transcoder.JobTemplateConfigElementaryStreamVideoStreamH264Args{
								WidthPixels:     pulumi.Int(640),
								HeightPixels:    pulumi.Int(360),
								BitrateBps:      pulumi.Int(550000),
								FrameRate:       pulumi.Int(60),
								PixelFormat:     pulumi.String("yuv420p"),
								RateControlMode: pulumi.String("vbr"),
								CrfLevel:        pulumi.Int(21),
								GopDuration:     pulumi.String("3s"),
								VbvSizeBits:     pulumi.Int(550000),
								VbvFullnessBits: pulumi.Int(495000),
								EntropyCoder:    pulumi.String("cabac"),
								Profile:         pulumi.String("high"),
								Preset:          pulumi.String("veryfast"),
							},
						},
					},
					&transcoder.JobTemplateConfigElementaryStreamArgs{
						Key: pulumi.String("video-stream1"),
						VideoStream: &transcoder.JobTemplateConfigElementaryStreamVideoStreamArgs{
							H264: &transcoder.JobTemplateConfigElementaryStreamVideoStreamH264Args{
								WidthPixels:     pulumi.Int(1280),
								HeightPixels:    pulumi.Int(720),
								BitrateBps:      pulumi.Int(550000),
								FrameRate:       pulumi.Int(60),
								PixelFormat:     pulumi.String("yuv420p"),
								RateControlMode: pulumi.String("vbr"),
								CrfLevel:        pulumi.Int(21),
								GopDuration:     pulumi.String("3s"),
								VbvSizeBits:     pulumi.Int(2500000),
								VbvFullnessBits: pulumi.Int(2250000),
								EntropyCoder:    pulumi.String("cabac"),
								Profile:         pulumi.String("high"),
								Preset:          pulumi.String("veryfast"),
							},
						},
					},
					&transcoder.JobTemplateConfigElementaryStreamArgs{
						Key: pulumi.String("audio-stream0"),
						AudioStream: &transcoder.JobTemplateConfigElementaryStreamAudioStreamArgs{
							Codec:        pulumi.String("aac"),
							BitrateBps:   pulumi.Int(64000),
							ChannelCount: pulumi.Int(2),
							ChannelLayouts: pulumi.StringArray{
								pulumi.String("fl"),
								pulumi.String("fr"),
							},
							SampleRateHertz: pulumi.Int(48000),
						},
					},
				},
				MuxStreams: transcoder.JobTemplateConfigMuxStreamArray{
					&transcoder.JobTemplateConfigMuxStreamArgs{
						Key:       pulumi.String("sd"),
						FileName:  pulumi.String("sd.mp4"),
						Container: pulumi.String("mp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream0"),
							pulumi.String("audio-stream0"),
						},
					},
					&transcoder.JobTemplateConfigMuxStreamArgs{
						Key:       pulumi.String("hd"),
						FileName:  pulumi.String("hd.mp4"),
						Container: pulumi.String("mp4"),
						ElementaryStreams: pulumi.StringArray{
							pulumi.String("video-stream1"),
							pulumi.String("audio-stream0"),
						},
					},
				},
				PubsubDestination: &transcoder.JobTemplateConfigPubsubDestinationArgs{
					Topic: transcoderNotifications.ID(),
				},
			},
			Labels: pulumi.StringMap{
				"label": pulumi.String("key"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

JobTemplate can be imported using any of these accepted formats:

* `projects/{{project}}/locations/{{location}}/jobTemplates/{{job_template_id}}`

* `{{project}}/{{location}}/{{job_template_id}}`

* `{{location}}/{{job_template_id}}`

When using the `pulumi import` command, JobTemplate can be imported using one of the formats above. For example:

```sh $ pulumi import gcp:transcoder/jobTemplate:JobTemplate default projects/{{project}}/locations/{{location}}/jobTemplates/{{job_template_id}} ```

```sh $ pulumi import gcp:transcoder/jobTemplate:JobTemplate default {{project}}/{{location}}/{{job_template_id}} ```

```sh $ pulumi import gcp:transcoder/jobTemplate:JobTemplate default {{location}}/{{job_template_id}} ```

func GetJobTemplate 

func GetJobTemplate(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *JobTemplateState, opts ...pulumi.ResourceOption) (*JobTemplate, error)

GetJobTemplate gets an existing JobTemplate resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewJobTemplate 

func NewJobTemplate(ctx *pulumi.Context,
	name string, args *JobTemplateArgs, opts ...pulumi.ResourceOption) (*JobTemplate, error)

NewJobTemplate registers a new resource with the given unique name, arguments, and options.

func (*JobTemplate) ElementType 

func (*JobTemplate) ElementType() reflect.Type

func (*JobTemplate) ToJobTemplateOutput 

func (i *JobTemplate) ToJobTemplateOutput() JobTemplateOutput

func (*JobTemplate) ToJobTemplateOutputWithContext 

func (i *JobTemplate) ToJobTemplateOutputWithContext(ctx context.Context) JobTemplateOutput

type JobTemplateArgs 

type JobTemplateArgs struct {
	// The configuration for this template.
	// Structure is documented below.
	Config JobTemplateConfigPtrInput
	// ID to use for the Transcoding job template.
	JobTemplateId pulumi.StringInput
	// The labels associated with this job template. You can use these to organize and group your job templates.
	//
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the resource.
	Labels pulumi.StringMapInput
	// The location of the transcoding job template resource.
	//
	// ***
	Location pulumi.StringInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
}

The set of arguments for constructing a JobTemplate resource.

func (JobTemplateArgs) ElementType 

func (JobTemplateArgs) ElementType() reflect.Type

type JobTemplateArray 

type JobTemplateArray []JobTemplateInput

func (JobTemplateArray) ElementType 

func (JobTemplateArray) ElementType() reflect.Type

func (JobTemplateArray) ToJobTemplateArrayOutput 

func (i JobTemplateArray) ToJobTemplateArrayOutput() JobTemplateArrayOutput

func (JobTemplateArray) ToJobTemplateArrayOutputWithContext 

func (i JobTemplateArray) ToJobTemplateArrayOutputWithContext(ctx context.Context) JobTemplateArrayOutput

type JobTemplateArrayInput 

type JobTemplateArrayInput interface {
	pulumi.Input

	ToJobTemplateArrayOutput() JobTemplateArrayOutput
	ToJobTemplateArrayOutputWithContext(context.Context) JobTemplateArrayOutput
}

JobTemplateArrayInput is an input type that accepts JobTemplateArray and JobTemplateArrayOutput values. You can construct a concrete instance of `JobTemplateArrayInput` via: 

JobTemplateArray{ JobTemplateArgs{...} }

type JobTemplateArrayOutput 

type JobTemplateArrayOutput struct{ *pulumi.OutputState }

func (JobTemplateArrayOutput) ElementType 

func (JobTemplateArrayOutput) ElementType() reflect.Type

func (JobTemplateArrayOutput) Index 

func (o JobTemplateArrayOutput) Index(i pulumi.IntInput) JobTemplateOutput

func (JobTemplateArrayOutput) ToJobTemplateArrayOutput 

func (o JobTemplateArrayOutput) ToJobTemplateArrayOutput() JobTemplateArrayOutput

func (JobTemplateArrayOutput) ToJobTemplateArrayOutputWithContext 

func (o JobTemplateArrayOutput) ToJobTemplateArrayOutputWithContext(ctx context.Context) JobTemplateArrayOutput

type JobTemplateConfig 

type JobTemplateConfig struct {
	// Ad break.
	// Structure is documented below.
	AdBreaks []JobTemplateConfigAdBreak `pulumi:"adBreaks"`
	// List of input assets stored in Cloud Storage.
	// Structure is documented below.
	EditLists []JobTemplateConfigEditList `pulumi:"editLists"`
	// List of input assets stored in Cloud Storage.
	// Structure is documented below.
	ElementaryStreams []JobTemplateConfigElementaryStream `pulumi:"elementaryStreams"`
	// List of encryption configurations for the content.
	// Structure is documented below.
	Encryptions []JobTemplateConfigEncryption `pulumi:"encryptions"`
	// List of input assets stored in Cloud Storage.
	// Structure is documented below.
	Inputs []JobTemplateConfigInputType `pulumi:"inputs"`
	// Manifest configuration.
	// Structure is documented below.
	Manifests []JobTemplateConfigManifest `pulumi:"manifests"`
	// Multiplexing settings for output stream.
	// Structure is documented below.
	MuxStreams []JobTemplateConfigMuxStream `pulumi:"muxStreams"`
	// Location of output file(s) in a Cloud Storage bucket.
	// Structure is documented below.
	Output *JobTemplateConfigOutputType `pulumi:"output"`
	// List of overlays on the output video, in descending Z-order.
	// Structure is documented below.
	Overlays []JobTemplateConfigOverlay `pulumi:"overlays"`
	// Pub/Sub destination.
	// Structure is documented below.
	PubsubDestination *JobTemplateConfigPubsubDestination `pulumi:"pubsubDestination"`
}

type JobTemplateConfigAdBreak 

type JobTemplateConfigAdBreak struct {
	// Start time in seconds for the ad break, relative to the output file timeline
	StartTimeOffset *string `pulumi:"startTimeOffset"`
}

type JobTemplateConfigAdBreakArgs 

type JobTemplateConfigAdBreakArgs struct {
	// Start time in seconds for the ad break, relative to the output file timeline
	StartTimeOffset pulumi.StringPtrInput `pulumi:"startTimeOffset"`
}

func (JobTemplateConfigAdBreakArgs) ElementType 

func (JobTemplateConfigAdBreakArgs) ElementType() reflect.Type

func (JobTemplateConfigAdBreakArgs) ToJobTemplateConfigAdBreakOutput 

func (i JobTemplateConfigAdBreakArgs) ToJobTemplateConfigAdBreakOutput() JobTemplateConfigAdBreakOutput

func (JobTemplateConfigAdBreakArgs) ToJobTemplateConfigAdBreakOutputWithContext 

func (i JobTemplateConfigAdBreakArgs) ToJobTemplateConfigAdBreakOutputWithContext(ctx context.Context) JobTemplateConfigAdBreakOutput

type JobTemplateConfigAdBreakArray 

type JobTemplateConfigAdBreakArray []JobTemplateConfigAdBreakInput

func (JobTemplateConfigAdBreakArray) ElementType 

func (JobTemplateConfigAdBreakArray) ElementType() reflect.Type

func (JobTemplateConfigAdBreakArray) ToJobTemplateConfigAdBreakArrayOutput 

func (i JobTemplateConfigAdBreakArray) ToJobTemplateConfigAdBreakArrayOutput() JobTemplateConfigAdBreakArrayOutput

func (JobTemplateConfigAdBreakArray) ToJobTemplateConfigAdBreakArrayOutputWithContext 

func (i JobTemplateConfigAdBreakArray) ToJobTemplateConfigAdBreakArrayOutputWithContext(ctx context.Context) JobTemplateConfigAdBreakArrayOutput

type JobTemplateConfigAdBreakArrayInput 

type JobTemplateConfigAdBreakArrayInput interface {
	pulumi.Input

	ToJobTemplateConfigAdBreakArrayOutput() JobTemplateConfigAdBreakArrayOutput
	ToJobTemplateConfigAdBreakArrayOutputWithContext(context.Context) JobTemplateConfigAdBreakArrayOutput
}

JobTemplateConfigAdBreakArrayInput is an input type that accepts JobTemplateConfigAdBreakArray and JobTemplateConfigAdBreakArrayOutput values. You can construct a concrete instance of `JobTemplateConfigAdBreakArrayInput` via: 

JobTemplateConfigAdBreakArray{ JobTemplateConfigAdBreakArgs{...} }

type JobTemplateConfigAdBreakArrayOutput 

type JobTemplateConfigAdBreakArrayOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigAdBreakArrayOutput) ElementType 

func (JobTemplateConfigAdBreakArrayOutput) ElementType() reflect.Type

func (JobTemplateConfigAdBreakArrayOutput) Index 

func (o JobTemplateConfigAdBreakArrayOutput) Index(i pulumi.IntInput) JobTemplateConfigAdBreakOutput

func (JobTemplateConfigAdBreakArrayOutput) ToJobTemplateConfigAdBreakArrayOutput 

func (o JobTemplateConfigAdBreakArrayOutput) ToJobTemplateConfigAdBreakArrayOutput() JobTemplateConfigAdBreakArrayOutput

func (JobTemplateConfigAdBreakArrayOutput) ToJobTemplateConfigAdBreakArrayOutputWithContext 

func (o JobTemplateConfigAdBreakArrayOutput) ToJobTemplateConfigAdBreakArrayOutputWithContext(ctx context.Context) JobTemplateConfigAdBreakArrayOutput

type JobTemplateConfigAdBreakInput 

type JobTemplateConfigAdBreakInput interface {
	pulumi.Input

	ToJobTemplateConfigAdBreakOutput() JobTemplateConfigAdBreakOutput
	ToJobTemplateConfigAdBreakOutputWithContext(context.Context) JobTemplateConfigAdBreakOutput
}

JobTemplateConfigAdBreakInput is an input type that accepts JobTemplateConfigAdBreakArgs and JobTemplateConfigAdBreakOutput values. You can construct a concrete instance of `JobTemplateConfigAdBreakInput` via: 

JobTemplateConfigAdBreakArgs{...}

type JobTemplateConfigAdBreakOutput 

type JobTemplateConfigAdBreakOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigAdBreakOutput) ElementType 

func (JobTemplateConfigAdBreakOutput) ElementType() reflect.Type

func (JobTemplateConfigAdBreakOutput) StartTimeOffset 

func (o JobTemplateConfigAdBreakOutput) StartTimeOffset() pulumi.StringPtrOutput

Start time in seconds for the ad break, relative to the output file timeline

func (JobTemplateConfigAdBreakOutput) ToJobTemplateConfigAdBreakOutput 

func (o JobTemplateConfigAdBreakOutput) ToJobTemplateConfigAdBreakOutput() JobTemplateConfigAdBreakOutput

func (JobTemplateConfigAdBreakOutput) ToJobTemplateConfigAdBreakOutputWithContext 

func (o JobTemplateConfigAdBreakOutput) ToJobTemplateConfigAdBreakOutputWithContext(ctx context.Context) JobTemplateConfigAdBreakOutput

type JobTemplateConfigArgs 

type JobTemplateConfigArgs struct {
	// Ad break.
	// Structure is documented below.
	AdBreaks JobTemplateConfigAdBreakArrayInput `pulumi:"adBreaks"`
	// List of input assets stored in Cloud Storage.
	// Structure is documented below.
	EditLists JobTemplateConfigEditListArrayInput `pulumi:"editLists"`
	// List of input assets stored in Cloud Storage.
	// Structure is documented below.
	ElementaryStreams JobTemplateConfigElementaryStreamArrayInput `pulumi:"elementaryStreams"`
	// List of encryption configurations for the content.
	// Structure is documented below.
	Encryptions JobTemplateConfigEncryptionArrayInput `pulumi:"encryptions"`
	// List of input assets stored in Cloud Storage.
	// Structure is documented below.
	Inputs JobTemplateConfigInputTypeArrayInput `pulumi:"inputs"`
	// Manifest configuration.
	// Structure is documented below.
	Manifests JobTemplateConfigManifestArrayInput `pulumi:"manifests"`
	// Multiplexing settings for output stream.
	// Structure is documented below.
	MuxStreams JobTemplateConfigMuxStreamArrayInput `pulumi:"muxStreams"`
	// Location of output file(s) in a Cloud Storage bucket.
	// Structure is documented below.
	Output JobTemplateConfigOutputTypePtrInput `pulumi:"output"`
	// List of overlays on the output video, in descending Z-order.
	// Structure is documented below.
	Overlays JobTemplateConfigOverlayArrayInput `pulumi:"overlays"`
	// Pub/Sub destination.
	// Structure is documented below.
	PubsubDestination JobTemplateConfigPubsubDestinationPtrInput `pulumi:"pubsubDestination"`
}

func (JobTemplateConfigArgs) ElementType 

func (JobTemplateConfigArgs) ElementType() reflect.Type

func (JobTemplateConfigArgs) ToJobTemplateConfigOutput 

func (i JobTemplateConfigArgs) ToJobTemplateConfigOutput() JobTemplateConfigOutput

func (JobTemplateConfigArgs) ToJobTemplateConfigOutputWithContext 

func (i JobTemplateConfigArgs) ToJobTemplateConfigOutputWithContext(ctx context.Context) JobTemplateConfigOutput

func (JobTemplateConfigArgs) ToJobTemplateConfigPtrOutput 

func (i JobTemplateConfigArgs) ToJobTemplateConfigPtrOutput() JobTemplateConfigPtrOutput

func (JobTemplateConfigArgs) ToJobTemplateConfigPtrOutputWithContext 

func (i JobTemplateConfigArgs) ToJobTemplateConfigPtrOutputWithContext(ctx context.Context) JobTemplateConfigPtrOutput

type JobTemplateConfigEditList 

type JobTemplateConfigEditList struct {
	// List of values identifying files that should be used in this atom.
	Inputs []string `pulumi:"inputs"`
	// A unique key for this atom.
	Key *string `pulumi:"key"`
	// Start time in seconds for the atom, relative to the input file timeline.  The default is `0s`.
	StartTimeOffset *string `pulumi:"startTimeOffset"`
}

type JobTemplateConfigEditListArgs 

type JobTemplateConfigEditListArgs struct {
	// List of values identifying files that should be used in this atom.
	Inputs pulumi.StringArrayInput `pulumi:"inputs"`
	// A unique key for this atom.
	Key pulumi.StringPtrInput `pulumi:"key"`
	// Start time in seconds for the atom, relative to the input file timeline.  The default is `0s`.
	StartTimeOffset pulumi.StringPtrInput `pulumi:"startTimeOffset"`
}

func (JobTemplateConfigEditListArgs) ElementType 

func (JobTemplateConfigEditListArgs) ElementType() reflect.Type

func (JobTemplateConfigEditListArgs) ToJobTemplateConfigEditListOutput 

func (i JobTemplateConfigEditListArgs) ToJobTemplateConfigEditListOutput() JobTemplateConfigEditListOutput

func (JobTemplateConfigEditListArgs) ToJobTemplateConfigEditListOutputWithContext 

func (i JobTemplateConfigEditListArgs) ToJobTemplateConfigEditListOutputWithContext(ctx context.Context) JobTemplateConfigEditListOutput

type JobTemplateConfigEditListArray 

type JobTemplateConfigEditListArray []JobTemplateConfigEditListInput

func (JobTemplateConfigEditListArray) ElementType 

func (JobTemplateConfigEditListArray) ElementType() reflect.Type

func (JobTemplateConfigEditListArray) ToJobTemplateConfigEditListArrayOutput 

func (i JobTemplateConfigEditListArray) ToJobTemplateConfigEditListArrayOutput() JobTemplateConfigEditListArrayOutput

func (JobTemplateConfigEditListArray) ToJobTemplateConfigEditListArrayOutputWithContext 

func (i JobTemplateConfigEditListArray) ToJobTemplateConfigEditListArrayOutputWithContext(ctx context.Context) JobTemplateConfigEditListArrayOutput

type JobTemplateConfigEditListArrayInput 

type JobTemplateConfigEditListArrayInput interface {
	pulumi.Input

	ToJobTemplateConfigEditListArrayOutput() JobTemplateConfigEditListArrayOutput
	ToJobTemplateConfigEditListArrayOutputWithContext(context.Context) JobTemplateConfigEditListArrayOutput
}

JobTemplateConfigEditListArrayInput is an input type that accepts JobTemplateConfigEditListArray and JobTemplateConfigEditListArrayOutput values. You can construct a concrete instance of `JobTemplateConfigEditListArrayInput` via: 

JobTemplateConfigEditListArray{ JobTemplateConfigEditListArgs{...} }

type JobTemplateConfigEditListArrayOutput 

type JobTemplateConfigEditListArrayOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEditListArrayOutput) ElementType 

func (JobTemplateConfigEditListArrayOutput) ElementType() reflect.Type

func (JobTemplateConfigEditListArrayOutput) Index 

func (o JobTemplateConfigEditListArrayOutput) Index(i pulumi.IntInput) JobTemplateConfigEditListOutput

func (JobTemplateConfigEditListArrayOutput) ToJobTemplateConfigEditListArrayOutput 

func (o JobTemplateConfigEditListArrayOutput) ToJobTemplateConfigEditListArrayOutput() JobTemplateConfigEditListArrayOutput

func (JobTemplateConfigEditListArrayOutput) ToJobTemplateConfigEditListArrayOutputWithContext 

func (o JobTemplateConfigEditListArrayOutput) ToJobTemplateConfigEditListArrayOutputWithContext(ctx context.Context) JobTemplateConfigEditListArrayOutput

type JobTemplateConfigEditListInput 

type JobTemplateConfigEditListInput interface {
	pulumi.Input

	ToJobTemplateConfigEditListOutput() JobTemplateConfigEditListOutput
	ToJobTemplateConfigEditListOutputWithContext(context.Context) JobTemplateConfigEditListOutput
}

JobTemplateConfigEditListInput is an input type that accepts JobTemplateConfigEditListArgs and JobTemplateConfigEditListOutput values. You can construct a concrete instance of `JobTemplateConfigEditListInput` via: 

JobTemplateConfigEditListArgs{...}

type JobTemplateConfigEditListOutput 

type JobTemplateConfigEditListOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEditListOutput) ElementType 

func (JobTemplateConfigEditListOutput) ElementType() reflect.Type

func (JobTemplateConfigEditListOutput) Inputs 

func (o JobTemplateConfigEditListOutput) Inputs() pulumi.StringArrayOutput

List of values identifying files that should be used in this atom.

func (JobTemplateConfigEditListOutput) Key 

func (o JobTemplateConfigEditListOutput) Key() pulumi.StringPtrOutput

A unique key for this atom.

func (JobTemplateConfigEditListOutput) StartTimeOffset 

func (o JobTemplateConfigEditListOutput) StartTimeOffset() pulumi.StringPtrOutput

Start time in seconds for the atom, relative to the input file timeline. The default is `0s`.

func (JobTemplateConfigEditListOutput) ToJobTemplateConfigEditListOutput 

func (o JobTemplateConfigEditListOutput) ToJobTemplateConfigEditListOutput() JobTemplateConfigEditListOutput

func (JobTemplateConfigEditListOutput) ToJobTemplateConfigEditListOutputWithContext 

func (o JobTemplateConfigEditListOutput) ToJobTemplateConfigEditListOutputWithContext(ctx context.Context) JobTemplateConfigEditListOutput

type JobTemplateConfigElementaryStream 

type JobTemplateConfigElementaryStream struct {
	// Encoding of an audio stream.
	// Structure is documented below.
	AudioStream *JobTemplateConfigElementaryStreamAudioStream `pulumi:"audioStream"`
	// A unique key for this atom.
	Key *string `pulumi:"key"`
	// Encoding of a video stream.
	// Structure is documented below.
	VideoStream *JobTemplateConfigElementaryStreamVideoStream `pulumi:"videoStream"`
}

type JobTemplateConfigElementaryStreamArgs 

type JobTemplateConfigElementaryStreamArgs struct {
	// Encoding of an audio stream.
	// Structure is documented below.
	AudioStream JobTemplateConfigElementaryStreamAudioStreamPtrInput `pulumi:"audioStream"`
	// A unique key for this atom.
	Key pulumi.StringPtrInput `pulumi:"key"`
	// Encoding of a video stream.
	// Structure is documented below.
	VideoStream JobTemplateConfigElementaryStreamVideoStreamPtrInput `pulumi:"videoStream"`
}

func (JobTemplateConfigElementaryStreamArgs) ElementType 

func (JobTemplateConfigElementaryStreamArgs) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamArgs) ToJobTemplateConfigElementaryStreamOutput 

func (i JobTemplateConfigElementaryStreamArgs) ToJobTemplateConfigElementaryStreamOutput() JobTemplateConfigElementaryStreamOutput

func (JobTemplateConfigElementaryStreamArgs) ToJobTemplateConfigElementaryStreamOutputWithContext 

func (i JobTemplateConfigElementaryStreamArgs) ToJobTemplateConfigElementaryStreamOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamOutput

type JobTemplateConfigElementaryStreamArray 

type JobTemplateConfigElementaryStreamArray []JobTemplateConfigElementaryStreamInput

func (JobTemplateConfigElementaryStreamArray) ElementType 

func (JobTemplateConfigElementaryStreamArray) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamArray) ToJobTemplateConfigElementaryStreamArrayOutput 

func (i JobTemplateConfigElementaryStreamArray) ToJobTemplateConfigElementaryStreamArrayOutput() JobTemplateConfigElementaryStreamArrayOutput

func (JobTemplateConfigElementaryStreamArray) ToJobTemplateConfigElementaryStreamArrayOutputWithContext 

func (i JobTemplateConfigElementaryStreamArray) ToJobTemplateConfigElementaryStreamArrayOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamArrayOutput

type JobTemplateConfigElementaryStreamArrayInput 

type JobTemplateConfigElementaryStreamArrayInput interface {
	pulumi.Input

	ToJobTemplateConfigElementaryStreamArrayOutput() JobTemplateConfigElementaryStreamArrayOutput
	ToJobTemplateConfigElementaryStreamArrayOutputWithContext(context.Context) JobTemplateConfigElementaryStreamArrayOutput
}

JobTemplateConfigElementaryStreamArrayInput is an input type that accepts JobTemplateConfigElementaryStreamArray and JobTemplateConfigElementaryStreamArrayOutput values. You can construct a concrete instance of `JobTemplateConfigElementaryStreamArrayInput` via: 

JobTemplateConfigElementaryStreamArray{ JobTemplateConfigElementaryStreamArgs{...} }

type JobTemplateConfigElementaryStreamArrayOutput 

type JobTemplateConfigElementaryStreamArrayOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigElementaryStreamArrayOutput) ElementType 

func (JobTemplateConfigElementaryStreamArrayOutput) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamArrayOutput) Index 

func (o JobTemplateConfigElementaryStreamArrayOutput) Index(i pulumi.IntInput) JobTemplateConfigElementaryStreamOutput

func (JobTemplateConfigElementaryStreamArrayOutput) ToJobTemplateConfigElementaryStreamArrayOutput 

func (o JobTemplateConfigElementaryStreamArrayOutput) ToJobTemplateConfigElementaryStreamArrayOutput() JobTemplateConfigElementaryStreamArrayOutput

func (JobTemplateConfigElementaryStreamArrayOutput) ToJobTemplateConfigElementaryStreamArrayOutputWithContext 

func (o JobTemplateConfigElementaryStreamArrayOutput) ToJobTemplateConfigElementaryStreamArrayOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamArrayOutput

type JobTemplateConfigElementaryStreamAudioStream 

type JobTemplateConfigElementaryStreamAudioStream struct {
	// Audio bitrate in bits per second.
	BitrateBps int `pulumi:"bitrateBps"`
	// Number of audio channels. The default is `2`.
	ChannelCount *int `pulumi:"channelCount"`
	// A list of channel names specifying layout of the audio channels.  The default is ["fl", "fr"].
	ChannelLayouts []string `pulumi:"channelLayouts"`
	// The codec for this audio stream. The default is `aac`.
	Codec *string `pulumi:"codec"`
	// The audio sample rate in Hertz. The default is `48000`.
	SampleRateHertz *int `pulumi:"sampleRateHertz"`
}

type JobTemplateConfigElementaryStreamAudioStreamArgs 

type JobTemplateConfigElementaryStreamAudioStreamArgs struct {
	// Audio bitrate in bits per second.
	BitrateBps pulumi.IntInput `pulumi:"bitrateBps"`
	// Number of audio channels. The default is `2`.
	ChannelCount pulumi.IntPtrInput `pulumi:"channelCount"`
	// A list of channel names specifying layout of the audio channels.  The default is ["fl", "fr"].
	ChannelLayouts pulumi.StringArrayInput `pulumi:"channelLayouts"`
	// The codec for this audio stream. The default is `aac`.
	Codec pulumi.StringPtrInput `pulumi:"codec"`
	// The audio sample rate in Hertz. The default is `48000`.
	SampleRateHertz pulumi.IntPtrInput `pulumi:"sampleRateHertz"`
}

func (JobTemplateConfigElementaryStreamAudioStreamArgs) ElementType 

func (JobTemplateConfigElementaryStreamAudioStreamArgs) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamAudioStreamArgs) ToJobTemplateConfigElementaryStreamAudioStreamOutput 

func (i JobTemplateConfigElementaryStreamAudioStreamArgs) ToJobTemplateConfigElementaryStreamAudioStreamOutput() JobTemplateConfigElementaryStreamAudioStreamOutput

func (JobTemplateConfigElementaryStreamAudioStreamArgs) ToJobTemplateConfigElementaryStreamAudioStreamOutputWithContext 

func (i JobTemplateConfigElementaryStreamAudioStreamArgs) ToJobTemplateConfigElementaryStreamAudioStreamOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamAudioStreamOutput

func (JobTemplateConfigElementaryStreamAudioStreamArgs) ToJobTemplateConfigElementaryStreamAudioStreamPtrOutput 

func (i JobTemplateConfigElementaryStreamAudioStreamArgs) ToJobTemplateConfigElementaryStreamAudioStreamPtrOutput() JobTemplateConfigElementaryStreamAudioStreamPtrOutput

func (JobTemplateConfigElementaryStreamAudioStreamArgs) ToJobTemplateConfigElementaryStreamAudioStreamPtrOutputWithContext 

func (i JobTemplateConfigElementaryStreamAudioStreamArgs) ToJobTemplateConfigElementaryStreamAudioStreamPtrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamAudioStreamPtrOutput

type JobTemplateConfigElementaryStreamAudioStreamInput 

type JobTemplateConfigElementaryStreamAudioStreamInput interface {
	pulumi.Input

	ToJobTemplateConfigElementaryStreamAudioStreamOutput() JobTemplateConfigElementaryStreamAudioStreamOutput
	ToJobTemplateConfigElementaryStreamAudioStreamOutputWithContext(context.Context) JobTemplateConfigElementaryStreamAudioStreamOutput
}

JobTemplateConfigElementaryStreamAudioStreamInput is an input type that accepts JobTemplateConfigElementaryStreamAudioStreamArgs and JobTemplateConfigElementaryStreamAudioStreamOutput values. You can construct a concrete instance of `JobTemplateConfigElementaryStreamAudioStreamInput` via: 

JobTemplateConfigElementaryStreamAudioStreamArgs{...}

type JobTemplateConfigElementaryStreamAudioStreamOutput 

type JobTemplateConfigElementaryStreamAudioStreamOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigElementaryStreamAudioStreamOutput) BitrateBps 

func (o JobTemplateConfigElementaryStreamAudioStreamOutput) BitrateBps() pulumi.IntOutput

Audio bitrate in bits per second.

func (JobTemplateConfigElementaryStreamAudioStreamOutput) ChannelCount 

func (o JobTemplateConfigElementaryStreamAudioStreamOutput) ChannelCount() pulumi.IntPtrOutput

Number of audio channels. The default is `2`.

func (JobTemplateConfigElementaryStreamAudioStreamOutput) ChannelLayouts 

func (o JobTemplateConfigElementaryStreamAudioStreamOutput) ChannelLayouts() pulumi.StringArrayOutput

A list of channel names specifying layout of the audio channels. The default is ["fl", "fr"].

func (JobTemplateConfigElementaryStreamAudioStreamOutput) Codec 

func (o JobTemplateConfigElementaryStreamAudioStreamOutput) Codec() pulumi.StringPtrOutput

The codec for this audio stream. The default is `aac`.

func (JobTemplateConfigElementaryStreamAudioStreamOutput) ElementType 

func (JobTemplateConfigElementaryStreamAudioStreamOutput) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamAudioStreamOutput) SampleRateHertz 

func (o JobTemplateConfigElementaryStreamAudioStreamOutput) SampleRateHertz() pulumi.IntPtrOutput

The audio sample rate in Hertz. The default is `48000`.

func (JobTemplateConfigElementaryStreamAudioStreamOutput) ToJobTemplateConfigElementaryStreamAudioStreamOutput 

func (o JobTemplateConfigElementaryStreamAudioStreamOutput) ToJobTemplateConfigElementaryStreamAudioStreamOutput() JobTemplateConfigElementaryStreamAudioStreamOutput

func (JobTemplateConfigElementaryStreamAudioStreamOutput) ToJobTemplateConfigElementaryStreamAudioStreamOutputWithContext 

func (o JobTemplateConfigElementaryStreamAudioStreamOutput) ToJobTemplateConfigElementaryStreamAudioStreamOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamAudioStreamOutput

func (JobTemplateConfigElementaryStreamAudioStreamOutput) ToJobTemplateConfigElementaryStreamAudioStreamPtrOutput 

func (o JobTemplateConfigElementaryStreamAudioStreamOutput) ToJobTemplateConfigElementaryStreamAudioStreamPtrOutput() JobTemplateConfigElementaryStreamAudioStreamPtrOutput

func (JobTemplateConfigElementaryStreamAudioStreamOutput) ToJobTemplateConfigElementaryStreamAudioStreamPtrOutputWithContext 

func (o JobTemplateConfigElementaryStreamAudioStreamOutput) ToJobTemplateConfigElementaryStreamAudioStreamPtrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamAudioStreamPtrOutput

type JobTemplateConfigElementaryStreamAudioStreamPtrInput 

type JobTemplateConfigElementaryStreamAudioStreamPtrInput interface {
	pulumi.Input

	ToJobTemplateConfigElementaryStreamAudioStreamPtrOutput() JobTemplateConfigElementaryStreamAudioStreamPtrOutput
	ToJobTemplateConfigElementaryStreamAudioStreamPtrOutputWithContext(context.Context) JobTemplateConfigElementaryStreamAudioStreamPtrOutput
}

JobTemplateConfigElementaryStreamAudioStreamPtrInput is an input type that accepts JobTemplateConfigElementaryStreamAudioStreamArgs, JobTemplateConfigElementaryStreamAudioStreamPtr and JobTemplateConfigElementaryStreamAudioStreamPtrOutput values. You can construct a concrete instance of `JobTemplateConfigElementaryStreamAudioStreamPtrInput` via: 

        JobTemplateConfigElementaryStreamAudioStreamArgs{...}

or:

        nil

func JobTemplateConfigElementaryStreamAudioStreamPtr 

func JobTemplateConfigElementaryStreamAudioStreamPtr(v *JobTemplateConfigElementaryStreamAudioStreamArgs) JobTemplateConfigElementaryStreamAudioStreamPtrInput

type JobTemplateConfigElementaryStreamAudioStreamPtrOutput 

type JobTemplateConfigElementaryStreamAudioStreamPtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigElementaryStreamAudioStreamPtrOutput) BitrateBps 

func (o JobTemplateConfigElementaryStreamAudioStreamPtrOutput) BitrateBps() pulumi.IntPtrOutput

Audio bitrate in bits per second.

func (JobTemplateConfigElementaryStreamAudioStreamPtrOutput) ChannelCount 

func (o JobTemplateConfigElementaryStreamAudioStreamPtrOutput) ChannelCount() pulumi.IntPtrOutput

Number of audio channels. The default is `2`.

func (JobTemplateConfigElementaryStreamAudioStreamPtrOutput) ChannelLayouts 

func (o JobTemplateConfigElementaryStreamAudioStreamPtrOutput) ChannelLayouts() pulumi.StringArrayOutput

A list of channel names specifying layout of the audio channels. The default is ["fl", "fr"].

func (JobTemplateConfigElementaryStreamAudioStreamPtrOutput) Codec 

func (o JobTemplateConfigElementaryStreamAudioStreamPtrOutput) Codec() pulumi.StringPtrOutput

The codec for this audio stream. The default is `aac`.

func (JobTemplateConfigElementaryStreamAudioStreamPtrOutput) Elem 

func (o JobTemplateConfigElementaryStreamAudioStreamPtrOutput) Elem() JobTemplateConfigElementaryStreamAudioStreamOutput

func (JobTemplateConfigElementaryStreamAudioStreamPtrOutput) ElementType 

func (JobTemplateConfigElementaryStreamAudioStreamPtrOutput) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamAudioStreamPtrOutput) SampleRateHertz 

func (o JobTemplateConfigElementaryStreamAudioStreamPtrOutput) SampleRateHertz() pulumi.IntPtrOutput

The audio sample rate in Hertz. The default is `48000`.

func (JobTemplateConfigElementaryStreamAudioStreamPtrOutput) ToJobTemplateConfigElementaryStreamAudioStreamPtrOutput 

func (o JobTemplateConfigElementaryStreamAudioStreamPtrOutput) ToJobTemplateConfigElementaryStreamAudioStreamPtrOutput() JobTemplateConfigElementaryStreamAudioStreamPtrOutput

func (JobTemplateConfigElementaryStreamAudioStreamPtrOutput) ToJobTemplateConfigElementaryStreamAudioStreamPtrOutputWithContext 

func (o JobTemplateConfigElementaryStreamAudioStreamPtrOutput) ToJobTemplateConfigElementaryStreamAudioStreamPtrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamAudioStreamPtrOutput

type JobTemplateConfigElementaryStreamInput 

type JobTemplateConfigElementaryStreamInput interface {
	pulumi.Input

	ToJobTemplateConfigElementaryStreamOutput() JobTemplateConfigElementaryStreamOutput
	ToJobTemplateConfigElementaryStreamOutputWithContext(context.Context) JobTemplateConfigElementaryStreamOutput
}

JobTemplateConfigElementaryStreamInput is an input type that accepts JobTemplateConfigElementaryStreamArgs and JobTemplateConfigElementaryStreamOutput values. You can construct a concrete instance of `JobTemplateConfigElementaryStreamInput` via: 

JobTemplateConfigElementaryStreamArgs{...}

type JobTemplateConfigElementaryStreamOutput 

type JobTemplateConfigElementaryStreamOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigElementaryStreamOutput) AudioStream 

func (o JobTemplateConfigElementaryStreamOutput) AudioStream() JobTemplateConfigElementaryStreamAudioStreamPtrOutput

Encoding of an audio stream. Structure is documented below.

func (JobTemplateConfigElementaryStreamOutput) ElementType 

func (JobTemplateConfigElementaryStreamOutput) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamOutput) Key 

func (o JobTemplateConfigElementaryStreamOutput) Key() pulumi.StringPtrOutput

A unique key for this atom.

func (JobTemplateConfigElementaryStreamOutput) ToJobTemplateConfigElementaryStreamOutput 

func (o JobTemplateConfigElementaryStreamOutput) ToJobTemplateConfigElementaryStreamOutput() JobTemplateConfigElementaryStreamOutput

func (JobTemplateConfigElementaryStreamOutput) ToJobTemplateConfigElementaryStreamOutputWithContext 

func (o JobTemplateConfigElementaryStreamOutput) ToJobTemplateConfigElementaryStreamOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamOutput

func (JobTemplateConfigElementaryStreamOutput) VideoStream 

func (o JobTemplateConfigElementaryStreamOutput) VideoStream() JobTemplateConfigElementaryStreamVideoStreamPtrOutput

Encoding of a video stream. Structure is documented below.

type JobTemplateConfigElementaryStreamVideoStream 

type JobTemplateConfigElementaryStreamVideoStream struct {
	// H264 codec settings
	// Structure is documented below.
	//
	// <a name="nestedH264"></a>The `h264` block supports:
	H264 *JobTemplateConfigElementaryStreamVideoStreamH264 `pulumi:"h264"`
}

type JobTemplateConfigElementaryStreamVideoStreamArgs 

type JobTemplateConfigElementaryStreamVideoStreamArgs struct {
	// H264 codec settings
	// Structure is documented below.
	//
	// <a name="nestedH264"></a>The `h264` block supports:
	H264 JobTemplateConfigElementaryStreamVideoStreamH264PtrInput `pulumi:"h264"`
}

func (JobTemplateConfigElementaryStreamVideoStreamArgs) ElementType 

func (JobTemplateConfigElementaryStreamVideoStreamArgs) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamVideoStreamArgs) ToJobTemplateConfigElementaryStreamVideoStreamOutput 

func (i JobTemplateConfigElementaryStreamVideoStreamArgs) ToJobTemplateConfigElementaryStreamVideoStreamOutput() JobTemplateConfigElementaryStreamVideoStreamOutput

func (JobTemplateConfigElementaryStreamVideoStreamArgs) ToJobTemplateConfigElementaryStreamVideoStreamOutputWithContext 

func (i JobTemplateConfigElementaryStreamVideoStreamArgs) ToJobTemplateConfigElementaryStreamVideoStreamOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamOutput

func (JobTemplateConfigElementaryStreamVideoStreamArgs) ToJobTemplateConfigElementaryStreamVideoStreamPtrOutput 

func (i JobTemplateConfigElementaryStreamVideoStreamArgs) ToJobTemplateConfigElementaryStreamVideoStreamPtrOutput() JobTemplateConfigElementaryStreamVideoStreamPtrOutput

func (JobTemplateConfigElementaryStreamVideoStreamArgs) ToJobTemplateConfigElementaryStreamVideoStreamPtrOutputWithContext 

func (i JobTemplateConfigElementaryStreamVideoStreamArgs) ToJobTemplateConfigElementaryStreamVideoStreamPtrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamPtrOutput

type JobTemplateConfigElementaryStreamVideoStreamH264 

type JobTemplateConfigElementaryStreamVideoStreamH264 struct {
	// The video bitrate in bits per second.
	BitrateBps int `pulumi:"bitrateBps"`
	// Target CRF level. The default is '21'.
	CrfLevel *int `pulumi:"crfLevel"`
	// The entropy coder to use. The default is 'cabac'.
	EntropyCoder *string `pulumi:"entropyCoder"`
	// The target video frame rate in frames per second (FPS).
	FrameRate int `pulumi:"frameRate"`
	// Select the GOP size based on the specified duration. The default is '3s'.
	GopDuration *string `pulumi:"gopDuration"`
	// The height of the video in pixels.
	HeightPixels *int `pulumi:"heightPixels"`
	// HLG color format setting for H264.
	Hlg *JobTemplateConfigElementaryStreamVideoStreamH264Hlg `pulumi:"hlg"`
	// Pixel format to use. The default is 'yuv420p'.
	PixelFormat *string `pulumi:"pixelFormat"`
	// Enforces the specified codec preset. The default is 'veryfast'.
	Preset *string `pulumi:"preset"`
	// Enforces the specified codec profile.
	Profile *string `pulumi:"profile"`
	// Specify the mode. The default is 'vbr'.
	RateControlMode *string `pulumi:"rateControlMode"`
	// SDR color format setting for H264.
	Sdr *JobTemplateConfigElementaryStreamVideoStreamH264Sdr `pulumi:"sdr"`
	// Initial fullness of the Video Buffering Verifier (VBV) buffer in bits.
	VbvFullnessBits *int `pulumi:"vbvFullnessBits"`
	// Size of the Video Buffering Verifier (VBV) buffer in bits.
	VbvSizeBits *int `pulumi:"vbvSizeBits"`
	// The width of the video in pixels.
	WidthPixels *int `pulumi:"widthPixels"`
}

type JobTemplateConfigElementaryStreamVideoStreamH264Args 

type JobTemplateConfigElementaryStreamVideoStreamH264Args struct {
	// The video bitrate in bits per second.
	BitrateBps pulumi.IntInput `pulumi:"bitrateBps"`
	// Target CRF level. The default is '21'.
	CrfLevel pulumi.IntPtrInput `pulumi:"crfLevel"`
	// The entropy coder to use. The default is 'cabac'.
	EntropyCoder pulumi.StringPtrInput `pulumi:"entropyCoder"`
	// The target video frame rate in frames per second (FPS).
	FrameRate pulumi.IntInput `pulumi:"frameRate"`
	// Select the GOP size based on the specified duration. The default is '3s'.
	GopDuration pulumi.StringPtrInput `pulumi:"gopDuration"`
	// The height of the video in pixels.
	HeightPixels pulumi.IntPtrInput `pulumi:"heightPixels"`
	// HLG color format setting for H264.
	Hlg JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrInput `pulumi:"hlg"`
	// Pixel format to use. The default is 'yuv420p'.
	PixelFormat pulumi.StringPtrInput `pulumi:"pixelFormat"`
	// Enforces the specified codec preset. The default is 'veryfast'.
	Preset pulumi.StringPtrInput `pulumi:"preset"`
	// Enforces the specified codec profile.
	Profile pulumi.StringPtrInput `pulumi:"profile"`
	// Specify the mode. The default is 'vbr'.
	RateControlMode pulumi.StringPtrInput `pulumi:"rateControlMode"`
	// SDR color format setting for H264.
	Sdr JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrInput `pulumi:"sdr"`
	// Initial fullness of the Video Buffering Verifier (VBV) buffer in bits.
	VbvFullnessBits pulumi.IntPtrInput `pulumi:"vbvFullnessBits"`
	// Size of the Video Buffering Verifier (VBV) buffer in bits.
	VbvSizeBits pulumi.IntPtrInput `pulumi:"vbvSizeBits"`
	// The width of the video in pixels.
	WidthPixels pulumi.IntPtrInput `pulumi:"widthPixels"`
}

func (JobTemplateConfigElementaryStreamVideoStreamH264Args) ElementType 

func (JobTemplateConfigElementaryStreamVideoStreamH264Args) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamVideoStreamH264Args) ToJobTemplateConfigElementaryStreamVideoStreamH264Output 

func (i JobTemplateConfigElementaryStreamVideoStreamH264Args) ToJobTemplateConfigElementaryStreamVideoStreamH264Output() JobTemplateConfigElementaryStreamVideoStreamH264Output

func (JobTemplateConfigElementaryStreamVideoStreamH264Args) ToJobTemplateConfigElementaryStreamVideoStreamH264OutputWithContext 

func (i JobTemplateConfigElementaryStreamVideoStreamH264Args) ToJobTemplateConfigElementaryStreamVideoStreamH264OutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamH264Output

func (JobTemplateConfigElementaryStreamVideoStreamH264Args) ToJobTemplateConfigElementaryStreamVideoStreamH264PtrOutput 

func (i JobTemplateConfigElementaryStreamVideoStreamH264Args) ToJobTemplateConfigElementaryStreamVideoStreamH264PtrOutput() JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264Args) ToJobTemplateConfigElementaryStreamVideoStreamH264PtrOutputWithContext 

func (i JobTemplateConfigElementaryStreamVideoStreamH264Args) ToJobTemplateConfigElementaryStreamVideoStreamH264PtrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput

type JobTemplateConfigElementaryStreamVideoStreamH264Hlg 

type JobTemplateConfigElementaryStreamVideoStreamH264Hlg struct {
}

type JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs 

type JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs struct {
}

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs) ElementType 

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgOutput 

func (i JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgOutput() JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgOutputWithContext 

func (i JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput 

func (i JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput() JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutputWithContext 

func (i JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput

type JobTemplateConfigElementaryStreamVideoStreamH264HlgInput 

type JobTemplateConfigElementaryStreamVideoStreamH264HlgInput interface {
	pulumi.Input

	ToJobTemplateConfigElementaryStreamVideoStreamH264HlgOutput() JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput
	ToJobTemplateConfigElementaryStreamVideoStreamH264HlgOutputWithContext(context.Context) JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput
}

JobTemplateConfigElementaryStreamVideoStreamH264HlgInput is an input type that accepts JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs and JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput values. You can construct a concrete instance of `JobTemplateConfigElementaryStreamVideoStreamH264HlgInput` via: 

JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs{...}

type JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput 

type JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput) ElementType 

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgOutput 

func (o JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgOutput() JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgOutputWithContext 

func (o JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput 

func (o JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput() JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutputWithContext 

func (o JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput

type JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrInput 

type JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrInput interface {
	pulumi.Input

	ToJobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput() JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput
	ToJobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutputWithContext(context.Context) JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput
}

JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrInput is an input type that accepts JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs, JobTemplateConfigElementaryStreamVideoStreamH264HlgPtr and JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput values. You can construct a concrete instance of `JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrInput` via: 

        JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs{...}

or:

        nil

func JobTemplateConfigElementaryStreamVideoStreamH264HlgPtr 

func JobTemplateConfigElementaryStreamVideoStreamH264HlgPtr(v *JobTemplateConfigElementaryStreamVideoStreamH264HlgArgs) JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrInput

type JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput 

type JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput) Elem 

func (o JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput) Elem() JobTemplateConfigElementaryStreamVideoStreamH264HlgOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput) ElementType 

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput 

func (o JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput() JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutputWithContext 

func (o JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput

type JobTemplateConfigElementaryStreamVideoStreamH264Input 

type JobTemplateConfigElementaryStreamVideoStreamH264Input interface {
	pulumi.Input

	ToJobTemplateConfigElementaryStreamVideoStreamH264Output() JobTemplateConfigElementaryStreamVideoStreamH264Output
	ToJobTemplateConfigElementaryStreamVideoStreamH264OutputWithContext(context.Context) JobTemplateConfigElementaryStreamVideoStreamH264Output
}

JobTemplateConfigElementaryStreamVideoStreamH264Input is an input type that accepts JobTemplateConfigElementaryStreamVideoStreamH264Args and JobTemplateConfigElementaryStreamVideoStreamH264Output values. You can construct a concrete instance of `JobTemplateConfigElementaryStreamVideoStreamH264Input` via: 

JobTemplateConfigElementaryStreamVideoStreamH264Args{...}

type JobTemplateConfigElementaryStreamVideoStreamH264Output 

type JobTemplateConfigElementaryStreamVideoStreamH264Output struct{ *pulumi.OutputState }

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) BitrateBps 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) BitrateBps() pulumi.IntOutput

The video bitrate in bits per second.

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) CrfLevel 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) CrfLevel() pulumi.IntPtrOutput

Target CRF level. The default is '21'.

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) ElementType 

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) EntropyCoder 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) EntropyCoder() pulumi.StringPtrOutput

The entropy coder to use. The default is 'cabac'.

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) FrameRate 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) FrameRate() pulumi.IntOutput

The target video frame rate in frames per second (FPS).

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) GopDuration 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) GopDuration() pulumi.StringPtrOutput

Select the GOP size based on the specified duration. The default is '3s'.

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) HeightPixels 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) HeightPixels() pulumi.IntPtrOutput

The height of the video in pixels.

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) Hlg 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) Hlg() JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput

HLG color format setting for H264.

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) PixelFormat 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) PixelFormat() pulumi.StringPtrOutput

Pixel format to use. The default is 'yuv420p'.

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) Preset 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) Preset() pulumi.StringPtrOutput

Enforces the specified codec preset. The default is 'veryfast'.

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) Profile 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) Profile() pulumi.StringPtrOutput

Enforces the specified codec profile.

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) RateControlMode 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) RateControlMode() pulumi.StringPtrOutput

Specify the mode. The default is 'vbr'.

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) Sdr 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) Sdr() JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput

SDR color format setting for H264.

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) ToJobTemplateConfigElementaryStreamVideoStreamH264Output 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) ToJobTemplateConfigElementaryStreamVideoStreamH264Output() JobTemplateConfigElementaryStreamVideoStreamH264Output

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) ToJobTemplateConfigElementaryStreamVideoStreamH264OutputWithContext 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) ToJobTemplateConfigElementaryStreamVideoStreamH264OutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamH264Output

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) ToJobTemplateConfigElementaryStreamVideoStreamH264PtrOutput 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) ToJobTemplateConfigElementaryStreamVideoStreamH264PtrOutput() JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) ToJobTemplateConfigElementaryStreamVideoStreamH264PtrOutputWithContext 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) ToJobTemplateConfigElementaryStreamVideoStreamH264PtrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) VbvFullnessBits 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) VbvFullnessBits() pulumi.IntPtrOutput

Initial fullness of the Video Buffering Verifier (VBV) buffer in bits.

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) VbvSizeBits 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) VbvSizeBits() pulumi.IntPtrOutput

Size of the Video Buffering Verifier (VBV) buffer in bits.

func (JobTemplateConfigElementaryStreamVideoStreamH264Output) WidthPixels 

func (o JobTemplateConfigElementaryStreamVideoStreamH264Output) WidthPixels() pulumi.IntPtrOutput

The width of the video in pixels.

type JobTemplateConfigElementaryStreamVideoStreamH264PtrInput 

type JobTemplateConfigElementaryStreamVideoStreamH264PtrInput interface {
	pulumi.Input

	ToJobTemplateConfigElementaryStreamVideoStreamH264PtrOutput() JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput
	ToJobTemplateConfigElementaryStreamVideoStreamH264PtrOutputWithContext(context.Context) JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput
}

JobTemplateConfigElementaryStreamVideoStreamH264PtrInput is an input type that accepts JobTemplateConfigElementaryStreamVideoStreamH264Args, JobTemplateConfigElementaryStreamVideoStreamH264Ptr and JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput values. You can construct a concrete instance of `JobTemplateConfigElementaryStreamVideoStreamH264PtrInput` via: 

        JobTemplateConfigElementaryStreamVideoStreamH264Args{...}

or:

        nil

func JobTemplateConfigElementaryStreamVideoStreamH264Ptr 

func JobTemplateConfigElementaryStreamVideoStreamH264Ptr(v *JobTemplateConfigElementaryStreamVideoStreamH264Args) JobTemplateConfigElementaryStreamVideoStreamH264PtrInput

type JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput 

type JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) BitrateBps 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) BitrateBps() pulumi.IntPtrOutput

The video bitrate in bits per second.

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) CrfLevel 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) CrfLevel() pulumi.IntPtrOutput

Target CRF level. The default is '21'.

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) Elem 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) Elem() JobTemplateConfigElementaryStreamVideoStreamH264Output

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) ElementType 

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) EntropyCoder 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) EntropyCoder() pulumi.StringPtrOutput

The entropy coder to use. The default is 'cabac'.

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) FrameRate 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) FrameRate() pulumi.IntPtrOutput

The target video frame rate in frames per second (FPS).

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) GopDuration 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) GopDuration() pulumi.StringPtrOutput

Select the GOP size based on the specified duration. The default is '3s'.

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) HeightPixels 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) HeightPixels() pulumi.IntPtrOutput

The height of the video in pixels.

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) Hlg 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) Hlg() JobTemplateConfigElementaryStreamVideoStreamH264HlgPtrOutput

HLG color format setting for H264.

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) PixelFormat 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) PixelFormat() pulumi.StringPtrOutput

Pixel format to use. The default is 'yuv420p'.

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) Preset 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) Preset() pulumi.StringPtrOutput

Enforces the specified codec preset. The default is 'veryfast'.

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) Profile 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) Profile() pulumi.StringPtrOutput

Enforces the specified codec profile.

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) RateControlMode 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) RateControlMode() pulumi.StringPtrOutput

Specify the mode. The default is 'vbr'.

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) Sdr 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) Sdr() JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput

SDR color format setting for H264.

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264PtrOutput 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264PtrOutput() JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264PtrOutputWithContext 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264PtrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) VbvFullnessBits 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) VbvFullnessBits() pulumi.IntPtrOutput

Initial fullness of the Video Buffering Verifier (VBV) buffer in bits.

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) VbvSizeBits 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) VbvSizeBits() pulumi.IntPtrOutput

Size of the Video Buffering Verifier (VBV) buffer in bits.

func (JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) WidthPixels 

func (o JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput) WidthPixels() pulumi.IntPtrOutput

The width of the video in pixels.

type JobTemplateConfigElementaryStreamVideoStreamH264Sdr 

type JobTemplateConfigElementaryStreamVideoStreamH264Sdr struct {
}

type JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs 

type JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs struct {
}

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs) ElementType 

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrOutput 

func (i JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrOutput() JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrOutputWithContext 

func (i JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput 

func (i JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput() JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutputWithContext 

func (i JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput

type JobTemplateConfigElementaryStreamVideoStreamH264SdrInput 

type JobTemplateConfigElementaryStreamVideoStreamH264SdrInput interface {
	pulumi.Input

	ToJobTemplateConfigElementaryStreamVideoStreamH264SdrOutput() JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput
	ToJobTemplateConfigElementaryStreamVideoStreamH264SdrOutputWithContext(context.Context) JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput
}

JobTemplateConfigElementaryStreamVideoStreamH264SdrInput is an input type that accepts JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs and JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput values. You can construct a concrete instance of `JobTemplateConfigElementaryStreamVideoStreamH264SdrInput` via: 

JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs{...}

type JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput 

type JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput) ElementType 

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrOutput 

func (o JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrOutput() JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrOutputWithContext 

func (o JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput 

func (o JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput() JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutputWithContext 

func (o JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput

type JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrInput 

type JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrInput interface {
	pulumi.Input

	ToJobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput() JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput
	ToJobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutputWithContext(context.Context) JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput
}

JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrInput is an input type that accepts JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs, JobTemplateConfigElementaryStreamVideoStreamH264SdrPtr and JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput values. You can construct a concrete instance of `JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrInput` via: 

        JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs{...}

or:

        nil

func JobTemplateConfigElementaryStreamVideoStreamH264SdrPtr 

func JobTemplateConfigElementaryStreamVideoStreamH264SdrPtr(v *JobTemplateConfigElementaryStreamVideoStreamH264SdrArgs) JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrInput

type JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput 

type JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput) Elem 

func (o JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput) Elem() JobTemplateConfigElementaryStreamVideoStreamH264SdrOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput) ElementType 

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput 

func (o JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput() JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput

func (JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutputWithContext 

func (o JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput) ToJobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamH264SdrPtrOutput

type JobTemplateConfigElementaryStreamVideoStreamInput 

type JobTemplateConfigElementaryStreamVideoStreamInput interface {
	pulumi.Input

	ToJobTemplateConfigElementaryStreamVideoStreamOutput() JobTemplateConfigElementaryStreamVideoStreamOutput
	ToJobTemplateConfigElementaryStreamVideoStreamOutputWithContext(context.Context) JobTemplateConfigElementaryStreamVideoStreamOutput
}

JobTemplateConfigElementaryStreamVideoStreamInput is an input type that accepts JobTemplateConfigElementaryStreamVideoStreamArgs and JobTemplateConfigElementaryStreamVideoStreamOutput values. You can construct a concrete instance of `JobTemplateConfigElementaryStreamVideoStreamInput` via: 

JobTemplateConfigElementaryStreamVideoStreamArgs{...}

type JobTemplateConfigElementaryStreamVideoStreamOutput 

type JobTemplateConfigElementaryStreamVideoStreamOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigElementaryStreamVideoStreamOutput) ElementType 

func (JobTemplateConfigElementaryStreamVideoStreamOutput) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamVideoStreamOutput) H264 

func (o JobTemplateConfigElementaryStreamVideoStreamOutput) H264() JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput

H264 codec settings Structure is documented below.

<a name="nestedH264"></a>The `h264` block supports:

func (JobTemplateConfigElementaryStreamVideoStreamOutput) ToJobTemplateConfigElementaryStreamVideoStreamOutput 

func (o JobTemplateConfigElementaryStreamVideoStreamOutput) ToJobTemplateConfigElementaryStreamVideoStreamOutput() JobTemplateConfigElementaryStreamVideoStreamOutput

func (JobTemplateConfigElementaryStreamVideoStreamOutput) ToJobTemplateConfigElementaryStreamVideoStreamOutputWithContext 

func (o JobTemplateConfigElementaryStreamVideoStreamOutput) ToJobTemplateConfigElementaryStreamVideoStreamOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamOutput

func (JobTemplateConfigElementaryStreamVideoStreamOutput) ToJobTemplateConfigElementaryStreamVideoStreamPtrOutput 

func (o JobTemplateConfigElementaryStreamVideoStreamOutput) ToJobTemplateConfigElementaryStreamVideoStreamPtrOutput() JobTemplateConfigElementaryStreamVideoStreamPtrOutput

func (JobTemplateConfigElementaryStreamVideoStreamOutput) ToJobTemplateConfigElementaryStreamVideoStreamPtrOutputWithContext 

func (o JobTemplateConfigElementaryStreamVideoStreamOutput) ToJobTemplateConfigElementaryStreamVideoStreamPtrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamPtrOutput

type JobTemplateConfigElementaryStreamVideoStreamPtrInput 

type JobTemplateConfigElementaryStreamVideoStreamPtrInput interface {
	pulumi.Input

	ToJobTemplateConfigElementaryStreamVideoStreamPtrOutput() JobTemplateConfigElementaryStreamVideoStreamPtrOutput
	ToJobTemplateConfigElementaryStreamVideoStreamPtrOutputWithContext(context.Context) JobTemplateConfigElementaryStreamVideoStreamPtrOutput
}

JobTemplateConfigElementaryStreamVideoStreamPtrInput is an input type that accepts JobTemplateConfigElementaryStreamVideoStreamArgs, JobTemplateConfigElementaryStreamVideoStreamPtr and JobTemplateConfigElementaryStreamVideoStreamPtrOutput values. You can construct a concrete instance of `JobTemplateConfigElementaryStreamVideoStreamPtrInput` via: 

        JobTemplateConfigElementaryStreamVideoStreamArgs{...}

or:

        nil

func JobTemplateConfigElementaryStreamVideoStreamPtr 

func JobTemplateConfigElementaryStreamVideoStreamPtr(v *JobTemplateConfigElementaryStreamVideoStreamArgs) JobTemplateConfigElementaryStreamVideoStreamPtrInput

type JobTemplateConfigElementaryStreamVideoStreamPtrOutput 

type JobTemplateConfigElementaryStreamVideoStreamPtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigElementaryStreamVideoStreamPtrOutput) Elem 

func (o JobTemplateConfigElementaryStreamVideoStreamPtrOutput) Elem() JobTemplateConfigElementaryStreamVideoStreamOutput

func (JobTemplateConfigElementaryStreamVideoStreamPtrOutput) ElementType 

func (JobTemplateConfigElementaryStreamVideoStreamPtrOutput) ElementType() reflect.Type

func (JobTemplateConfigElementaryStreamVideoStreamPtrOutput) H264 

func (o JobTemplateConfigElementaryStreamVideoStreamPtrOutput) H264() JobTemplateConfigElementaryStreamVideoStreamH264PtrOutput

H264 codec settings Structure is documented below.

<a name="nestedH264"></a>The `h264` block supports:

func (JobTemplateConfigElementaryStreamVideoStreamPtrOutput) ToJobTemplateConfigElementaryStreamVideoStreamPtrOutput 

func (o JobTemplateConfigElementaryStreamVideoStreamPtrOutput) ToJobTemplateConfigElementaryStreamVideoStreamPtrOutput() JobTemplateConfigElementaryStreamVideoStreamPtrOutput

func (JobTemplateConfigElementaryStreamVideoStreamPtrOutput) ToJobTemplateConfigElementaryStreamVideoStreamPtrOutputWithContext 

func (o JobTemplateConfigElementaryStreamVideoStreamPtrOutput) ToJobTemplateConfigElementaryStreamVideoStreamPtrOutputWithContext(ctx context.Context) JobTemplateConfigElementaryStreamVideoStreamPtrOutput

type JobTemplateConfigEncryption 

type JobTemplateConfigEncryption struct {
	// Configuration for AES-128 encryption.
	Aes128 *JobTemplateConfigEncryptionAes128 `pulumi:"aes128"`
	// DRM system(s) to use; at least one must be specified. If a DRM system is omitted, it is considered disabled.
	// Structure is documented below.
	DrmSystems *JobTemplateConfigEncryptionDrmSystems `pulumi:"drmSystems"`
	// Identifier for this set of encryption options.
	Id string `pulumi:"id"`
	// Configuration for MPEG Common Encryption (MPEG-CENC).
	// Structure is documented below.
	MpegCenc *JobTemplateConfigEncryptionMpegCenc `pulumi:"mpegCenc"`
	// Configuration for SAMPLE-AES encryption.
	SampleAes *JobTemplateConfigEncryptionSampleAes `pulumi:"sampleAes"`
	// Configuration for secrets stored in Google Secret Manager.
	// Structure is documented below.
	SecretManagerKeySource *JobTemplateConfigEncryptionSecretManagerKeySource `pulumi:"secretManagerKeySource"`
}

type JobTemplateConfigEncryptionAes128 

type JobTemplateConfigEncryptionAes128 struct {
}

type JobTemplateConfigEncryptionAes128Args 

type JobTemplateConfigEncryptionAes128Args struct {
}

func (JobTemplateConfigEncryptionAes128Args) ElementType 

func (JobTemplateConfigEncryptionAes128Args) ElementType() reflect.Type

func (JobTemplateConfigEncryptionAes128Args) ToJobTemplateConfigEncryptionAes128Output 

func (i JobTemplateConfigEncryptionAes128Args) ToJobTemplateConfigEncryptionAes128Output() JobTemplateConfigEncryptionAes128Output

func (JobTemplateConfigEncryptionAes128Args) ToJobTemplateConfigEncryptionAes128OutputWithContext 

func (i JobTemplateConfigEncryptionAes128Args) ToJobTemplateConfigEncryptionAes128OutputWithContext(ctx context.Context) JobTemplateConfigEncryptionAes128Output

func (JobTemplateConfigEncryptionAes128Args) ToJobTemplateConfigEncryptionAes128PtrOutput 

func (i JobTemplateConfigEncryptionAes128Args) ToJobTemplateConfigEncryptionAes128PtrOutput() JobTemplateConfigEncryptionAes128PtrOutput

func (JobTemplateConfigEncryptionAes128Args) ToJobTemplateConfigEncryptionAes128PtrOutputWithContext 

func (i JobTemplateConfigEncryptionAes128Args) ToJobTemplateConfigEncryptionAes128PtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionAes128PtrOutput

type JobTemplateConfigEncryptionAes128Input 

type JobTemplateConfigEncryptionAes128Input interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionAes128Output() JobTemplateConfigEncryptionAes128Output
	ToJobTemplateConfigEncryptionAes128OutputWithContext(context.Context) JobTemplateConfigEncryptionAes128Output
}

JobTemplateConfigEncryptionAes128Input is an input type that accepts JobTemplateConfigEncryptionAes128Args and JobTemplateConfigEncryptionAes128Output values. You can construct a concrete instance of `JobTemplateConfigEncryptionAes128Input` via: 

JobTemplateConfigEncryptionAes128Args{...}

type JobTemplateConfigEncryptionAes128Output 

type JobTemplateConfigEncryptionAes128Output struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionAes128Output) ElementType 

func (JobTemplateConfigEncryptionAes128Output) ElementType() reflect.Type

func (JobTemplateConfigEncryptionAes128Output) ToJobTemplateConfigEncryptionAes128Output 

func (o JobTemplateConfigEncryptionAes128Output) ToJobTemplateConfigEncryptionAes128Output() JobTemplateConfigEncryptionAes128Output

func (JobTemplateConfigEncryptionAes128Output) ToJobTemplateConfigEncryptionAes128OutputWithContext 

func (o JobTemplateConfigEncryptionAes128Output) ToJobTemplateConfigEncryptionAes128OutputWithContext(ctx context.Context) JobTemplateConfigEncryptionAes128Output

func (JobTemplateConfigEncryptionAes128Output) ToJobTemplateConfigEncryptionAes128PtrOutput 

func (o JobTemplateConfigEncryptionAes128Output) ToJobTemplateConfigEncryptionAes128PtrOutput() JobTemplateConfigEncryptionAes128PtrOutput

func (JobTemplateConfigEncryptionAes128Output) ToJobTemplateConfigEncryptionAes128PtrOutputWithContext 

func (o JobTemplateConfigEncryptionAes128Output) ToJobTemplateConfigEncryptionAes128PtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionAes128PtrOutput

type JobTemplateConfigEncryptionAes128PtrInput 

type JobTemplateConfigEncryptionAes128PtrInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionAes128PtrOutput() JobTemplateConfigEncryptionAes128PtrOutput
	ToJobTemplateConfigEncryptionAes128PtrOutputWithContext(context.Context) JobTemplateConfigEncryptionAes128PtrOutput
}

JobTemplateConfigEncryptionAes128PtrInput is an input type that accepts JobTemplateConfigEncryptionAes128Args, JobTemplateConfigEncryptionAes128Ptr and JobTemplateConfigEncryptionAes128PtrOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionAes128PtrInput` via: 

        JobTemplateConfigEncryptionAes128Args{...}

or:

        nil

func JobTemplateConfigEncryptionAes128Ptr 

func JobTemplateConfigEncryptionAes128Ptr(v *JobTemplateConfigEncryptionAes128Args) JobTemplateConfigEncryptionAes128PtrInput

type JobTemplateConfigEncryptionAes128PtrOutput 

type JobTemplateConfigEncryptionAes128PtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionAes128PtrOutput) Elem 

func (o JobTemplateConfigEncryptionAes128PtrOutput) Elem() JobTemplateConfigEncryptionAes128Output

func (JobTemplateConfigEncryptionAes128PtrOutput) ElementType 

func (JobTemplateConfigEncryptionAes128PtrOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionAes128PtrOutput) ToJobTemplateConfigEncryptionAes128PtrOutput 

func (o JobTemplateConfigEncryptionAes128PtrOutput) ToJobTemplateConfigEncryptionAes128PtrOutput() JobTemplateConfigEncryptionAes128PtrOutput

func (JobTemplateConfigEncryptionAes128PtrOutput) ToJobTemplateConfigEncryptionAes128PtrOutputWithContext 

func (o JobTemplateConfigEncryptionAes128PtrOutput) ToJobTemplateConfigEncryptionAes128PtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionAes128PtrOutput

type JobTemplateConfigEncryptionArgs 

type JobTemplateConfigEncryptionArgs struct {
	// Configuration for AES-128 encryption.
	Aes128 JobTemplateConfigEncryptionAes128PtrInput `pulumi:"aes128"`
	// DRM system(s) to use; at least one must be specified. If a DRM system is omitted, it is considered disabled.
	// Structure is documented below.
	DrmSystems JobTemplateConfigEncryptionDrmSystemsPtrInput `pulumi:"drmSystems"`
	// Identifier for this set of encryption options.
	Id pulumi.StringInput `pulumi:"id"`
	// Configuration for MPEG Common Encryption (MPEG-CENC).
	// Structure is documented below.
	MpegCenc JobTemplateConfigEncryptionMpegCencPtrInput `pulumi:"mpegCenc"`
	// Configuration for SAMPLE-AES encryption.
	SampleAes JobTemplateConfigEncryptionSampleAesPtrInput `pulumi:"sampleAes"`
	// Configuration for secrets stored in Google Secret Manager.
	// Structure is documented below.
	SecretManagerKeySource JobTemplateConfigEncryptionSecretManagerKeySourcePtrInput `pulumi:"secretManagerKeySource"`
}

func (JobTemplateConfigEncryptionArgs) ElementType 

func (JobTemplateConfigEncryptionArgs) ElementType() reflect.Type

func (JobTemplateConfigEncryptionArgs) ToJobTemplateConfigEncryptionOutput 

func (i JobTemplateConfigEncryptionArgs) ToJobTemplateConfigEncryptionOutput() JobTemplateConfigEncryptionOutput

func (JobTemplateConfigEncryptionArgs) ToJobTemplateConfigEncryptionOutputWithContext 

func (i JobTemplateConfigEncryptionArgs) ToJobTemplateConfigEncryptionOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionOutput

type JobTemplateConfigEncryptionArray 

type JobTemplateConfigEncryptionArray []JobTemplateConfigEncryptionInput

func (JobTemplateConfigEncryptionArray) ElementType 

func (JobTemplateConfigEncryptionArray) ElementType() reflect.Type

func (JobTemplateConfigEncryptionArray) ToJobTemplateConfigEncryptionArrayOutput 

func (i JobTemplateConfigEncryptionArray) ToJobTemplateConfigEncryptionArrayOutput() JobTemplateConfigEncryptionArrayOutput

func (JobTemplateConfigEncryptionArray) ToJobTemplateConfigEncryptionArrayOutputWithContext 

func (i JobTemplateConfigEncryptionArray) ToJobTemplateConfigEncryptionArrayOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionArrayOutput

type JobTemplateConfigEncryptionArrayInput 

type JobTemplateConfigEncryptionArrayInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionArrayOutput() JobTemplateConfigEncryptionArrayOutput
	ToJobTemplateConfigEncryptionArrayOutputWithContext(context.Context) JobTemplateConfigEncryptionArrayOutput
}

JobTemplateConfigEncryptionArrayInput is an input type that accepts JobTemplateConfigEncryptionArray and JobTemplateConfigEncryptionArrayOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionArrayInput` via: 

JobTemplateConfigEncryptionArray{ JobTemplateConfigEncryptionArgs{...} }

type JobTemplateConfigEncryptionArrayOutput 

type JobTemplateConfigEncryptionArrayOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionArrayOutput) ElementType 

func (JobTemplateConfigEncryptionArrayOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionArrayOutput) Index 

func (o JobTemplateConfigEncryptionArrayOutput) Index(i pulumi.IntInput) JobTemplateConfigEncryptionOutput

func (JobTemplateConfigEncryptionArrayOutput) ToJobTemplateConfigEncryptionArrayOutput 

func (o JobTemplateConfigEncryptionArrayOutput) ToJobTemplateConfigEncryptionArrayOutput() JobTemplateConfigEncryptionArrayOutput

func (JobTemplateConfigEncryptionArrayOutput) ToJobTemplateConfigEncryptionArrayOutputWithContext 

func (o JobTemplateConfigEncryptionArrayOutput) ToJobTemplateConfigEncryptionArrayOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionArrayOutput

type JobTemplateConfigEncryptionDrmSystems 

type JobTemplateConfigEncryptionDrmSystems struct {
	// Clearkey configuration.
	Clearkey *JobTemplateConfigEncryptionDrmSystemsClearkey `pulumi:"clearkey"`
	// Fairplay configuration.
	Fairplay *JobTemplateConfigEncryptionDrmSystemsFairplay `pulumi:"fairplay"`
	// Playready configuration.
	Playready *JobTemplateConfigEncryptionDrmSystemsPlayready `pulumi:"playready"`
	// Widevine configuration.
	Widevine *JobTemplateConfigEncryptionDrmSystemsWidevine `pulumi:"widevine"`
}

type JobTemplateConfigEncryptionDrmSystemsArgs 

type JobTemplateConfigEncryptionDrmSystemsArgs struct {
	// Clearkey configuration.
	Clearkey JobTemplateConfigEncryptionDrmSystemsClearkeyPtrInput `pulumi:"clearkey"`
	// Fairplay configuration.
	Fairplay JobTemplateConfigEncryptionDrmSystemsFairplayPtrInput `pulumi:"fairplay"`
	// Playready configuration.
	Playready JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrInput `pulumi:"playready"`
	// Widevine configuration.
	Widevine JobTemplateConfigEncryptionDrmSystemsWidevinePtrInput `pulumi:"widevine"`
}

func (JobTemplateConfigEncryptionDrmSystemsArgs) ElementType 

func (JobTemplateConfigEncryptionDrmSystemsArgs) ElementType() reflect.Type

func (JobTemplateConfigEncryptionDrmSystemsArgs) ToJobTemplateConfigEncryptionDrmSystemsOutput 

func (i JobTemplateConfigEncryptionDrmSystemsArgs) ToJobTemplateConfigEncryptionDrmSystemsOutput() JobTemplateConfigEncryptionDrmSystemsOutput

func (JobTemplateConfigEncryptionDrmSystemsArgs) ToJobTemplateConfigEncryptionDrmSystemsOutputWithContext 

func (i JobTemplateConfigEncryptionDrmSystemsArgs) ToJobTemplateConfigEncryptionDrmSystemsOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsOutput

func (JobTemplateConfigEncryptionDrmSystemsArgs) ToJobTemplateConfigEncryptionDrmSystemsPtrOutput 

func (i JobTemplateConfigEncryptionDrmSystemsArgs) ToJobTemplateConfigEncryptionDrmSystemsPtrOutput() JobTemplateConfigEncryptionDrmSystemsPtrOutput

func (JobTemplateConfigEncryptionDrmSystemsArgs) ToJobTemplateConfigEncryptionDrmSystemsPtrOutputWithContext 

func (i JobTemplateConfigEncryptionDrmSystemsArgs) ToJobTemplateConfigEncryptionDrmSystemsPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsPtrOutput

type JobTemplateConfigEncryptionDrmSystemsClearkey 

type JobTemplateConfigEncryptionDrmSystemsClearkey struct {
}

type JobTemplateConfigEncryptionDrmSystemsClearkeyArgs 

type JobTemplateConfigEncryptionDrmSystemsClearkeyArgs struct {
}

func (JobTemplateConfigEncryptionDrmSystemsClearkeyArgs) ElementType 

func (JobTemplateConfigEncryptionDrmSystemsClearkeyArgs) ElementType() reflect.Type

func (JobTemplateConfigEncryptionDrmSystemsClearkeyArgs) ToJobTemplateConfigEncryptionDrmSystemsClearkeyOutput 

func (i JobTemplateConfigEncryptionDrmSystemsClearkeyArgs) ToJobTemplateConfigEncryptionDrmSystemsClearkeyOutput() JobTemplateConfigEncryptionDrmSystemsClearkeyOutput

func (JobTemplateConfigEncryptionDrmSystemsClearkeyArgs) ToJobTemplateConfigEncryptionDrmSystemsClearkeyOutputWithContext 

func (i JobTemplateConfigEncryptionDrmSystemsClearkeyArgs) ToJobTemplateConfigEncryptionDrmSystemsClearkeyOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsClearkeyOutput

func (JobTemplateConfigEncryptionDrmSystemsClearkeyArgs) ToJobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput 

func (i JobTemplateConfigEncryptionDrmSystemsClearkeyArgs) ToJobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput() JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput

func (JobTemplateConfigEncryptionDrmSystemsClearkeyArgs) ToJobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutputWithContext 

func (i JobTemplateConfigEncryptionDrmSystemsClearkeyArgs) ToJobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput

type JobTemplateConfigEncryptionDrmSystemsClearkeyInput 

type JobTemplateConfigEncryptionDrmSystemsClearkeyInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionDrmSystemsClearkeyOutput() JobTemplateConfigEncryptionDrmSystemsClearkeyOutput
	ToJobTemplateConfigEncryptionDrmSystemsClearkeyOutputWithContext(context.Context) JobTemplateConfigEncryptionDrmSystemsClearkeyOutput
}

JobTemplateConfigEncryptionDrmSystemsClearkeyInput is an input type that accepts JobTemplateConfigEncryptionDrmSystemsClearkeyArgs and JobTemplateConfigEncryptionDrmSystemsClearkeyOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionDrmSystemsClearkeyInput` via: 

JobTemplateConfigEncryptionDrmSystemsClearkeyArgs{...}

type JobTemplateConfigEncryptionDrmSystemsClearkeyOutput 

type JobTemplateConfigEncryptionDrmSystemsClearkeyOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionDrmSystemsClearkeyOutput) ElementType 

func (JobTemplateConfigEncryptionDrmSystemsClearkeyOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionDrmSystemsClearkeyOutput) ToJobTemplateConfigEncryptionDrmSystemsClearkeyOutput 

func (o JobTemplateConfigEncryptionDrmSystemsClearkeyOutput) ToJobTemplateConfigEncryptionDrmSystemsClearkeyOutput() JobTemplateConfigEncryptionDrmSystemsClearkeyOutput

func (JobTemplateConfigEncryptionDrmSystemsClearkeyOutput) ToJobTemplateConfigEncryptionDrmSystemsClearkeyOutputWithContext 

func (o JobTemplateConfigEncryptionDrmSystemsClearkeyOutput) ToJobTemplateConfigEncryptionDrmSystemsClearkeyOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsClearkeyOutput

func (JobTemplateConfigEncryptionDrmSystemsClearkeyOutput) ToJobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput 

func (o JobTemplateConfigEncryptionDrmSystemsClearkeyOutput) ToJobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput() JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput

func (JobTemplateConfigEncryptionDrmSystemsClearkeyOutput) ToJobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutputWithContext 

func (o JobTemplateConfigEncryptionDrmSystemsClearkeyOutput) ToJobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput

type JobTemplateConfigEncryptionDrmSystemsClearkeyPtrInput 

type JobTemplateConfigEncryptionDrmSystemsClearkeyPtrInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput() JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput
	ToJobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutputWithContext(context.Context) JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput
}

JobTemplateConfigEncryptionDrmSystemsClearkeyPtrInput is an input type that accepts JobTemplateConfigEncryptionDrmSystemsClearkeyArgs, JobTemplateConfigEncryptionDrmSystemsClearkeyPtr and JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionDrmSystemsClearkeyPtrInput` via: 

        JobTemplateConfigEncryptionDrmSystemsClearkeyArgs{...}

or:

        nil

func JobTemplateConfigEncryptionDrmSystemsClearkeyPtr 

func JobTemplateConfigEncryptionDrmSystemsClearkeyPtr(v *JobTemplateConfigEncryptionDrmSystemsClearkeyArgs) JobTemplateConfigEncryptionDrmSystemsClearkeyPtrInput

type JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput 

type JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput) Elem 

func (o JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput) Elem() JobTemplateConfigEncryptionDrmSystemsClearkeyOutput

func (JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput) ElementType 

func (JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput) ToJobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput 

func (o JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput) ToJobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput() JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput

func (JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput) ToJobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutputWithContext 

func (o JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput) ToJobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput

type JobTemplateConfigEncryptionDrmSystemsFairplay 

type JobTemplateConfigEncryptionDrmSystemsFairplay struct {
}

type JobTemplateConfigEncryptionDrmSystemsFairplayArgs 

type JobTemplateConfigEncryptionDrmSystemsFairplayArgs struct {
}

func (JobTemplateConfigEncryptionDrmSystemsFairplayArgs) ElementType 

func (JobTemplateConfigEncryptionDrmSystemsFairplayArgs) ElementType() reflect.Type

func (JobTemplateConfigEncryptionDrmSystemsFairplayArgs) ToJobTemplateConfigEncryptionDrmSystemsFairplayOutput 

func (i JobTemplateConfigEncryptionDrmSystemsFairplayArgs) ToJobTemplateConfigEncryptionDrmSystemsFairplayOutput() JobTemplateConfigEncryptionDrmSystemsFairplayOutput

func (JobTemplateConfigEncryptionDrmSystemsFairplayArgs) ToJobTemplateConfigEncryptionDrmSystemsFairplayOutputWithContext 

func (i JobTemplateConfigEncryptionDrmSystemsFairplayArgs) ToJobTemplateConfigEncryptionDrmSystemsFairplayOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsFairplayOutput

func (JobTemplateConfigEncryptionDrmSystemsFairplayArgs) ToJobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput 

func (i JobTemplateConfigEncryptionDrmSystemsFairplayArgs) ToJobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput() JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput

func (JobTemplateConfigEncryptionDrmSystemsFairplayArgs) ToJobTemplateConfigEncryptionDrmSystemsFairplayPtrOutputWithContext 

func (i JobTemplateConfigEncryptionDrmSystemsFairplayArgs) ToJobTemplateConfigEncryptionDrmSystemsFairplayPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput

type JobTemplateConfigEncryptionDrmSystemsFairplayInput 

type JobTemplateConfigEncryptionDrmSystemsFairplayInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionDrmSystemsFairplayOutput() JobTemplateConfigEncryptionDrmSystemsFairplayOutput
	ToJobTemplateConfigEncryptionDrmSystemsFairplayOutputWithContext(context.Context) JobTemplateConfigEncryptionDrmSystemsFairplayOutput
}

JobTemplateConfigEncryptionDrmSystemsFairplayInput is an input type that accepts JobTemplateConfigEncryptionDrmSystemsFairplayArgs and JobTemplateConfigEncryptionDrmSystemsFairplayOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionDrmSystemsFairplayInput` via: 

JobTemplateConfigEncryptionDrmSystemsFairplayArgs{...}

type JobTemplateConfigEncryptionDrmSystemsFairplayOutput 

type JobTemplateConfigEncryptionDrmSystemsFairplayOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionDrmSystemsFairplayOutput) ElementType 

func (JobTemplateConfigEncryptionDrmSystemsFairplayOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionDrmSystemsFairplayOutput) ToJobTemplateConfigEncryptionDrmSystemsFairplayOutput 

func (o JobTemplateConfigEncryptionDrmSystemsFairplayOutput) ToJobTemplateConfigEncryptionDrmSystemsFairplayOutput() JobTemplateConfigEncryptionDrmSystemsFairplayOutput

func (JobTemplateConfigEncryptionDrmSystemsFairplayOutput) ToJobTemplateConfigEncryptionDrmSystemsFairplayOutputWithContext 

func (o JobTemplateConfigEncryptionDrmSystemsFairplayOutput) ToJobTemplateConfigEncryptionDrmSystemsFairplayOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsFairplayOutput

func (JobTemplateConfigEncryptionDrmSystemsFairplayOutput) ToJobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput 

func (o JobTemplateConfigEncryptionDrmSystemsFairplayOutput) ToJobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput() JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput

func (JobTemplateConfigEncryptionDrmSystemsFairplayOutput) ToJobTemplateConfigEncryptionDrmSystemsFairplayPtrOutputWithContext 

func (o JobTemplateConfigEncryptionDrmSystemsFairplayOutput) ToJobTemplateConfigEncryptionDrmSystemsFairplayPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput

type JobTemplateConfigEncryptionDrmSystemsFairplayPtrInput 

type JobTemplateConfigEncryptionDrmSystemsFairplayPtrInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput() JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput
	ToJobTemplateConfigEncryptionDrmSystemsFairplayPtrOutputWithContext(context.Context) JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput
}

JobTemplateConfigEncryptionDrmSystemsFairplayPtrInput is an input type that accepts JobTemplateConfigEncryptionDrmSystemsFairplayArgs, JobTemplateConfigEncryptionDrmSystemsFairplayPtr and JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionDrmSystemsFairplayPtrInput` via: 

        JobTemplateConfigEncryptionDrmSystemsFairplayArgs{...}

or:

        nil

func JobTemplateConfigEncryptionDrmSystemsFairplayPtr 

func JobTemplateConfigEncryptionDrmSystemsFairplayPtr(v *JobTemplateConfigEncryptionDrmSystemsFairplayArgs) JobTemplateConfigEncryptionDrmSystemsFairplayPtrInput

type JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput 

type JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput) Elem 

func (o JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput) Elem() JobTemplateConfigEncryptionDrmSystemsFairplayOutput

func (JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput) ElementType 

func (JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput) ToJobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput 

func (o JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput) ToJobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput() JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput

func (JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput) ToJobTemplateConfigEncryptionDrmSystemsFairplayPtrOutputWithContext 

func (o JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput) ToJobTemplateConfigEncryptionDrmSystemsFairplayPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput

type JobTemplateConfigEncryptionDrmSystemsInput 

type JobTemplateConfigEncryptionDrmSystemsInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionDrmSystemsOutput() JobTemplateConfigEncryptionDrmSystemsOutput
	ToJobTemplateConfigEncryptionDrmSystemsOutputWithContext(context.Context) JobTemplateConfigEncryptionDrmSystemsOutput
}

JobTemplateConfigEncryptionDrmSystemsInput is an input type that accepts JobTemplateConfigEncryptionDrmSystemsArgs and JobTemplateConfigEncryptionDrmSystemsOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionDrmSystemsInput` via: 

JobTemplateConfigEncryptionDrmSystemsArgs{...}

type JobTemplateConfigEncryptionDrmSystemsOutput 

type JobTemplateConfigEncryptionDrmSystemsOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionDrmSystemsOutput) Clearkey 

func (o JobTemplateConfigEncryptionDrmSystemsOutput) Clearkey() JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput

Clearkey configuration.

func (JobTemplateConfigEncryptionDrmSystemsOutput) ElementType 

func (JobTemplateConfigEncryptionDrmSystemsOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionDrmSystemsOutput) Fairplay 

func (o JobTemplateConfigEncryptionDrmSystemsOutput) Fairplay() JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput

Fairplay configuration.

func (JobTemplateConfigEncryptionDrmSystemsOutput) Playready 

func (o JobTemplateConfigEncryptionDrmSystemsOutput) Playready() JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput

Playready configuration.

func (JobTemplateConfigEncryptionDrmSystemsOutput) ToJobTemplateConfigEncryptionDrmSystemsOutput 

func (o JobTemplateConfigEncryptionDrmSystemsOutput) ToJobTemplateConfigEncryptionDrmSystemsOutput() JobTemplateConfigEncryptionDrmSystemsOutput

func (JobTemplateConfigEncryptionDrmSystemsOutput) ToJobTemplateConfigEncryptionDrmSystemsOutputWithContext 

func (o JobTemplateConfigEncryptionDrmSystemsOutput) ToJobTemplateConfigEncryptionDrmSystemsOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsOutput

func (JobTemplateConfigEncryptionDrmSystemsOutput) ToJobTemplateConfigEncryptionDrmSystemsPtrOutput 

func (o JobTemplateConfigEncryptionDrmSystemsOutput) ToJobTemplateConfigEncryptionDrmSystemsPtrOutput() JobTemplateConfigEncryptionDrmSystemsPtrOutput

func (JobTemplateConfigEncryptionDrmSystemsOutput) ToJobTemplateConfigEncryptionDrmSystemsPtrOutputWithContext 

func (o JobTemplateConfigEncryptionDrmSystemsOutput) ToJobTemplateConfigEncryptionDrmSystemsPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsPtrOutput

func (JobTemplateConfigEncryptionDrmSystemsOutput) Widevine 

func (o JobTemplateConfigEncryptionDrmSystemsOutput) Widevine() JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput

Widevine configuration.

type JobTemplateConfigEncryptionDrmSystemsPlayready 

type JobTemplateConfigEncryptionDrmSystemsPlayready struct {
}

type JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs 

type JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs struct {
}

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs) ElementType 

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs) ElementType() reflect.Type

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyOutput 

func (i JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyOutput() JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyOutputWithContext 

func (i JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput 

func (i JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput() JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutputWithContext 

func (i JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput

type JobTemplateConfigEncryptionDrmSystemsPlayreadyInput 

type JobTemplateConfigEncryptionDrmSystemsPlayreadyInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionDrmSystemsPlayreadyOutput() JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput
	ToJobTemplateConfigEncryptionDrmSystemsPlayreadyOutputWithContext(context.Context) JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput
}

JobTemplateConfigEncryptionDrmSystemsPlayreadyInput is an input type that accepts JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs and JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionDrmSystemsPlayreadyInput` via: 

JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs{...}

type JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput 

type JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput) ElementType 

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyOutput 

func (o JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyOutput() JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyOutputWithContext 

func (o JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput 

func (o JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput() JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutputWithContext 

func (o JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput

type JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrInput 

type JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput() JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput
	ToJobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutputWithContext(context.Context) JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput
}

JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrInput is an input type that accepts JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs, JobTemplateConfigEncryptionDrmSystemsPlayreadyPtr and JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrInput` via: 

        JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs{...}

or:

        nil

func JobTemplateConfigEncryptionDrmSystemsPlayreadyPtr 

func JobTemplateConfigEncryptionDrmSystemsPlayreadyPtr(v *JobTemplateConfigEncryptionDrmSystemsPlayreadyArgs) JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrInput

type JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput 

type JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput) Elem 

func (o JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput) Elem() JobTemplateConfigEncryptionDrmSystemsPlayreadyOutput

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput) ElementType 

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput 

func (o JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput() JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput

func (JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutputWithContext 

func (o JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput) ToJobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput

type JobTemplateConfigEncryptionDrmSystemsPtrInput 

type JobTemplateConfigEncryptionDrmSystemsPtrInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionDrmSystemsPtrOutput() JobTemplateConfigEncryptionDrmSystemsPtrOutput
	ToJobTemplateConfigEncryptionDrmSystemsPtrOutputWithContext(context.Context) JobTemplateConfigEncryptionDrmSystemsPtrOutput
}

JobTemplateConfigEncryptionDrmSystemsPtrInput is an input type that accepts JobTemplateConfigEncryptionDrmSystemsArgs, JobTemplateConfigEncryptionDrmSystemsPtr and JobTemplateConfigEncryptionDrmSystemsPtrOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionDrmSystemsPtrInput` via: 

        JobTemplateConfigEncryptionDrmSystemsArgs{...}

or:

        nil

func JobTemplateConfigEncryptionDrmSystemsPtr 

func JobTemplateConfigEncryptionDrmSystemsPtr(v *JobTemplateConfigEncryptionDrmSystemsArgs) JobTemplateConfigEncryptionDrmSystemsPtrInput

type JobTemplateConfigEncryptionDrmSystemsPtrOutput 

type JobTemplateConfigEncryptionDrmSystemsPtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionDrmSystemsPtrOutput) Clearkey 

func (o JobTemplateConfigEncryptionDrmSystemsPtrOutput) Clearkey() JobTemplateConfigEncryptionDrmSystemsClearkeyPtrOutput

Clearkey configuration.

func (JobTemplateConfigEncryptionDrmSystemsPtrOutput) Elem 

func (o JobTemplateConfigEncryptionDrmSystemsPtrOutput) Elem() JobTemplateConfigEncryptionDrmSystemsOutput

func (JobTemplateConfigEncryptionDrmSystemsPtrOutput) ElementType 

func (JobTemplateConfigEncryptionDrmSystemsPtrOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionDrmSystemsPtrOutput) Fairplay 

func (o JobTemplateConfigEncryptionDrmSystemsPtrOutput) Fairplay() JobTemplateConfigEncryptionDrmSystemsFairplayPtrOutput

Fairplay configuration.

func (JobTemplateConfigEncryptionDrmSystemsPtrOutput) Playready 

func (o JobTemplateConfigEncryptionDrmSystemsPtrOutput) Playready() JobTemplateConfigEncryptionDrmSystemsPlayreadyPtrOutput

Playready configuration.

func (JobTemplateConfigEncryptionDrmSystemsPtrOutput) ToJobTemplateConfigEncryptionDrmSystemsPtrOutput 

func (o JobTemplateConfigEncryptionDrmSystemsPtrOutput) ToJobTemplateConfigEncryptionDrmSystemsPtrOutput() JobTemplateConfigEncryptionDrmSystemsPtrOutput

func (JobTemplateConfigEncryptionDrmSystemsPtrOutput) ToJobTemplateConfigEncryptionDrmSystemsPtrOutputWithContext 

func (o JobTemplateConfigEncryptionDrmSystemsPtrOutput) ToJobTemplateConfigEncryptionDrmSystemsPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsPtrOutput

func (JobTemplateConfigEncryptionDrmSystemsPtrOutput) Widevine 

func (o JobTemplateConfigEncryptionDrmSystemsPtrOutput) Widevine() JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput

Widevine configuration.

type JobTemplateConfigEncryptionDrmSystemsWidevine 

type JobTemplateConfigEncryptionDrmSystemsWidevine struct {
}

type JobTemplateConfigEncryptionDrmSystemsWidevineArgs 

type JobTemplateConfigEncryptionDrmSystemsWidevineArgs struct {
}

func (JobTemplateConfigEncryptionDrmSystemsWidevineArgs) ElementType 

func (JobTemplateConfigEncryptionDrmSystemsWidevineArgs) ElementType() reflect.Type

func (JobTemplateConfigEncryptionDrmSystemsWidevineArgs) ToJobTemplateConfigEncryptionDrmSystemsWidevineOutput 

func (i JobTemplateConfigEncryptionDrmSystemsWidevineArgs) ToJobTemplateConfigEncryptionDrmSystemsWidevineOutput() JobTemplateConfigEncryptionDrmSystemsWidevineOutput

func (JobTemplateConfigEncryptionDrmSystemsWidevineArgs) ToJobTemplateConfigEncryptionDrmSystemsWidevineOutputWithContext 

func (i JobTemplateConfigEncryptionDrmSystemsWidevineArgs) ToJobTemplateConfigEncryptionDrmSystemsWidevineOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsWidevineOutput

func (JobTemplateConfigEncryptionDrmSystemsWidevineArgs) ToJobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput 

func (i JobTemplateConfigEncryptionDrmSystemsWidevineArgs) ToJobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput() JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput

func (JobTemplateConfigEncryptionDrmSystemsWidevineArgs) ToJobTemplateConfigEncryptionDrmSystemsWidevinePtrOutputWithContext 

func (i JobTemplateConfigEncryptionDrmSystemsWidevineArgs) ToJobTemplateConfigEncryptionDrmSystemsWidevinePtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput

type JobTemplateConfigEncryptionDrmSystemsWidevineInput 

type JobTemplateConfigEncryptionDrmSystemsWidevineInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionDrmSystemsWidevineOutput() JobTemplateConfigEncryptionDrmSystemsWidevineOutput
	ToJobTemplateConfigEncryptionDrmSystemsWidevineOutputWithContext(context.Context) JobTemplateConfigEncryptionDrmSystemsWidevineOutput
}

JobTemplateConfigEncryptionDrmSystemsWidevineInput is an input type that accepts JobTemplateConfigEncryptionDrmSystemsWidevineArgs and JobTemplateConfigEncryptionDrmSystemsWidevineOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionDrmSystemsWidevineInput` via: 

JobTemplateConfigEncryptionDrmSystemsWidevineArgs{...}

type JobTemplateConfigEncryptionDrmSystemsWidevineOutput 

type JobTemplateConfigEncryptionDrmSystemsWidevineOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionDrmSystemsWidevineOutput) ElementType 

func (JobTemplateConfigEncryptionDrmSystemsWidevineOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionDrmSystemsWidevineOutput) ToJobTemplateConfigEncryptionDrmSystemsWidevineOutput 

func (o JobTemplateConfigEncryptionDrmSystemsWidevineOutput) ToJobTemplateConfigEncryptionDrmSystemsWidevineOutput() JobTemplateConfigEncryptionDrmSystemsWidevineOutput

func (JobTemplateConfigEncryptionDrmSystemsWidevineOutput) ToJobTemplateConfigEncryptionDrmSystemsWidevineOutputWithContext 

func (o JobTemplateConfigEncryptionDrmSystemsWidevineOutput) ToJobTemplateConfigEncryptionDrmSystemsWidevineOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsWidevineOutput

func (JobTemplateConfigEncryptionDrmSystemsWidevineOutput) ToJobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput 

func (o JobTemplateConfigEncryptionDrmSystemsWidevineOutput) ToJobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput() JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput

func (JobTemplateConfigEncryptionDrmSystemsWidevineOutput) ToJobTemplateConfigEncryptionDrmSystemsWidevinePtrOutputWithContext 

func (o JobTemplateConfigEncryptionDrmSystemsWidevineOutput) ToJobTemplateConfigEncryptionDrmSystemsWidevinePtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput

type JobTemplateConfigEncryptionDrmSystemsWidevinePtrInput 

type JobTemplateConfigEncryptionDrmSystemsWidevinePtrInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput() JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput
	ToJobTemplateConfigEncryptionDrmSystemsWidevinePtrOutputWithContext(context.Context) JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput
}

JobTemplateConfigEncryptionDrmSystemsWidevinePtrInput is an input type that accepts JobTemplateConfigEncryptionDrmSystemsWidevineArgs, JobTemplateConfigEncryptionDrmSystemsWidevinePtr and JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionDrmSystemsWidevinePtrInput` via: 

        JobTemplateConfigEncryptionDrmSystemsWidevineArgs{...}

or:

        nil

func JobTemplateConfigEncryptionDrmSystemsWidevinePtr 

func JobTemplateConfigEncryptionDrmSystemsWidevinePtr(v *JobTemplateConfigEncryptionDrmSystemsWidevineArgs) JobTemplateConfigEncryptionDrmSystemsWidevinePtrInput

type JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput 

type JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput) Elem 

func (o JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput) Elem() JobTemplateConfigEncryptionDrmSystemsWidevineOutput

func (JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput) ElementType 

func (JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput) ToJobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput 

func (o JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput) ToJobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput() JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput

func (JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput) ToJobTemplateConfigEncryptionDrmSystemsWidevinePtrOutputWithContext 

func (o JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput) ToJobTemplateConfigEncryptionDrmSystemsWidevinePtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionDrmSystemsWidevinePtrOutput

type JobTemplateConfigEncryptionInput 

type JobTemplateConfigEncryptionInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionOutput() JobTemplateConfigEncryptionOutput
	ToJobTemplateConfigEncryptionOutputWithContext(context.Context) JobTemplateConfigEncryptionOutput
}

JobTemplateConfigEncryptionInput is an input type that accepts JobTemplateConfigEncryptionArgs and JobTemplateConfigEncryptionOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionInput` via: 

JobTemplateConfigEncryptionArgs{...}

type JobTemplateConfigEncryptionMpegCenc 

type JobTemplateConfigEncryptionMpegCenc struct {
	// Specify the encryption scheme.
	Scheme string `pulumi:"scheme"`
}

type JobTemplateConfigEncryptionMpegCencArgs 

type JobTemplateConfigEncryptionMpegCencArgs struct {
	// Specify the encryption scheme.
	Scheme pulumi.StringInput `pulumi:"scheme"`
}

func (JobTemplateConfigEncryptionMpegCencArgs) ElementType 

func (JobTemplateConfigEncryptionMpegCencArgs) ElementType() reflect.Type

func (JobTemplateConfigEncryptionMpegCencArgs) ToJobTemplateConfigEncryptionMpegCencOutput 

func (i JobTemplateConfigEncryptionMpegCencArgs) ToJobTemplateConfigEncryptionMpegCencOutput() JobTemplateConfigEncryptionMpegCencOutput

func (JobTemplateConfigEncryptionMpegCencArgs) ToJobTemplateConfigEncryptionMpegCencOutputWithContext 

func (i JobTemplateConfigEncryptionMpegCencArgs) ToJobTemplateConfigEncryptionMpegCencOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionMpegCencOutput

func (JobTemplateConfigEncryptionMpegCencArgs) ToJobTemplateConfigEncryptionMpegCencPtrOutput 

func (i JobTemplateConfigEncryptionMpegCencArgs) ToJobTemplateConfigEncryptionMpegCencPtrOutput() JobTemplateConfigEncryptionMpegCencPtrOutput

func (JobTemplateConfigEncryptionMpegCencArgs) ToJobTemplateConfigEncryptionMpegCencPtrOutputWithContext 

func (i JobTemplateConfigEncryptionMpegCencArgs) ToJobTemplateConfigEncryptionMpegCencPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionMpegCencPtrOutput

type JobTemplateConfigEncryptionMpegCencInput 

type JobTemplateConfigEncryptionMpegCencInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionMpegCencOutput() JobTemplateConfigEncryptionMpegCencOutput
	ToJobTemplateConfigEncryptionMpegCencOutputWithContext(context.Context) JobTemplateConfigEncryptionMpegCencOutput
}

JobTemplateConfigEncryptionMpegCencInput is an input type that accepts JobTemplateConfigEncryptionMpegCencArgs and JobTemplateConfigEncryptionMpegCencOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionMpegCencInput` via: 

JobTemplateConfigEncryptionMpegCencArgs{...}

type JobTemplateConfigEncryptionMpegCencOutput 

type JobTemplateConfigEncryptionMpegCencOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionMpegCencOutput) ElementType 

func (JobTemplateConfigEncryptionMpegCencOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionMpegCencOutput) Scheme 

func (o JobTemplateConfigEncryptionMpegCencOutput) Scheme() pulumi.StringOutput

Specify the encryption scheme.

func (JobTemplateConfigEncryptionMpegCencOutput) ToJobTemplateConfigEncryptionMpegCencOutput 

func (o JobTemplateConfigEncryptionMpegCencOutput) ToJobTemplateConfigEncryptionMpegCencOutput() JobTemplateConfigEncryptionMpegCencOutput

func (JobTemplateConfigEncryptionMpegCencOutput) ToJobTemplateConfigEncryptionMpegCencOutputWithContext 

func (o JobTemplateConfigEncryptionMpegCencOutput) ToJobTemplateConfigEncryptionMpegCencOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionMpegCencOutput

func (JobTemplateConfigEncryptionMpegCencOutput) ToJobTemplateConfigEncryptionMpegCencPtrOutput 

func (o JobTemplateConfigEncryptionMpegCencOutput) ToJobTemplateConfigEncryptionMpegCencPtrOutput() JobTemplateConfigEncryptionMpegCencPtrOutput

func (JobTemplateConfigEncryptionMpegCencOutput) ToJobTemplateConfigEncryptionMpegCencPtrOutputWithContext 

func (o JobTemplateConfigEncryptionMpegCencOutput) ToJobTemplateConfigEncryptionMpegCencPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionMpegCencPtrOutput

type JobTemplateConfigEncryptionMpegCencPtrInput 

type JobTemplateConfigEncryptionMpegCencPtrInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionMpegCencPtrOutput() JobTemplateConfigEncryptionMpegCencPtrOutput
	ToJobTemplateConfigEncryptionMpegCencPtrOutputWithContext(context.Context) JobTemplateConfigEncryptionMpegCencPtrOutput
}

JobTemplateConfigEncryptionMpegCencPtrInput is an input type that accepts JobTemplateConfigEncryptionMpegCencArgs, JobTemplateConfigEncryptionMpegCencPtr and JobTemplateConfigEncryptionMpegCencPtrOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionMpegCencPtrInput` via: 

        JobTemplateConfigEncryptionMpegCencArgs{...}

or:

        nil

func JobTemplateConfigEncryptionMpegCencPtr 

func JobTemplateConfigEncryptionMpegCencPtr(v *JobTemplateConfigEncryptionMpegCencArgs) JobTemplateConfigEncryptionMpegCencPtrInput

type JobTemplateConfigEncryptionMpegCencPtrOutput 

type JobTemplateConfigEncryptionMpegCencPtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionMpegCencPtrOutput) Elem 

func (o JobTemplateConfigEncryptionMpegCencPtrOutput) Elem() JobTemplateConfigEncryptionMpegCencOutput

func (JobTemplateConfigEncryptionMpegCencPtrOutput) ElementType 

func (JobTemplateConfigEncryptionMpegCencPtrOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionMpegCencPtrOutput) Scheme 

func (o JobTemplateConfigEncryptionMpegCencPtrOutput) Scheme() pulumi.StringPtrOutput

Specify the encryption scheme.

func (JobTemplateConfigEncryptionMpegCencPtrOutput) ToJobTemplateConfigEncryptionMpegCencPtrOutput 

func (o JobTemplateConfigEncryptionMpegCencPtrOutput) ToJobTemplateConfigEncryptionMpegCencPtrOutput() JobTemplateConfigEncryptionMpegCencPtrOutput

func (JobTemplateConfigEncryptionMpegCencPtrOutput) ToJobTemplateConfigEncryptionMpegCencPtrOutputWithContext 

func (o JobTemplateConfigEncryptionMpegCencPtrOutput) ToJobTemplateConfigEncryptionMpegCencPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionMpegCencPtrOutput

type JobTemplateConfigEncryptionOutput 

type JobTemplateConfigEncryptionOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionOutput) Aes128 

func (o JobTemplateConfigEncryptionOutput) Aes128() JobTemplateConfigEncryptionAes128PtrOutput

Configuration for AES-128 encryption.

func (JobTemplateConfigEncryptionOutput) DrmSystems 

func (o JobTemplateConfigEncryptionOutput) DrmSystems() JobTemplateConfigEncryptionDrmSystemsPtrOutput

DRM system(s) to use; at least one must be specified. If a DRM system is omitted, it is considered disabled. Structure is documented below.

func (JobTemplateConfigEncryptionOutput) ElementType 

func (JobTemplateConfigEncryptionOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionOutput) Id 

func (o JobTemplateConfigEncryptionOutput) Id() pulumi.StringOutput

Identifier for this set of encryption options.

func (JobTemplateConfigEncryptionOutput) MpegCenc 

func (o JobTemplateConfigEncryptionOutput) MpegCenc() JobTemplateConfigEncryptionMpegCencPtrOutput

Configuration for MPEG Common Encryption (MPEG-CENC). Structure is documented below.

func (JobTemplateConfigEncryptionOutput) SampleAes 

func (o JobTemplateConfigEncryptionOutput) SampleAes() JobTemplateConfigEncryptionSampleAesPtrOutput

Configuration for SAMPLE-AES encryption.

func (JobTemplateConfigEncryptionOutput) SecretManagerKeySource 

func (o JobTemplateConfigEncryptionOutput) SecretManagerKeySource() JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput

Configuration for secrets stored in Google Secret Manager. Structure is documented below.

func (JobTemplateConfigEncryptionOutput) ToJobTemplateConfigEncryptionOutput 

func (o JobTemplateConfigEncryptionOutput) ToJobTemplateConfigEncryptionOutput() JobTemplateConfigEncryptionOutput

func (JobTemplateConfigEncryptionOutput) ToJobTemplateConfigEncryptionOutputWithContext 

func (o JobTemplateConfigEncryptionOutput) ToJobTemplateConfigEncryptionOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionOutput

type JobTemplateConfigEncryptionSampleAes 

type JobTemplateConfigEncryptionSampleAes struct {
}

type JobTemplateConfigEncryptionSampleAesArgs 

type JobTemplateConfigEncryptionSampleAesArgs struct {
}

func (JobTemplateConfigEncryptionSampleAesArgs) ElementType 

func (JobTemplateConfigEncryptionSampleAesArgs) ElementType() reflect.Type

func (JobTemplateConfigEncryptionSampleAesArgs) ToJobTemplateConfigEncryptionSampleAesOutput 

func (i JobTemplateConfigEncryptionSampleAesArgs) ToJobTemplateConfigEncryptionSampleAesOutput() JobTemplateConfigEncryptionSampleAesOutput

func (JobTemplateConfigEncryptionSampleAesArgs) ToJobTemplateConfigEncryptionSampleAesOutputWithContext 

func (i JobTemplateConfigEncryptionSampleAesArgs) ToJobTemplateConfigEncryptionSampleAesOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionSampleAesOutput

func (JobTemplateConfigEncryptionSampleAesArgs) ToJobTemplateConfigEncryptionSampleAesPtrOutput 

func (i JobTemplateConfigEncryptionSampleAesArgs) ToJobTemplateConfigEncryptionSampleAesPtrOutput() JobTemplateConfigEncryptionSampleAesPtrOutput

func (JobTemplateConfigEncryptionSampleAesArgs) ToJobTemplateConfigEncryptionSampleAesPtrOutputWithContext 

func (i JobTemplateConfigEncryptionSampleAesArgs) ToJobTemplateConfigEncryptionSampleAesPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionSampleAesPtrOutput

type JobTemplateConfigEncryptionSampleAesInput 

type JobTemplateConfigEncryptionSampleAesInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionSampleAesOutput() JobTemplateConfigEncryptionSampleAesOutput
	ToJobTemplateConfigEncryptionSampleAesOutputWithContext(context.Context) JobTemplateConfigEncryptionSampleAesOutput
}

JobTemplateConfigEncryptionSampleAesInput is an input type that accepts JobTemplateConfigEncryptionSampleAesArgs and JobTemplateConfigEncryptionSampleAesOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionSampleAesInput` via: 

JobTemplateConfigEncryptionSampleAesArgs{...}

type JobTemplateConfigEncryptionSampleAesOutput 

type JobTemplateConfigEncryptionSampleAesOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionSampleAesOutput) ElementType 

func (JobTemplateConfigEncryptionSampleAesOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionSampleAesOutput) ToJobTemplateConfigEncryptionSampleAesOutput 

func (o JobTemplateConfigEncryptionSampleAesOutput) ToJobTemplateConfigEncryptionSampleAesOutput() JobTemplateConfigEncryptionSampleAesOutput

func (JobTemplateConfigEncryptionSampleAesOutput) ToJobTemplateConfigEncryptionSampleAesOutputWithContext 

func (o JobTemplateConfigEncryptionSampleAesOutput) ToJobTemplateConfigEncryptionSampleAesOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionSampleAesOutput

func (JobTemplateConfigEncryptionSampleAesOutput) ToJobTemplateConfigEncryptionSampleAesPtrOutput 

func (o JobTemplateConfigEncryptionSampleAesOutput) ToJobTemplateConfigEncryptionSampleAesPtrOutput() JobTemplateConfigEncryptionSampleAesPtrOutput

func (JobTemplateConfigEncryptionSampleAesOutput) ToJobTemplateConfigEncryptionSampleAesPtrOutputWithContext 

func (o JobTemplateConfigEncryptionSampleAesOutput) ToJobTemplateConfigEncryptionSampleAesPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionSampleAesPtrOutput

type JobTemplateConfigEncryptionSampleAesPtrInput 

type JobTemplateConfigEncryptionSampleAesPtrInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionSampleAesPtrOutput() JobTemplateConfigEncryptionSampleAesPtrOutput
	ToJobTemplateConfigEncryptionSampleAesPtrOutputWithContext(context.Context) JobTemplateConfigEncryptionSampleAesPtrOutput
}

JobTemplateConfigEncryptionSampleAesPtrInput is an input type that accepts JobTemplateConfigEncryptionSampleAesArgs, JobTemplateConfigEncryptionSampleAesPtr and JobTemplateConfigEncryptionSampleAesPtrOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionSampleAesPtrInput` via: 

        JobTemplateConfigEncryptionSampleAesArgs{...}

or:

        nil

func JobTemplateConfigEncryptionSampleAesPtr 

func JobTemplateConfigEncryptionSampleAesPtr(v *JobTemplateConfigEncryptionSampleAesArgs) JobTemplateConfigEncryptionSampleAesPtrInput

type JobTemplateConfigEncryptionSampleAesPtrOutput 

type JobTemplateConfigEncryptionSampleAesPtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionSampleAesPtrOutput) Elem 

func (o JobTemplateConfigEncryptionSampleAesPtrOutput) Elem() JobTemplateConfigEncryptionSampleAesOutput

func (JobTemplateConfigEncryptionSampleAesPtrOutput) ElementType 

func (JobTemplateConfigEncryptionSampleAesPtrOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionSampleAesPtrOutput) ToJobTemplateConfigEncryptionSampleAesPtrOutput 

func (o JobTemplateConfigEncryptionSampleAesPtrOutput) ToJobTemplateConfigEncryptionSampleAesPtrOutput() JobTemplateConfigEncryptionSampleAesPtrOutput

func (JobTemplateConfigEncryptionSampleAesPtrOutput) ToJobTemplateConfigEncryptionSampleAesPtrOutputWithContext 

func (o JobTemplateConfigEncryptionSampleAesPtrOutput) ToJobTemplateConfigEncryptionSampleAesPtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionSampleAesPtrOutput

type JobTemplateConfigEncryptionSecretManagerKeySource 

type JobTemplateConfigEncryptionSecretManagerKeySource struct {
	// The name of the Secret Version containing the encryption key in the following format: projects/{project}/secrets/{secret_id}/versions/{version_number}.
	SecretVersion string `pulumi:"secretVersion"`
}

type JobTemplateConfigEncryptionSecretManagerKeySourceArgs 

type JobTemplateConfigEncryptionSecretManagerKeySourceArgs struct {
	// The name of the Secret Version containing the encryption key in the following format: projects/{project}/secrets/{secret_id}/versions/{version_number}.
	SecretVersion pulumi.StringInput `pulumi:"secretVersion"`
}

func (JobTemplateConfigEncryptionSecretManagerKeySourceArgs) ElementType 

func (JobTemplateConfigEncryptionSecretManagerKeySourceArgs) ElementType() reflect.Type

func (JobTemplateConfigEncryptionSecretManagerKeySourceArgs) ToJobTemplateConfigEncryptionSecretManagerKeySourceOutput 

func (i JobTemplateConfigEncryptionSecretManagerKeySourceArgs) ToJobTemplateConfigEncryptionSecretManagerKeySourceOutput() JobTemplateConfigEncryptionSecretManagerKeySourceOutput

func (JobTemplateConfigEncryptionSecretManagerKeySourceArgs) ToJobTemplateConfigEncryptionSecretManagerKeySourceOutputWithContext 

func (i JobTemplateConfigEncryptionSecretManagerKeySourceArgs) ToJobTemplateConfigEncryptionSecretManagerKeySourceOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionSecretManagerKeySourceOutput

func (JobTemplateConfigEncryptionSecretManagerKeySourceArgs) ToJobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput 

func (i JobTemplateConfigEncryptionSecretManagerKeySourceArgs) ToJobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput() JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput

func (JobTemplateConfigEncryptionSecretManagerKeySourceArgs) ToJobTemplateConfigEncryptionSecretManagerKeySourcePtrOutputWithContext 

func (i JobTemplateConfigEncryptionSecretManagerKeySourceArgs) ToJobTemplateConfigEncryptionSecretManagerKeySourcePtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput

type JobTemplateConfigEncryptionSecretManagerKeySourceInput 

type JobTemplateConfigEncryptionSecretManagerKeySourceInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionSecretManagerKeySourceOutput() JobTemplateConfigEncryptionSecretManagerKeySourceOutput
	ToJobTemplateConfigEncryptionSecretManagerKeySourceOutputWithContext(context.Context) JobTemplateConfigEncryptionSecretManagerKeySourceOutput
}

JobTemplateConfigEncryptionSecretManagerKeySourceInput is an input type that accepts JobTemplateConfigEncryptionSecretManagerKeySourceArgs and JobTemplateConfigEncryptionSecretManagerKeySourceOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionSecretManagerKeySourceInput` via: 

JobTemplateConfigEncryptionSecretManagerKeySourceArgs{...}

type JobTemplateConfigEncryptionSecretManagerKeySourceOutput 

type JobTemplateConfigEncryptionSecretManagerKeySourceOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionSecretManagerKeySourceOutput) ElementType 

func (JobTemplateConfigEncryptionSecretManagerKeySourceOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionSecretManagerKeySourceOutput) SecretVersion 

func (o JobTemplateConfigEncryptionSecretManagerKeySourceOutput) SecretVersion() pulumi.StringOutput

The name of the Secret Version containing the encryption key in the following format: projects/{project}/secrets/{secret_id}/versions/{version_number}.

func (JobTemplateConfigEncryptionSecretManagerKeySourceOutput) ToJobTemplateConfigEncryptionSecretManagerKeySourceOutput 

func (o JobTemplateConfigEncryptionSecretManagerKeySourceOutput) ToJobTemplateConfigEncryptionSecretManagerKeySourceOutput() JobTemplateConfigEncryptionSecretManagerKeySourceOutput

func (JobTemplateConfigEncryptionSecretManagerKeySourceOutput) ToJobTemplateConfigEncryptionSecretManagerKeySourceOutputWithContext 

func (o JobTemplateConfigEncryptionSecretManagerKeySourceOutput) ToJobTemplateConfigEncryptionSecretManagerKeySourceOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionSecretManagerKeySourceOutput

func (JobTemplateConfigEncryptionSecretManagerKeySourceOutput) ToJobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput 

func (o JobTemplateConfigEncryptionSecretManagerKeySourceOutput) ToJobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput() JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput

func (JobTemplateConfigEncryptionSecretManagerKeySourceOutput) ToJobTemplateConfigEncryptionSecretManagerKeySourcePtrOutputWithContext 

func (o JobTemplateConfigEncryptionSecretManagerKeySourceOutput) ToJobTemplateConfigEncryptionSecretManagerKeySourcePtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput

type JobTemplateConfigEncryptionSecretManagerKeySourcePtrInput 

type JobTemplateConfigEncryptionSecretManagerKeySourcePtrInput interface {
	pulumi.Input

	ToJobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput() JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput
	ToJobTemplateConfigEncryptionSecretManagerKeySourcePtrOutputWithContext(context.Context) JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput
}

JobTemplateConfigEncryptionSecretManagerKeySourcePtrInput is an input type that accepts JobTemplateConfigEncryptionSecretManagerKeySourceArgs, JobTemplateConfigEncryptionSecretManagerKeySourcePtr and JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput values. You can construct a concrete instance of `JobTemplateConfigEncryptionSecretManagerKeySourcePtrInput` via: 

        JobTemplateConfigEncryptionSecretManagerKeySourceArgs{...}

or:

        nil

func JobTemplateConfigEncryptionSecretManagerKeySourcePtr 

func JobTemplateConfigEncryptionSecretManagerKeySourcePtr(v *JobTemplateConfigEncryptionSecretManagerKeySourceArgs) JobTemplateConfigEncryptionSecretManagerKeySourcePtrInput

type JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput 

type JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput) Elem 

func (o JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput) Elem() JobTemplateConfigEncryptionSecretManagerKeySourceOutput

func (JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput) ElementType 

func (JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput) ElementType() reflect.Type

func (JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput) SecretVersion 

func (o JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput) SecretVersion() pulumi.StringPtrOutput

The name of the Secret Version containing the encryption key in the following format: projects/{project}/secrets/{secret_id}/versions/{version_number}.

func (JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput) ToJobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput 

func (o JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput) ToJobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput() JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput

func (JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput) ToJobTemplateConfigEncryptionSecretManagerKeySourcePtrOutputWithContext 

func (o JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput) ToJobTemplateConfigEncryptionSecretManagerKeySourcePtrOutputWithContext(ctx context.Context) JobTemplateConfigEncryptionSecretManagerKeySourcePtrOutput

type JobTemplateConfigInput 

type JobTemplateConfigInput interface {
	pulumi.Input

	ToJobTemplateConfigOutput() JobTemplateConfigOutput
	ToJobTemplateConfigOutputWithContext(context.Context) JobTemplateConfigOutput
}

JobTemplateConfigInput is an input type that accepts JobTemplateConfigArgs and JobTemplateConfigOutput values. You can construct a concrete instance of `JobTemplateConfigInput` via: 

JobTemplateConfigArgs{...}

type JobTemplateConfigInputType 

type JobTemplateConfigInputType struct {
	// A unique key for this input. Must be specified when using advanced mapping and edit lists.
	Key *string `pulumi:"key"`
	// URI of the media. Input files must be at least 5 seconds in duration and stored in Cloud Storage (for example, gs://bucket/inputs/file.mp4).
	// If empty, the value is populated from Job.input_uri.
	Uri *string `pulumi:"uri"`
}

type JobTemplateConfigInputTypeArgs 

type JobTemplateConfigInputTypeArgs struct {
	// A unique key for this input. Must be specified when using advanced mapping and edit lists.
	Key pulumi.StringPtrInput `pulumi:"key"`
	// URI of the media. Input files must be at least 5 seconds in duration and stored in Cloud Storage (for example, gs://bucket/inputs/file.mp4).
	// If empty, the value is populated from Job.input_uri.
	Uri pulumi.StringPtrInput `pulumi:"uri"`
}

func (JobTemplateConfigInputTypeArgs) ElementType 

func (JobTemplateConfigInputTypeArgs) ElementType() reflect.Type

func (JobTemplateConfigInputTypeArgs) ToJobTemplateConfigInputTypeOutput 

func (i JobTemplateConfigInputTypeArgs) ToJobTemplateConfigInputTypeOutput() JobTemplateConfigInputTypeOutput

func (JobTemplateConfigInputTypeArgs) ToJobTemplateConfigInputTypeOutputWithContext 

func (i JobTemplateConfigInputTypeArgs) ToJobTemplateConfigInputTypeOutputWithContext(ctx context.Context) JobTemplateConfigInputTypeOutput

type JobTemplateConfigInputTypeArray 

type JobTemplateConfigInputTypeArray []JobTemplateConfigInputTypeInput

func (JobTemplateConfigInputTypeArray) ElementType 

func (JobTemplateConfigInputTypeArray) ElementType() reflect.Type

func (JobTemplateConfigInputTypeArray) ToJobTemplateConfigInputTypeArrayOutput 

func (i JobTemplateConfigInputTypeArray) ToJobTemplateConfigInputTypeArrayOutput() JobTemplateConfigInputTypeArrayOutput

func (JobTemplateConfigInputTypeArray) ToJobTemplateConfigInputTypeArrayOutputWithContext 

func (i JobTemplateConfigInputTypeArray) ToJobTemplateConfigInputTypeArrayOutputWithContext(ctx context.Context) JobTemplateConfigInputTypeArrayOutput

type JobTemplateConfigInputTypeArrayInput 

type JobTemplateConfigInputTypeArrayInput interface {
	pulumi.Input

	ToJobTemplateConfigInputTypeArrayOutput() JobTemplateConfigInputTypeArrayOutput
	ToJobTemplateConfigInputTypeArrayOutputWithContext(context.Context) JobTemplateConfigInputTypeArrayOutput
}

JobTemplateConfigInputTypeArrayInput is an input type that accepts JobTemplateConfigInputTypeArray and JobTemplateConfigInputTypeArrayOutput values. You can construct a concrete instance of `JobTemplateConfigInputTypeArrayInput` via: 

JobTemplateConfigInputTypeArray{ JobTemplateConfigInputTypeArgs{...} }

type JobTemplateConfigInputTypeArrayOutput 

type JobTemplateConfigInputTypeArrayOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigInputTypeArrayOutput) ElementType 

func (JobTemplateConfigInputTypeArrayOutput) ElementType() reflect.Type

func (JobTemplateConfigInputTypeArrayOutput) Index 

func (o JobTemplateConfigInputTypeArrayOutput) Index(i pulumi.IntInput) JobTemplateConfigInputTypeOutput

func (JobTemplateConfigInputTypeArrayOutput) ToJobTemplateConfigInputTypeArrayOutput 

func (o JobTemplateConfigInputTypeArrayOutput) ToJobTemplateConfigInputTypeArrayOutput() JobTemplateConfigInputTypeArrayOutput

func (JobTemplateConfigInputTypeArrayOutput) ToJobTemplateConfigInputTypeArrayOutputWithContext 

func (o JobTemplateConfigInputTypeArrayOutput) ToJobTemplateConfigInputTypeArrayOutputWithContext(ctx context.Context) JobTemplateConfigInputTypeArrayOutput

type JobTemplateConfigInputTypeInput 

type JobTemplateConfigInputTypeInput interface {
	pulumi.Input

	ToJobTemplateConfigInputTypeOutput() JobTemplateConfigInputTypeOutput
	ToJobTemplateConfigInputTypeOutputWithContext(context.Context) JobTemplateConfigInputTypeOutput
}

JobTemplateConfigInputTypeInput is an input type that accepts JobTemplateConfigInputTypeArgs and JobTemplateConfigInputTypeOutput values. You can construct a concrete instance of `JobTemplateConfigInputTypeInput` via: 

JobTemplateConfigInputTypeArgs{...}

type JobTemplateConfigInputTypeOutput 

type JobTemplateConfigInputTypeOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigInputTypeOutput) ElementType 

func (JobTemplateConfigInputTypeOutput) ElementType() reflect.Type

func (JobTemplateConfigInputTypeOutput) Key 

func (o JobTemplateConfigInputTypeOutput) Key() pulumi.StringPtrOutput

A unique key for this input. Must be specified when using advanced mapping and edit lists.

func (JobTemplateConfigInputTypeOutput) ToJobTemplateConfigInputTypeOutput 

func (o JobTemplateConfigInputTypeOutput) ToJobTemplateConfigInputTypeOutput() JobTemplateConfigInputTypeOutput

func (JobTemplateConfigInputTypeOutput) ToJobTemplateConfigInputTypeOutputWithContext 

func (o JobTemplateConfigInputTypeOutput) ToJobTemplateConfigInputTypeOutputWithContext(ctx context.Context) JobTemplateConfigInputTypeOutput

func (JobTemplateConfigInputTypeOutput) Uri 

func (o JobTemplateConfigInputTypeOutput) Uri() pulumi.StringPtrOutput

URI of the media. Input files must be at least 5 seconds in duration and stored in Cloud Storage (for example, gs://bucket/inputs/file.mp4). If empty, the value is populated from Job.input_uri.

type JobTemplateConfigManifest 

type JobTemplateConfigManifest struct {
	// The name of the generated file. The default is `manifest`.
	FileName *string `pulumi:"fileName"`
	// List of user supplied MuxStream.key values that should appear in this manifest.
	MuxStreams []string `pulumi:"muxStreams"`
	// Type of the manifest.
	// Possible values are: `MANIFEST_TYPE_UNSPECIFIED`, `HLS`, `DASH`.
	Type *string `pulumi:"type"`
}

type JobTemplateConfigManifestArgs 

type JobTemplateConfigManifestArgs struct {
	// The name of the generated file. The default is `manifest`.
	FileName pulumi.StringPtrInput `pulumi:"fileName"`
	// List of user supplied MuxStream.key values that should appear in this manifest.
	MuxStreams pulumi.StringArrayInput `pulumi:"muxStreams"`
	// Type of the manifest.
	// Possible values are: `MANIFEST_TYPE_UNSPECIFIED`, `HLS`, `DASH`.
	Type pulumi.StringPtrInput `pulumi:"type"`
}

func (JobTemplateConfigManifestArgs) ElementType 

func (JobTemplateConfigManifestArgs) ElementType() reflect.Type

func (JobTemplateConfigManifestArgs) ToJobTemplateConfigManifestOutput 

func (i JobTemplateConfigManifestArgs) ToJobTemplateConfigManifestOutput() JobTemplateConfigManifestOutput

func (JobTemplateConfigManifestArgs) ToJobTemplateConfigManifestOutputWithContext 

func (i JobTemplateConfigManifestArgs) ToJobTemplateConfigManifestOutputWithContext(ctx context.Context) JobTemplateConfigManifestOutput

type JobTemplateConfigManifestArray 

type JobTemplateConfigManifestArray []JobTemplateConfigManifestInput

func (JobTemplateConfigManifestArray) ElementType 

func (JobTemplateConfigManifestArray) ElementType() reflect.Type

func (JobTemplateConfigManifestArray) ToJobTemplateConfigManifestArrayOutput 

func (i JobTemplateConfigManifestArray) ToJobTemplateConfigManifestArrayOutput() JobTemplateConfigManifestArrayOutput

func (JobTemplateConfigManifestArray) ToJobTemplateConfigManifestArrayOutputWithContext 

func (i JobTemplateConfigManifestArray) ToJobTemplateConfigManifestArrayOutputWithContext(ctx context.Context) JobTemplateConfigManifestArrayOutput

type JobTemplateConfigManifestArrayInput 

type JobTemplateConfigManifestArrayInput interface {
	pulumi.Input

	ToJobTemplateConfigManifestArrayOutput() JobTemplateConfigManifestArrayOutput
	ToJobTemplateConfigManifestArrayOutputWithContext(context.Context) JobTemplateConfigManifestArrayOutput
}

JobTemplateConfigManifestArrayInput is an input type that accepts JobTemplateConfigManifestArray and JobTemplateConfigManifestArrayOutput values. You can construct a concrete instance of `JobTemplateConfigManifestArrayInput` via: 

JobTemplateConfigManifestArray{ JobTemplateConfigManifestArgs{...} }

type JobTemplateConfigManifestArrayOutput 

type JobTemplateConfigManifestArrayOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigManifestArrayOutput) ElementType 

func (JobTemplateConfigManifestArrayOutput) ElementType() reflect.Type

func (JobTemplateConfigManifestArrayOutput) Index 

func (o JobTemplateConfigManifestArrayOutput) Index(i pulumi.IntInput) JobTemplateConfigManifestOutput

func (JobTemplateConfigManifestArrayOutput) ToJobTemplateConfigManifestArrayOutput 

func (o JobTemplateConfigManifestArrayOutput) ToJobTemplateConfigManifestArrayOutput() JobTemplateConfigManifestArrayOutput

func (JobTemplateConfigManifestArrayOutput) ToJobTemplateConfigManifestArrayOutputWithContext 

func (o JobTemplateConfigManifestArrayOutput) ToJobTemplateConfigManifestArrayOutputWithContext(ctx context.Context) JobTemplateConfigManifestArrayOutput

type JobTemplateConfigManifestInput 

type JobTemplateConfigManifestInput interface {
	pulumi.Input

	ToJobTemplateConfigManifestOutput() JobTemplateConfigManifestOutput
	ToJobTemplateConfigManifestOutputWithContext(context.Context) JobTemplateConfigManifestOutput
}

JobTemplateConfigManifestInput is an input type that accepts JobTemplateConfigManifestArgs and JobTemplateConfigManifestOutput values. You can construct a concrete instance of `JobTemplateConfigManifestInput` via: 

JobTemplateConfigManifestArgs{...}

type JobTemplateConfigManifestOutput 

type JobTemplateConfigManifestOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigManifestOutput) ElementType 

func (JobTemplateConfigManifestOutput) ElementType() reflect.Type

func (JobTemplateConfigManifestOutput) FileName 

func (o JobTemplateConfigManifestOutput) FileName() pulumi.StringPtrOutput

The name of the generated file. The default is `manifest`.

func (JobTemplateConfigManifestOutput) MuxStreams 

func (o JobTemplateConfigManifestOutput) MuxStreams() pulumi.StringArrayOutput

List of user supplied MuxStream.key values that should appear in this manifest.

func (JobTemplateConfigManifestOutput) ToJobTemplateConfigManifestOutput 

func (o JobTemplateConfigManifestOutput) ToJobTemplateConfigManifestOutput() JobTemplateConfigManifestOutput

func (JobTemplateConfigManifestOutput) ToJobTemplateConfigManifestOutputWithContext 

func (o JobTemplateConfigManifestOutput) ToJobTemplateConfigManifestOutputWithContext(ctx context.Context) JobTemplateConfigManifestOutput

func (JobTemplateConfigManifestOutput) Type 

func (o JobTemplateConfigManifestOutput) Type() pulumi.StringPtrOutput

Type of the manifest. Possible values are: `MANIFEST_TYPE_UNSPECIFIED`, `HLS`, `DASH`.

type JobTemplateConfigMuxStream 

type JobTemplateConfigMuxStream struct {
	// The container format. The default is `mp4`.
	Container *string `pulumi:"container"`
	// List of ElementaryStream.key values multiplexed in this stream.
	ElementaryStreams []string `pulumi:"elementaryStreams"`
	// Identifier of the encryption configuration to use.
	EncryptionId *string `pulumi:"encryptionId"`
	// The name of the generated file.
	FileName *string `pulumi:"fileName"`
	// A unique key for this multiplexed stream.
	Key *string `pulumi:"key"`
	// Segment settings for ts, fmp4 and vtt.
	// Structure is documented below.
	SegmentSettings *JobTemplateConfigMuxStreamSegmentSettings `pulumi:"segmentSettings"`
}

type JobTemplateConfigMuxStreamArgs 

type JobTemplateConfigMuxStreamArgs struct {
	// The container format. The default is `mp4`.
	Container pulumi.StringPtrInput `pulumi:"container"`
	// List of ElementaryStream.key values multiplexed in this stream.
	ElementaryStreams pulumi.StringArrayInput `pulumi:"elementaryStreams"`
	// Identifier of the encryption configuration to use.
	EncryptionId pulumi.StringPtrInput `pulumi:"encryptionId"`
	// The name of the generated file.
	FileName pulumi.StringPtrInput `pulumi:"fileName"`
	// A unique key for this multiplexed stream.
	Key pulumi.StringPtrInput `pulumi:"key"`
	// Segment settings for ts, fmp4 and vtt.
	// Structure is documented below.
	SegmentSettings JobTemplateConfigMuxStreamSegmentSettingsPtrInput `pulumi:"segmentSettings"`
}

func (JobTemplateConfigMuxStreamArgs) ElementType 

func (JobTemplateConfigMuxStreamArgs) ElementType() reflect.Type

func (JobTemplateConfigMuxStreamArgs) ToJobTemplateConfigMuxStreamOutput 

func (i JobTemplateConfigMuxStreamArgs) ToJobTemplateConfigMuxStreamOutput() JobTemplateConfigMuxStreamOutput

func (JobTemplateConfigMuxStreamArgs) ToJobTemplateConfigMuxStreamOutputWithContext 

func (i JobTemplateConfigMuxStreamArgs) ToJobTemplateConfigMuxStreamOutputWithContext(ctx context.Context) JobTemplateConfigMuxStreamOutput

type JobTemplateConfigMuxStreamArray 

type JobTemplateConfigMuxStreamArray []JobTemplateConfigMuxStreamInput

func (JobTemplateConfigMuxStreamArray) ElementType 

func (JobTemplateConfigMuxStreamArray) ElementType() reflect.Type

func (JobTemplateConfigMuxStreamArray) ToJobTemplateConfigMuxStreamArrayOutput 

func (i JobTemplateConfigMuxStreamArray) ToJobTemplateConfigMuxStreamArrayOutput() JobTemplateConfigMuxStreamArrayOutput

func (JobTemplateConfigMuxStreamArray) ToJobTemplateConfigMuxStreamArrayOutputWithContext 

func (i JobTemplateConfigMuxStreamArray) ToJobTemplateConfigMuxStreamArrayOutputWithContext(ctx context.Context) JobTemplateConfigMuxStreamArrayOutput

type JobTemplateConfigMuxStreamArrayInput 

type JobTemplateConfigMuxStreamArrayInput interface {
	pulumi.Input

	ToJobTemplateConfigMuxStreamArrayOutput() JobTemplateConfigMuxStreamArrayOutput
	ToJobTemplateConfigMuxStreamArrayOutputWithContext(context.Context) JobTemplateConfigMuxStreamArrayOutput
}

JobTemplateConfigMuxStreamArrayInput is an input type that accepts JobTemplateConfigMuxStreamArray and JobTemplateConfigMuxStreamArrayOutput values. You can construct a concrete instance of `JobTemplateConfigMuxStreamArrayInput` via: 

JobTemplateConfigMuxStreamArray{ JobTemplateConfigMuxStreamArgs{...} }

type JobTemplateConfigMuxStreamArrayOutput 

type JobTemplateConfigMuxStreamArrayOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigMuxStreamArrayOutput) ElementType 

func (JobTemplateConfigMuxStreamArrayOutput) ElementType() reflect.Type

func (JobTemplateConfigMuxStreamArrayOutput) Index 

func (o JobTemplateConfigMuxStreamArrayOutput) Index(i pulumi.IntInput) JobTemplateConfigMuxStreamOutput

func (JobTemplateConfigMuxStreamArrayOutput) ToJobTemplateConfigMuxStreamArrayOutput 

func (o JobTemplateConfigMuxStreamArrayOutput) ToJobTemplateConfigMuxStreamArrayOutput() JobTemplateConfigMuxStreamArrayOutput

func (JobTemplateConfigMuxStreamArrayOutput) ToJobTemplateConfigMuxStreamArrayOutputWithContext 

func (o JobTemplateConfigMuxStreamArrayOutput) ToJobTemplateConfigMuxStreamArrayOutputWithContext(ctx context.Context) JobTemplateConfigMuxStreamArrayOutput

type JobTemplateConfigMuxStreamInput 

type JobTemplateConfigMuxStreamInput interface {
	pulumi.Input

	ToJobTemplateConfigMuxStreamOutput() JobTemplateConfigMuxStreamOutput
	ToJobTemplateConfigMuxStreamOutputWithContext(context.Context) JobTemplateConfigMuxStreamOutput
}

JobTemplateConfigMuxStreamInput is an input type that accepts JobTemplateConfigMuxStreamArgs and JobTemplateConfigMuxStreamOutput values. You can construct a concrete instance of `JobTemplateConfigMuxStreamInput` via: 

JobTemplateConfigMuxStreamArgs{...}

type JobTemplateConfigMuxStreamOutput 

type JobTemplateConfigMuxStreamOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigMuxStreamOutput) Container 

func (o JobTemplateConfigMuxStreamOutput) Container() pulumi.StringPtrOutput

The container format. The default is `mp4`.

func (JobTemplateConfigMuxStreamOutput) ElementType 

func (JobTemplateConfigMuxStreamOutput) ElementType() reflect.Type

func (JobTemplateConfigMuxStreamOutput) ElementaryStreams 

func (o JobTemplateConfigMuxStreamOutput) ElementaryStreams() pulumi.StringArrayOutput

List of ElementaryStream.key values multiplexed in this stream.

func (JobTemplateConfigMuxStreamOutput) EncryptionId 

func (o JobTemplateConfigMuxStreamOutput) EncryptionId() pulumi.StringPtrOutput

Identifier of the encryption configuration to use.

func (JobTemplateConfigMuxStreamOutput) FileName 

func (o JobTemplateConfigMuxStreamOutput) FileName() pulumi.StringPtrOutput

The name of the generated file.

func (JobTemplateConfigMuxStreamOutput) Key 

func (o JobTemplateConfigMuxStreamOutput) Key() pulumi.StringPtrOutput

A unique key for this multiplexed stream.

func (JobTemplateConfigMuxStreamOutput) SegmentSettings 

func (o JobTemplateConfigMuxStreamOutput) SegmentSettings() JobTemplateConfigMuxStreamSegmentSettingsPtrOutput

Segment settings for ts, fmp4 and vtt. Structure is documented below.

func (JobTemplateConfigMuxStreamOutput) ToJobTemplateConfigMuxStreamOutput 

func (o JobTemplateConfigMuxStreamOutput) ToJobTemplateConfigMuxStreamOutput() JobTemplateConfigMuxStreamOutput

func (JobTemplateConfigMuxStreamOutput) ToJobTemplateConfigMuxStreamOutputWithContext 

func (o JobTemplateConfigMuxStreamOutput) ToJobTemplateConfigMuxStreamOutputWithContext(ctx context.Context) JobTemplateConfigMuxStreamOutput

type JobTemplateConfigMuxStreamSegmentSettings 

type JobTemplateConfigMuxStreamSegmentSettings struct {
	// Duration of the segments in seconds. The default is `6.0s`.
	SegmentDuration *string `pulumi:"segmentDuration"`
}

type JobTemplateConfigMuxStreamSegmentSettingsArgs 

type JobTemplateConfigMuxStreamSegmentSettingsArgs struct {
	// Duration of the segments in seconds. The default is `6.0s`.
	SegmentDuration pulumi.StringPtrInput `pulumi:"segmentDuration"`
}

func (JobTemplateConfigMuxStreamSegmentSettingsArgs) ElementType 

func (JobTemplateConfigMuxStreamSegmentSettingsArgs) ElementType() reflect.Type

func (JobTemplateConfigMuxStreamSegmentSettingsArgs) ToJobTemplateConfigMuxStreamSegmentSettingsOutput 

func (i JobTemplateConfigMuxStreamSegmentSettingsArgs) ToJobTemplateConfigMuxStreamSegmentSettingsOutput() JobTemplateConfigMuxStreamSegmentSettingsOutput

func (JobTemplateConfigMuxStreamSegmentSettingsArgs) ToJobTemplateConfigMuxStreamSegmentSettingsOutputWithContext 

func (i JobTemplateConfigMuxStreamSegmentSettingsArgs) ToJobTemplateConfigMuxStreamSegmentSettingsOutputWithContext(ctx context.Context) JobTemplateConfigMuxStreamSegmentSettingsOutput

func (JobTemplateConfigMuxStreamSegmentSettingsArgs) ToJobTemplateConfigMuxStreamSegmentSettingsPtrOutput 

func (i JobTemplateConfigMuxStreamSegmentSettingsArgs) ToJobTemplateConfigMuxStreamSegmentSettingsPtrOutput() JobTemplateConfigMuxStreamSegmentSettingsPtrOutput

func (JobTemplateConfigMuxStreamSegmentSettingsArgs) ToJobTemplateConfigMuxStreamSegmentSettingsPtrOutputWithContext 

func (i JobTemplateConfigMuxStreamSegmentSettingsArgs) ToJobTemplateConfigMuxStreamSegmentSettingsPtrOutputWithContext(ctx context.Context) JobTemplateConfigMuxStreamSegmentSettingsPtrOutput

type JobTemplateConfigMuxStreamSegmentSettingsInput 

type JobTemplateConfigMuxStreamSegmentSettingsInput interface {
	pulumi.Input

	ToJobTemplateConfigMuxStreamSegmentSettingsOutput() JobTemplateConfigMuxStreamSegmentSettingsOutput
	ToJobTemplateConfigMuxStreamSegmentSettingsOutputWithContext(context.Context) JobTemplateConfigMuxStreamSegmentSettingsOutput
}

JobTemplateConfigMuxStreamSegmentSettingsInput is an input type that accepts JobTemplateConfigMuxStreamSegmentSettingsArgs and JobTemplateConfigMuxStreamSegmentSettingsOutput values. You can construct a concrete instance of `JobTemplateConfigMuxStreamSegmentSettingsInput` via: 

JobTemplateConfigMuxStreamSegmentSettingsArgs{...}

type JobTemplateConfigMuxStreamSegmentSettingsOutput 

type JobTemplateConfigMuxStreamSegmentSettingsOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigMuxStreamSegmentSettingsOutput) ElementType 

func (JobTemplateConfigMuxStreamSegmentSettingsOutput) ElementType() reflect.Type

func (JobTemplateConfigMuxStreamSegmentSettingsOutput) SegmentDuration 

func (o JobTemplateConfigMuxStreamSegmentSettingsOutput) SegmentDuration() pulumi.StringPtrOutput

Duration of the segments in seconds. The default is `6.0s`.

func (JobTemplateConfigMuxStreamSegmentSettingsOutput) ToJobTemplateConfigMuxStreamSegmentSettingsOutput 

func (o JobTemplateConfigMuxStreamSegmentSettingsOutput) ToJobTemplateConfigMuxStreamSegmentSettingsOutput() JobTemplateConfigMuxStreamSegmentSettingsOutput

func (JobTemplateConfigMuxStreamSegmentSettingsOutput) ToJobTemplateConfigMuxStreamSegmentSettingsOutputWithContext 

func (o JobTemplateConfigMuxStreamSegmentSettingsOutput) ToJobTemplateConfigMuxStreamSegmentSettingsOutputWithContext(ctx context.Context) JobTemplateConfigMuxStreamSegmentSettingsOutput

func (JobTemplateConfigMuxStreamSegmentSettingsOutput) ToJobTemplateConfigMuxStreamSegmentSettingsPtrOutput 

func (o JobTemplateConfigMuxStreamSegmentSettingsOutput) ToJobTemplateConfigMuxStreamSegmentSettingsPtrOutput() JobTemplateConfigMuxStreamSegmentSettingsPtrOutput

func (JobTemplateConfigMuxStreamSegmentSettingsOutput) ToJobTemplateConfigMuxStreamSegmentSettingsPtrOutputWithContext 

func (o JobTemplateConfigMuxStreamSegmentSettingsOutput) ToJobTemplateConfigMuxStreamSegmentSettingsPtrOutputWithContext(ctx context.Context) JobTemplateConfigMuxStreamSegmentSettingsPtrOutput

type JobTemplateConfigMuxStreamSegmentSettingsPtrInput 

type JobTemplateConfigMuxStreamSegmentSettingsPtrInput interface {
	pulumi.Input

	ToJobTemplateConfigMuxStreamSegmentSettingsPtrOutput() JobTemplateConfigMuxStreamSegmentSettingsPtrOutput
	ToJobTemplateConfigMuxStreamSegmentSettingsPtrOutputWithContext(context.Context) JobTemplateConfigMuxStreamSegmentSettingsPtrOutput
}

JobTemplateConfigMuxStreamSegmentSettingsPtrInput is an input type that accepts JobTemplateConfigMuxStreamSegmentSettingsArgs, JobTemplateConfigMuxStreamSegmentSettingsPtr and JobTemplateConfigMuxStreamSegmentSettingsPtrOutput values. You can construct a concrete instance of `JobTemplateConfigMuxStreamSegmentSettingsPtrInput` via: 

        JobTemplateConfigMuxStreamSegmentSettingsArgs{...}

or:

        nil

func JobTemplateConfigMuxStreamSegmentSettingsPtr 

func JobTemplateConfigMuxStreamSegmentSettingsPtr(v *JobTemplateConfigMuxStreamSegmentSettingsArgs) JobTemplateConfigMuxStreamSegmentSettingsPtrInput

type JobTemplateConfigMuxStreamSegmentSettingsPtrOutput 

type JobTemplateConfigMuxStreamSegmentSettingsPtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigMuxStreamSegmentSettingsPtrOutput) Elem 

func (o JobTemplateConfigMuxStreamSegmentSettingsPtrOutput) Elem() JobTemplateConfigMuxStreamSegmentSettingsOutput

func (JobTemplateConfigMuxStreamSegmentSettingsPtrOutput) ElementType 

func (JobTemplateConfigMuxStreamSegmentSettingsPtrOutput) ElementType() reflect.Type

func (JobTemplateConfigMuxStreamSegmentSettingsPtrOutput) SegmentDuration 

func (o JobTemplateConfigMuxStreamSegmentSettingsPtrOutput) SegmentDuration() pulumi.StringPtrOutput

Duration of the segments in seconds. The default is `6.0s`.

func (JobTemplateConfigMuxStreamSegmentSettingsPtrOutput) ToJobTemplateConfigMuxStreamSegmentSettingsPtrOutput 

func (o JobTemplateConfigMuxStreamSegmentSettingsPtrOutput) ToJobTemplateConfigMuxStreamSegmentSettingsPtrOutput() JobTemplateConfigMuxStreamSegmentSettingsPtrOutput

func (JobTemplateConfigMuxStreamSegmentSettingsPtrOutput) ToJobTemplateConfigMuxStreamSegmentSettingsPtrOutputWithContext 

func (o JobTemplateConfigMuxStreamSegmentSettingsPtrOutput) ToJobTemplateConfigMuxStreamSegmentSettingsPtrOutputWithContext(ctx context.Context) JobTemplateConfigMuxStreamSegmentSettingsPtrOutput

type JobTemplateConfigOutput 

type JobTemplateConfigOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigOutput) AdBreaks 

func (o JobTemplateConfigOutput) AdBreaks() JobTemplateConfigAdBreakArrayOutput

Ad break. Structure is documented below.

func (JobTemplateConfigOutput) EditLists 

func (o JobTemplateConfigOutput) EditLists() JobTemplateConfigEditListArrayOutput

List of input assets stored in Cloud Storage. Structure is documented below.

func (JobTemplateConfigOutput) ElementType 

func (JobTemplateConfigOutput) ElementType() reflect.Type

func (JobTemplateConfigOutput) ElementaryStreams 

func (o JobTemplateConfigOutput) ElementaryStreams() JobTemplateConfigElementaryStreamArrayOutput

List of input assets stored in Cloud Storage. Structure is documented below.

func (JobTemplateConfigOutput) Encryptions 

func (o JobTemplateConfigOutput) Encryptions() JobTemplateConfigEncryptionArrayOutput

List of encryption configurations for the content. Structure is documented below.

func (JobTemplateConfigOutput) Inputs 

func (o JobTemplateConfigOutput) Inputs() JobTemplateConfigInputTypeArrayOutput

List of input assets stored in Cloud Storage. Structure is documented below.

func (JobTemplateConfigOutput) Manifests 

func (o JobTemplateConfigOutput) Manifests() JobTemplateConfigManifestArrayOutput

Manifest configuration. Structure is documented below.

func (JobTemplateConfigOutput) MuxStreams 

func (o JobTemplateConfigOutput) MuxStreams() JobTemplateConfigMuxStreamArrayOutput

Multiplexing settings for output stream. Structure is documented below.

func (JobTemplateConfigOutput) Output 

func (o JobTemplateConfigOutput) Output() JobTemplateConfigOutputTypePtrOutput

Location of output file(s) in a Cloud Storage bucket. Structure is documented below.

func (JobTemplateConfigOutput) Overlays 

func (o JobTemplateConfigOutput) Overlays() JobTemplateConfigOverlayArrayOutput

List of overlays on the output video, in descending Z-order. Structure is documented below.

func (JobTemplateConfigOutput) PubsubDestination 

func (o JobTemplateConfigOutput) PubsubDestination() JobTemplateConfigPubsubDestinationPtrOutput

Pub/Sub destination. Structure is documented below.

func (JobTemplateConfigOutput) ToJobTemplateConfigOutput 

func (o JobTemplateConfigOutput) ToJobTemplateConfigOutput() JobTemplateConfigOutput

func (JobTemplateConfigOutput) ToJobTemplateConfigOutputWithContext 

func (o JobTemplateConfigOutput) ToJobTemplateConfigOutputWithContext(ctx context.Context) JobTemplateConfigOutput

func (JobTemplateConfigOutput) ToJobTemplateConfigPtrOutput 

func (o JobTemplateConfigOutput) ToJobTemplateConfigPtrOutput() JobTemplateConfigPtrOutput

func (JobTemplateConfigOutput) ToJobTemplateConfigPtrOutputWithContext 

func (o JobTemplateConfigOutput) ToJobTemplateConfigPtrOutputWithContext(ctx context.Context) JobTemplateConfigPtrOutput

type JobTemplateConfigOutputType 

type JobTemplateConfigOutputType struct {
	// URI for the output file(s). For example, gs://my-bucket/outputs/.
	Uri *string `pulumi:"uri"`
}

type JobTemplateConfigOutputTypeArgs 

type JobTemplateConfigOutputTypeArgs struct {
	// URI for the output file(s). For example, gs://my-bucket/outputs/.
	Uri pulumi.StringPtrInput `pulumi:"uri"`
}

func (JobTemplateConfigOutputTypeArgs) ElementType 

func (JobTemplateConfigOutputTypeArgs) ElementType() reflect.Type

func (JobTemplateConfigOutputTypeArgs) ToJobTemplateConfigOutputTypeOutput 

func (i JobTemplateConfigOutputTypeArgs) ToJobTemplateConfigOutputTypeOutput() JobTemplateConfigOutputTypeOutput

func (JobTemplateConfigOutputTypeArgs) ToJobTemplateConfigOutputTypeOutputWithContext 

func (i JobTemplateConfigOutputTypeArgs) ToJobTemplateConfigOutputTypeOutputWithContext(ctx context.Context) JobTemplateConfigOutputTypeOutput

func (JobTemplateConfigOutputTypeArgs) ToJobTemplateConfigOutputTypePtrOutput 

func (i JobTemplateConfigOutputTypeArgs) ToJobTemplateConfigOutputTypePtrOutput() JobTemplateConfigOutputTypePtrOutput

func (JobTemplateConfigOutputTypeArgs) ToJobTemplateConfigOutputTypePtrOutputWithContext 

func (i JobTemplateConfigOutputTypeArgs) ToJobTemplateConfigOutputTypePtrOutputWithContext(ctx context.Context) JobTemplateConfigOutputTypePtrOutput

type JobTemplateConfigOutputTypeInput 

type JobTemplateConfigOutputTypeInput interface {
	pulumi.Input

	ToJobTemplateConfigOutputTypeOutput() JobTemplateConfigOutputTypeOutput
	ToJobTemplateConfigOutputTypeOutputWithContext(context.Context) JobTemplateConfigOutputTypeOutput
}

JobTemplateConfigOutputTypeInput is an input type that accepts JobTemplateConfigOutputTypeArgs and JobTemplateConfigOutputTypeOutput values. You can construct a concrete instance of `JobTemplateConfigOutputTypeInput` via: 

JobTemplateConfigOutputTypeArgs{...}

type JobTemplateConfigOutputTypeOutput 

type JobTemplateConfigOutputTypeOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigOutputTypeOutput) ElementType 

func (JobTemplateConfigOutputTypeOutput) ElementType() reflect.Type

func (JobTemplateConfigOutputTypeOutput) ToJobTemplateConfigOutputTypeOutput 

func (o JobTemplateConfigOutputTypeOutput) ToJobTemplateConfigOutputTypeOutput() JobTemplateConfigOutputTypeOutput

func (JobTemplateConfigOutputTypeOutput) ToJobTemplateConfigOutputTypeOutputWithContext 

func (o JobTemplateConfigOutputTypeOutput) ToJobTemplateConfigOutputTypeOutputWithContext(ctx context.Context) JobTemplateConfigOutputTypeOutput

func (JobTemplateConfigOutputTypeOutput) ToJobTemplateConfigOutputTypePtrOutput 

func (o JobTemplateConfigOutputTypeOutput) ToJobTemplateConfigOutputTypePtrOutput() JobTemplateConfigOutputTypePtrOutput

func (JobTemplateConfigOutputTypeOutput) ToJobTemplateConfigOutputTypePtrOutputWithContext 

func (o JobTemplateConfigOutputTypeOutput) ToJobTemplateConfigOutputTypePtrOutputWithContext(ctx context.Context) JobTemplateConfigOutputTypePtrOutput

func (JobTemplateConfigOutputTypeOutput) Uri 

func (o JobTemplateConfigOutputTypeOutput) Uri() pulumi.StringPtrOutput

URI for the output file(s). For example, gs://my-bucket/outputs/.

type JobTemplateConfigOutputTypePtrInput 

type JobTemplateConfigOutputTypePtrInput interface {
	pulumi.Input

	ToJobTemplateConfigOutputTypePtrOutput() JobTemplateConfigOutputTypePtrOutput
	ToJobTemplateConfigOutputTypePtrOutputWithContext(context.Context) JobTemplateConfigOutputTypePtrOutput
}

JobTemplateConfigOutputTypePtrInput is an input type that accepts JobTemplateConfigOutputTypeArgs, JobTemplateConfigOutputTypePtr and JobTemplateConfigOutputTypePtrOutput values. You can construct a concrete instance of `JobTemplateConfigOutputTypePtrInput` via: 

        JobTemplateConfigOutputTypeArgs{...}

or:

        nil

func JobTemplateConfigOutputTypePtr 

func JobTemplateConfigOutputTypePtr(v *JobTemplateConfigOutputTypeArgs) JobTemplateConfigOutputTypePtrInput

type JobTemplateConfigOutputTypePtrOutput 

type JobTemplateConfigOutputTypePtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigOutputTypePtrOutput) Elem 

func (o JobTemplateConfigOutputTypePtrOutput) Elem() JobTemplateConfigOutputTypeOutput

func (JobTemplateConfigOutputTypePtrOutput) ElementType 

func (JobTemplateConfigOutputTypePtrOutput) ElementType() reflect.Type

func (JobTemplateConfigOutputTypePtrOutput) ToJobTemplateConfigOutputTypePtrOutput 

func (o JobTemplateConfigOutputTypePtrOutput) ToJobTemplateConfigOutputTypePtrOutput() JobTemplateConfigOutputTypePtrOutput

func (JobTemplateConfigOutputTypePtrOutput) ToJobTemplateConfigOutputTypePtrOutputWithContext 

func (o JobTemplateConfigOutputTypePtrOutput) ToJobTemplateConfigOutputTypePtrOutputWithContext(ctx context.Context) JobTemplateConfigOutputTypePtrOutput

func (JobTemplateConfigOutputTypePtrOutput) Uri 

func (o JobTemplateConfigOutputTypePtrOutput) Uri() pulumi.StringPtrOutput

URI for the output file(s). For example, gs://my-bucket/outputs/.

type JobTemplateConfigOverlay 

type JobTemplateConfigOverlay struct {
	// List of animations. The list should be chronological, without any time overlap.
	// Structure is documented below.
	Animations []JobTemplateConfigOverlayAnimation `pulumi:"animations"`
	// Image overlay.
	// Structure is documented below.
	Image *JobTemplateConfigOverlayImage `pulumi:"image"`
}

type JobTemplateConfigOverlayAnimation 

type JobTemplateConfigOverlayAnimation struct {
	// Display overlay object with fade animation.
	// Structure is documented below.
	AnimationFade *JobTemplateConfigOverlayAnimationAnimationFade `pulumi:"animationFade"`
}

type JobTemplateConfigOverlayAnimationAnimationFade 

type JobTemplateConfigOverlayAnimationAnimationFade struct {
	// The time to end the fade animation, in seconds.
	EndTimeOffset *string `pulumi:"endTimeOffset"`
	// Required. Type of fade animation: `FADE_IN` or `FADE_OUT`.
	// The possible values are:
	// * `FADE_TYPE_UNSPECIFIED`: The fade type is not specified.
	// * `FADE_IN`: Fade the overlay object into view.
	// * `FADE_OUT`: Fade the overlay object out of view.
	//   Possible values are: `FADE_TYPE_UNSPECIFIED`, `FADE_IN`, `FADE_OUT`.
	FadeType string `pulumi:"fadeType"`
	// The time to start the fade animation, in seconds.
	StartTimeOffset *string `pulumi:"startTimeOffset"`
	// Normalized coordinates based on output video resolution.
	// Structure is documented below.
	Xy *JobTemplateConfigOverlayAnimationAnimationFadeXy `pulumi:"xy"`
}

type JobTemplateConfigOverlayAnimationAnimationFadeArgs 

type JobTemplateConfigOverlayAnimationAnimationFadeArgs struct {
	// The time to end the fade animation, in seconds.
	EndTimeOffset pulumi.StringPtrInput `pulumi:"endTimeOffset"`
	// Required. Type of fade animation: `FADE_IN` or `FADE_OUT`.
	// The possible values are:
	// * `FADE_TYPE_UNSPECIFIED`: The fade type is not specified.
	// * `FADE_IN`: Fade the overlay object into view.
	// * `FADE_OUT`: Fade the overlay object out of view.
	//   Possible values are: `FADE_TYPE_UNSPECIFIED`, `FADE_IN`, `FADE_OUT`.
	FadeType pulumi.StringInput `pulumi:"fadeType"`
	// The time to start the fade animation, in seconds.
	StartTimeOffset pulumi.StringPtrInput `pulumi:"startTimeOffset"`
	// Normalized coordinates based on output video resolution.
	// Structure is documented below.
	Xy JobTemplateConfigOverlayAnimationAnimationFadeXyPtrInput `pulumi:"xy"`
}

func (JobTemplateConfigOverlayAnimationAnimationFadeArgs) ElementType 

func (JobTemplateConfigOverlayAnimationAnimationFadeArgs) ElementType() reflect.Type

func (JobTemplateConfigOverlayAnimationAnimationFadeArgs) ToJobTemplateConfigOverlayAnimationAnimationFadeOutput 

func (i JobTemplateConfigOverlayAnimationAnimationFadeArgs) ToJobTemplateConfigOverlayAnimationAnimationFadeOutput() JobTemplateConfigOverlayAnimationAnimationFadeOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeArgs) ToJobTemplateConfigOverlayAnimationAnimationFadeOutputWithContext 

func (i JobTemplateConfigOverlayAnimationAnimationFadeArgs) ToJobTemplateConfigOverlayAnimationAnimationFadeOutputWithContext(ctx context.Context) JobTemplateConfigOverlayAnimationAnimationFadeOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeArgs) ToJobTemplateConfigOverlayAnimationAnimationFadePtrOutput 

func (i JobTemplateConfigOverlayAnimationAnimationFadeArgs) ToJobTemplateConfigOverlayAnimationAnimationFadePtrOutput() JobTemplateConfigOverlayAnimationAnimationFadePtrOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeArgs) ToJobTemplateConfigOverlayAnimationAnimationFadePtrOutputWithContext 

func (i JobTemplateConfigOverlayAnimationAnimationFadeArgs) ToJobTemplateConfigOverlayAnimationAnimationFadePtrOutputWithContext(ctx context.Context) JobTemplateConfigOverlayAnimationAnimationFadePtrOutput

type JobTemplateConfigOverlayAnimationAnimationFadeInput 

type JobTemplateConfigOverlayAnimationAnimationFadeInput interface {
	pulumi.Input

	ToJobTemplateConfigOverlayAnimationAnimationFadeOutput() JobTemplateConfigOverlayAnimationAnimationFadeOutput
	ToJobTemplateConfigOverlayAnimationAnimationFadeOutputWithContext(context.Context) JobTemplateConfigOverlayAnimationAnimationFadeOutput
}

JobTemplateConfigOverlayAnimationAnimationFadeInput is an input type that accepts JobTemplateConfigOverlayAnimationAnimationFadeArgs and JobTemplateConfigOverlayAnimationAnimationFadeOutput values. You can construct a concrete instance of `JobTemplateConfigOverlayAnimationAnimationFadeInput` via: 

JobTemplateConfigOverlayAnimationAnimationFadeArgs{...}

type JobTemplateConfigOverlayAnimationAnimationFadeOutput 

type JobTemplateConfigOverlayAnimationAnimationFadeOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigOverlayAnimationAnimationFadeOutput) ElementType 

func (JobTemplateConfigOverlayAnimationAnimationFadeOutput) ElementType() reflect.Type

func (JobTemplateConfigOverlayAnimationAnimationFadeOutput) EndTimeOffset 

func (o JobTemplateConfigOverlayAnimationAnimationFadeOutput) EndTimeOffset() pulumi.StringPtrOutput

The time to end the fade animation, in seconds.

func (JobTemplateConfigOverlayAnimationAnimationFadeOutput) FadeType 

func (o JobTemplateConfigOverlayAnimationAnimationFadeOutput) FadeType() pulumi.StringOutput

Required. Type of fade animation: `FADE_IN` or `FADE_OUT`. The possible values are:

  • `FADE_TYPE_UNSPECIFIED`: The fade type is not specified.
  • `FADE_IN`: Fade the overlay object into view.
  • `FADE_OUT`: Fade the overlay object out of view. Possible values are: `FADE_TYPE_UNSPECIFIED`, `FADE_IN`, `FADE_OUT`.

func (JobTemplateConfigOverlayAnimationAnimationFadeOutput) StartTimeOffset 

func (o JobTemplateConfigOverlayAnimationAnimationFadeOutput) StartTimeOffset() pulumi.StringPtrOutput

The time to start the fade animation, in seconds.

func (JobTemplateConfigOverlayAnimationAnimationFadeOutput) ToJobTemplateConfigOverlayAnimationAnimationFadeOutput 

func (o JobTemplateConfigOverlayAnimationAnimationFadeOutput) ToJobTemplateConfigOverlayAnimationAnimationFadeOutput() JobTemplateConfigOverlayAnimationAnimationFadeOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeOutput) ToJobTemplateConfigOverlayAnimationAnimationFadeOutputWithContext 

func (o JobTemplateConfigOverlayAnimationAnimationFadeOutput) ToJobTemplateConfigOverlayAnimationAnimationFadeOutputWithContext(ctx context.Context) JobTemplateConfigOverlayAnimationAnimationFadeOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeOutput) ToJobTemplateConfigOverlayAnimationAnimationFadePtrOutput 

func (o JobTemplateConfigOverlayAnimationAnimationFadeOutput) ToJobTemplateConfigOverlayAnimationAnimationFadePtrOutput() JobTemplateConfigOverlayAnimationAnimationFadePtrOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeOutput) ToJobTemplateConfigOverlayAnimationAnimationFadePtrOutputWithContext 

func (o JobTemplateConfigOverlayAnimationAnimationFadeOutput) ToJobTemplateConfigOverlayAnimationAnimationFadePtrOutputWithContext(ctx context.Context) JobTemplateConfigOverlayAnimationAnimationFadePtrOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeOutput) Xy 

func (o JobTemplateConfigOverlayAnimationAnimationFadeOutput) Xy() JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput

Normalized coordinates based on output video resolution. Structure is documented below.

type JobTemplateConfigOverlayAnimationAnimationFadePtrInput 

type JobTemplateConfigOverlayAnimationAnimationFadePtrInput interface {
	pulumi.Input

	ToJobTemplateConfigOverlayAnimationAnimationFadePtrOutput() JobTemplateConfigOverlayAnimationAnimationFadePtrOutput
	ToJobTemplateConfigOverlayAnimationAnimationFadePtrOutputWithContext(context.Context) JobTemplateConfigOverlayAnimationAnimationFadePtrOutput
}

JobTemplateConfigOverlayAnimationAnimationFadePtrInput is an input type that accepts JobTemplateConfigOverlayAnimationAnimationFadeArgs, JobTemplateConfigOverlayAnimationAnimationFadePtr and JobTemplateConfigOverlayAnimationAnimationFadePtrOutput values. You can construct a concrete instance of `JobTemplateConfigOverlayAnimationAnimationFadePtrInput` via: 

        JobTemplateConfigOverlayAnimationAnimationFadeArgs{...}

or:

        nil

func JobTemplateConfigOverlayAnimationAnimationFadePtr 

func JobTemplateConfigOverlayAnimationAnimationFadePtr(v *JobTemplateConfigOverlayAnimationAnimationFadeArgs) JobTemplateConfigOverlayAnimationAnimationFadePtrInput

type JobTemplateConfigOverlayAnimationAnimationFadePtrOutput 

type JobTemplateConfigOverlayAnimationAnimationFadePtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigOverlayAnimationAnimationFadePtrOutput) Elem 

func (o JobTemplateConfigOverlayAnimationAnimationFadePtrOutput) Elem() JobTemplateConfigOverlayAnimationAnimationFadeOutput

func (JobTemplateConfigOverlayAnimationAnimationFadePtrOutput) ElementType 

func (JobTemplateConfigOverlayAnimationAnimationFadePtrOutput) ElementType() reflect.Type

func (JobTemplateConfigOverlayAnimationAnimationFadePtrOutput) EndTimeOffset 

func (o JobTemplateConfigOverlayAnimationAnimationFadePtrOutput) EndTimeOffset() pulumi.StringPtrOutput

The time to end the fade animation, in seconds.

func (JobTemplateConfigOverlayAnimationAnimationFadePtrOutput) FadeType 

func (o JobTemplateConfigOverlayAnimationAnimationFadePtrOutput) FadeType() pulumi.StringPtrOutput

Required. Type of fade animation: `FADE_IN` or `FADE_OUT`. The possible values are:

  • `FADE_TYPE_UNSPECIFIED`: The fade type is not specified.
  • `FADE_IN`: Fade the overlay object into view.
  • `FADE_OUT`: Fade the overlay object out of view. Possible values are: `FADE_TYPE_UNSPECIFIED`, `FADE_IN`, `FADE_OUT`.

func (JobTemplateConfigOverlayAnimationAnimationFadePtrOutput) StartTimeOffset 

func (o JobTemplateConfigOverlayAnimationAnimationFadePtrOutput) StartTimeOffset() pulumi.StringPtrOutput

The time to start the fade animation, in seconds.

func (JobTemplateConfigOverlayAnimationAnimationFadePtrOutput) ToJobTemplateConfigOverlayAnimationAnimationFadePtrOutput 

func (o JobTemplateConfigOverlayAnimationAnimationFadePtrOutput) ToJobTemplateConfigOverlayAnimationAnimationFadePtrOutput() JobTemplateConfigOverlayAnimationAnimationFadePtrOutput

func (JobTemplateConfigOverlayAnimationAnimationFadePtrOutput) ToJobTemplateConfigOverlayAnimationAnimationFadePtrOutputWithContext 

func (o JobTemplateConfigOverlayAnimationAnimationFadePtrOutput) ToJobTemplateConfigOverlayAnimationAnimationFadePtrOutputWithContext(ctx context.Context) JobTemplateConfigOverlayAnimationAnimationFadePtrOutput

func (JobTemplateConfigOverlayAnimationAnimationFadePtrOutput) Xy 

func (o JobTemplateConfigOverlayAnimationAnimationFadePtrOutput) Xy() JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput

Normalized coordinates based on output video resolution. Structure is documented below.

type JobTemplateConfigOverlayAnimationAnimationFadeXy 

type JobTemplateConfigOverlayAnimationAnimationFadeXy struct {
	// Normalized x coordinate.
	X *float64 `pulumi:"x"`
	// Normalized y coordinate.
	Y *float64 `pulumi:"y"`
}

type JobTemplateConfigOverlayAnimationAnimationFadeXyArgs 

type JobTemplateConfigOverlayAnimationAnimationFadeXyArgs struct {
	// Normalized x coordinate.
	X pulumi.Float64PtrInput `pulumi:"x"`
	// Normalized y coordinate.
	Y pulumi.Float64PtrInput `pulumi:"y"`
}

func (JobTemplateConfigOverlayAnimationAnimationFadeXyArgs) ElementType 

func (JobTemplateConfigOverlayAnimationAnimationFadeXyArgs) ElementType() reflect.Type

func (JobTemplateConfigOverlayAnimationAnimationFadeXyArgs) ToJobTemplateConfigOverlayAnimationAnimationFadeXyOutput 

func (i JobTemplateConfigOverlayAnimationAnimationFadeXyArgs) ToJobTemplateConfigOverlayAnimationAnimationFadeXyOutput() JobTemplateConfigOverlayAnimationAnimationFadeXyOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeXyArgs) ToJobTemplateConfigOverlayAnimationAnimationFadeXyOutputWithContext 

func (i JobTemplateConfigOverlayAnimationAnimationFadeXyArgs) ToJobTemplateConfigOverlayAnimationAnimationFadeXyOutputWithContext(ctx context.Context) JobTemplateConfigOverlayAnimationAnimationFadeXyOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeXyArgs) ToJobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput 

func (i JobTemplateConfigOverlayAnimationAnimationFadeXyArgs) ToJobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput() JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeXyArgs) ToJobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutputWithContext 

func (i JobTemplateConfigOverlayAnimationAnimationFadeXyArgs) ToJobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutputWithContext(ctx context.Context) JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput

type JobTemplateConfigOverlayAnimationAnimationFadeXyInput 

type JobTemplateConfigOverlayAnimationAnimationFadeXyInput interface {
	pulumi.Input

	ToJobTemplateConfigOverlayAnimationAnimationFadeXyOutput() JobTemplateConfigOverlayAnimationAnimationFadeXyOutput
	ToJobTemplateConfigOverlayAnimationAnimationFadeXyOutputWithContext(context.Context) JobTemplateConfigOverlayAnimationAnimationFadeXyOutput
}

JobTemplateConfigOverlayAnimationAnimationFadeXyInput is an input type that accepts JobTemplateConfigOverlayAnimationAnimationFadeXyArgs and JobTemplateConfigOverlayAnimationAnimationFadeXyOutput values. You can construct a concrete instance of `JobTemplateConfigOverlayAnimationAnimationFadeXyInput` via: 

JobTemplateConfigOverlayAnimationAnimationFadeXyArgs{...}

type JobTemplateConfigOverlayAnimationAnimationFadeXyOutput 

type JobTemplateConfigOverlayAnimationAnimationFadeXyOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigOverlayAnimationAnimationFadeXyOutput) ElementType 

func (JobTemplateConfigOverlayAnimationAnimationFadeXyOutput) ElementType() reflect.Type

func (JobTemplateConfigOverlayAnimationAnimationFadeXyOutput) ToJobTemplateConfigOverlayAnimationAnimationFadeXyOutput 

func (o JobTemplateConfigOverlayAnimationAnimationFadeXyOutput) ToJobTemplateConfigOverlayAnimationAnimationFadeXyOutput() JobTemplateConfigOverlayAnimationAnimationFadeXyOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeXyOutput) ToJobTemplateConfigOverlayAnimationAnimationFadeXyOutputWithContext 

func (o JobTemplateConfigOverlayAnimationAnimationFadeXyOutput) ToJobTemplateConfigOverlayAnimationAnimationFadeXyOutputWithContext(ctx context.Context) JobTemplateConfigOverlayAnimationAnimationFadeXyOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeXyOutput) ToJobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput 

func (o JobTemplateConfigOverlayAnimationAnimationFadeXyOutput) ToJobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput() JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeXyOutput) ToJobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutputWithContext 

func (o JobTemplateConfigOverlayAnimationAnimationFadeXyOutput) ToJobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutputWithContext(ctx context.Context) JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeXyOutput) X 

func (o JobTemplateConfigOverlayAnimationAnimationFadeXyOutput) X() pulumi.Float64PtrOutput

Normalized x coordinate.

func (JobTemplateConfigOverlayAnimationAnimationFadeXyOutput) Y 

func (o JobTemplateConfigOverlayAnimationAnimationFadeXyOutput) Y() pulumi.Float64PtrOutput

Normalized y coordinate.

type JobTemplateConfigOverlayAnimationAnimationFadeXyPtrInput 

type JobTemplateConfigOverlayAnimationAnimationFadeXyPtrInput interface {
	pulumi.Input

	ToJobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput() JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput
	ToJobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutputWithContext(context.Context) JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput
}

JobTemplateConfigOverlayAnimationAnimationFadeXyPtrInput is an input type that accepts JobTemplateConfigOverlayAnimationAnimationFadeXyArgs, JobTemplateConfigOverlayAnimationAnimationFadeXyPtr and JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput values. You can construct a concrete instance of `JobTemplateConfigOverlayAnimationAnimationFadeXyPtrInput` via: 

        JobTemplateConfigOverlayAnimationAnimationFadeXyArgs{...}

or:

        nil

func JobTemplateConfigOverlayAnimationAnimationFadeXyPtr 

func JobTemplateConfigOverlayAnimationAnimationFadeXyPtr(v *JobTemplateConfigOverlayAnimationAnimationFadeXyArgs) JobTemplateConfigOverlayAnimationAnimationFadeXyPtrInput

type JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput 

type JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput) Elem 

func (o JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput) Elem() JobTemplateConfigOverlayAnimationAnimationFadeXyOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput) ElementType 

func (JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput) ElementType() reflect.Type

func (JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput) ToJobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput 

func (o JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput) ToJobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput() JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput) ToJobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutputWithContext 

func (o JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput) ToJobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutputWithContext(ctx context.Context) JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput

func (JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput) X 

func (o JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput) X() pulumi.Float64PtrOutput

Normalized x coordinate.

func (JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput) Y 

func (o JobTemplateConfigOverlayAnimationAnimationFadeXyPtrOutput) Y() pulumi.Float64PtrOutput

Normalized y coordinate.

type JobTemplateConfigOverlayAnimationArgs 

type JobTemplateConfigOverlayAnimationArgs struct {
	// Display overlay object with fade animation.
	// Structure is documented below.
	AnimationFade JobTemplateConfigOverlayAnimationAnimationFadePtrInput `pulumi:"animationFade"`
}

func (JobTemplateConfigOverlayAnimationArgs) ElementType 

func (JobTemplateConfigOverlayAnimationArgs) ElementType() reflect.Type

func (JobTemplateConfigOverlayAnimationArgs) ToJobTemplateConfigOverlayAnimationOutput 

func (i JobTemplateConfigOverlayAnimationArgs) ToJobTemplateConfigOverlayAnimationOutput() JobTemplateConfigOverlayAnimationOutput

func (JobTemplateConfigOverlayAnimationArgs) ToJobTemplateConfigOverlayAnimationOutputWithContext 

func (i JobTemplateConfigOverlayAnimationArgs) ToJobTemplateConfigOverlayAnimationOutputWithContext(ctx context.Context) JobTemplateConfigOverlayAnimationOutput

type JobTemplateConfigOverlayAnimationArray 

type JobTemplateConfigOverlayAnimationArray []JobTemplateConfigOverlayAnimationInput

func (JobTemplateConfigOverlayAnimationArray) ElementType 

func (JobTemplateConfigOverlayAnimationArray) ElementType() reflect.Type

func (JobTemplateConfigOverlayAnimationArray) ToJobTemplateConfigOverlayAnimationArrayOutput 

func (i JobTemplateConfigOverlayAnimationArray) ToJobTemplateConfigOverlayAnimationArrayOutput() JobTemplateConfigOverlayAnimationArrayOutput

func (JobTemplateConfigOverlayAnimationArray) ToJobTemplateConfigOverlayAnimationArrayOutputWithContext 

func (i JobTemplateConfigOverlayAnimationArray) ToJobTemplateConfigOverlayAnimationArrayOutputWithContext(ctx context.Context) JobTemplateConfigOverlayAnimationArrayOutput

type JobTemplateConfigOverlayAnimationArrayInput 

type JobTemplateConfigOverlayAnimationArrayInput interface {
	pulumi.Input

	ToJobTemplateConfigOverlayAnimationArrayOutput() JobTemplateConfigOverlayAnimationArrayOutput
	ToJobTemplateConfigOverlayAnimationArrayOutputWithContext(context.Context) JobTemplateConfigOverlayAnimationArrayOutput
}

JobTemplateConfigOverlayAnimationArrayInput is an input type that accepts JobTemplateConfigOverlayAnimationArray and JobTemplateConfigOverlayAnimationArrayOutput values. You can construct a concrete instance of `JobTemplateConfigOverlayAnimationArrayInput` via: 

JobTemplateConfigOverlayAnimationArray{ JobTemplateConfigOverlayAnimationArgs{...} }

type JobTemplateConfigOverlayAnimationArrayOutput 

type JobTemplateConfigOverlayAnimationArrayOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigOverlayAnimationArrayOutput) ElementType 

func (JobTemplateConfigOverlayAnimationArrayOutput) ElementType() reflect.Type

func (JobTemplateConfigOverlayAnimationArrayOutput) Index 

func (o JobTemplateConfigOverlayAnimationArrayOutput) Index(i pulumi.IntInput) JobTemplateConfigOverlayAnimationOutput

func (JobTemplateConfigOverlayAnimationArrayOutput) ToJobTemplateConfigOverlayAnimationArrayOutput 

func (o JobTemplateConfigOverlayAnimationArrayOutput) ToJobTemplateConfigOverlayAnimationArrayOutput() JobTemplateConfigOverlayAnimationArrayOutput

func (JobTemplateConfigOverlayAnimationArrayOutput) ToJobTemplateConfigOverlayAnimationArrayOutputWithContext 

func (o JobTemplateConfigOverlayAnimationArrayOutput) ToJobTemplateConfigOverlayAnimationArrayOutputWithContext(ctx context.Context) JobTemplateConfigOverlayAnimationArrayOutput

type JobTemplateConfigOverlayAnimationInput 

type JobTemplateConfigOverlayAnimationInput interface {
	pulumi.Input

	ToJobTemplateConfigOverlayAnimationOutput() JobTemplateConfigOverlayAnimationOutput
	ToJobTemplateConfigOverlayAnimationOutputWithContext(context.Context) JobTemplateConfigOverlayAnimationOutput
}

JobTemplateConfigOverlayAnimationInput is an input type that accepts JobTemplateConfigOverlayAnimationArgs and JobTemplateConfigOverlayAnimationOutput values. You can construct a concrete instance of `JobTemplateConfigOverlayAnimationInput` via: 

JobTemplateConfigOverlayAnimationArgs{...}

type JobTemplateConfigOverlayAnimationOutput 

type JobTemplateConfigOverlayAnimationOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigOverlayAnimationOutput) AnimationFade 

func (o JobTemplateConfigOverlayAnimationOutput) AnimationFade() JobTemplateConfigOverlayAnimationAnimationFadePtrOutput

Display overlay object with fade animation. Structure is documented below.

func (JobTemplateConfigOverlayAnimationOutput) ElementType 

func (JobTemplateConfigOverlayAnimationOutput) ElementType() reflect.Type

func (JobTemplateConfigOverlayAnimationOutput) ToJobTemplateConfigOverlayAnimationOutput 

func (o JobTemplateConfigOverlayAnimationOutput) ToJobTemplateConfigOverlayAnimationOutput() JobTemplateConfigOverlayAnimationOutput

func (JobTemplateConfigOverlayAnimationOutput) ToJobTemplateConfigOverlayAnimationOutputWithContext 

func (o JobTemplateConfigOverlayAnimationOutput) ToJobTemplateConfigOverlayAnimationOutputWithContext(ctx context.Context) JobTemplateConfigOverlayAnimationOutput

type JobTemplateConfigOverlayArgs 

type JobTemplateConfigOverlayArgs struct {
	// List of animations. The list should be chronological, without any time overlap.
	// Structure is documented below.
	Animations JobTemplateConfigOverlayAnimationArrayInput `pulumi:"animations"`
	// Image overlay.
	// Structure is documented below.
	Image JobTemplateConfigOverlayImagePtrInput `pulumi:"image"`
}

func (JobTemplateConfigOverlayArgs) ElementType 

func (JobTemplateConfigOverlayArgs) ElementType() reflect.Type

func (JobTemplateConfigOverlayArgs) ToJobTemplateConfigOverlayOutput 

func (i JobTemplateConfigOverlayArgs) ToJobTemplateConfigOverlayOutput() JobTemplateConfigOverlayOutput

func (JobTemplateConfigOverlayArgs) ToJobTemplateConfigOverlayOutputWithContext 

func (i JobTemplateConfigOverlayArgs) ToJobTemplateConfigOverlayOutputWithContext(ctx context.Context) JobTemplateConfigOverlayOutput

type JobTemplateConfigOverlayArray 

type JobTemplateConfigOverlayArray []JobTemplateConfigOverlayInput

func (JobTemplateConfigOverlayArray) ElementType 

func (JobTemplateConfigOverlayArray) ElementType() reflect.Type

func (JobTemplateConfigOverlayArray) ToJobTemplateConfigOverlayArrayOutput 

func (i JobTemplateConfigOverlayArray) ToJobTemplateConfigOverlayArrayOutput() JobTemplateConfigOverlayArrayOutput

func (JobTemplateConfigOverlayArray) ToJobTemplateConfigOverlayArrayOutputWithContext 

func (i JobTemplateConfigOverlayArray) ToJobTemplateConfigOverlayArrayOutputWithContext(ctx context.Context) JobTemplateConfigOverlayArrayOutput

type JobTemplateConfigOverlayArrayInput 

type JobTemplateConfigOverlayArrayInput interface {
	pulumi.Input

	ToJobTemplateConfigOverlayArrayOutput() JobTemplateConfigOverlayArrayOutput
	ToJobTemplateConfigOverlayArrayOutputWithContext(context.Context) JobTemplateConfigOverlayArrayOutput
}

JobTemplateConfigOverlayArrayInput is an input type that accepts JobTemplateConfigOverlayArray and JobTemplateConfigOverlayArrayOutput values. You can construct a concrete instance of `JobTemplateConfigOverlayArrayInput` via: 

JobTemplateConfigOverlayArray{ JobTemplateConfigOverlayArgs{...} }

type JobTemplateConfigOverlayArrayOutput 

type JobTemplateConfigOverlayArrayOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigOverlayArrayOutput) ElementType 

func (JobTemplateConfigOverlayArrayOutput) ElementType() reflect.Type

func (JobTemplateConfigOverlayArrayOutput) Index 

func (o JobTemplateConfigOverlayArrayOutput) Index(i pulumi.IntInput) JobTemplateConfigOverlayOutput

func (JobTemplateConfigOverlayArrayOutput) ToJobTemplateConfigOverlayArrayOutput 

func (o JobTemplateConfigOverlayArrayOutput) ToJobTemplateConfigOverlayArrayOutput() JobTemplateConfigOverlayArrayOutput

func (JobTemplateConfigOverlayArrayOutput) ToJobTemplateConfigOverlayArrayOutputWithContext 

func (o JobTemplateConfigOverlayArrayOutput) ToJobTemplateConfigOverlayArrayOutputWithContext(ctx context.Context) JobTemplateConfigOverlayArrayOutput

type JobTemplateConfigOverlayImage 

type JobTemplateConfigOverlayImage struct {
	// URI of the image in Cloud Storage. For example, gs://bucket/inputs/image.png.
	Uri string `pulumi:"uri"`
}

type JobTemplateConfigOverlayImageArgs 

type JobTemplateConfigOverlayImageArgs struct {
	// URI of the image in Cloud Storage. For example, gs://bucket/inputs/image.png.
	Uri pulumi.StringInput `pulumi:"uri"`
}

func (JobTemplateConfigOverlayImageArgs) ElementType 

func (JobTemplateConfigOverlayImageArgs) ElementType() reflect.Type

func (JobTemplateConfigOverlayImageArgs) ToJobTemplateConfigOverlayImageOutput 

func (i JobTemplateConfigOverlayImageArgs) ToJobTemplateConfigOverlayImageOutput() JobTemplateConfigOverlayImageOutput

func (JobTemplateConfigOverlayImageArgs) ToJobTemplateConfigOverlayImageOutputWithContext 

func (i JobTemplateConfigOverlayImageArgs) ToJobTemplateConfigOverlayImageOutputWithContext(ctx context.Context) JobTemplateConfigOverlayImageOutput

func (JobTemplateConfigOverlayImageArgs) ToJobTemplateConfigOverlayImagePtrOutput 

func (i JobTemplateConfigOverlayImageArgs) ToJobTemplateConfigOverlayImagePtrOutput() JobTemplateConfigOverlayImagePtrOutput

func (JobTemplateConfigOverlayImageArgs) ToJobTemplateConfigOverlayImagePtrOutputWithContext 

func (i JobTemplateConfigOverlayImageArgs) ToJobTemplateConfigOverlayImagePtrOutputWithContext(ctx context.Context) JobTemplateConfigOverlayImagePtrOutput

type JobTemplateConfigOverlayImageInput 

type JobTemplateConfigOverlayImageInput interface {
	pulumi.Input

	ToJobTemplateConfigOverlayImageOutput() JobTemplateConfigOverlayImageOutput
	ToJobTemplateConfigOverlayImageOutputWithContext(context.Context) JobTemplateConfigOverlayImageOutput
}

JobTemplateConfigOverlayImageInput is an input type that accepts JobTemplateConfigOverlayImageArgs and JobTemplateConfigOverlayImageOutput values. You can construct a concrete instance of `JobTemplateConfigOverlayImageInput` via: 

JobTemplateConfigOverlayImageArgs{...}

type JobTemplateConfigOverlayImageOutput 

type JobTemplateConfigOverlayImageOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigOverlayImageOutput) ElementType 

func (JobTemplateConfigOverlayImageOutput) ElementType() reflect.Type

func (JobTemplateConfigOverlayImageOutput) ToJobTemplateConfigOverlayImageOutput 

func (o JobTemplateConfigOverlayImageOutput) ToJobTemplateConfigOverlayImageOutput() JobTemplateConfigOverlayImageOutput

func (JobTemplateConfigOverlayImageOutput) ToJobTemplateConfigOverlayImageOutputWithContext 

func (o JobTemplateConfigOverlayImageOutput) ToJobTemplateConfigOverlayImageOutputWithContext(ctx context.Context) JobTemplateConfigOverlayImageOutput

func (JobTemplateConfigOverlayImageOutput) ToJobTemplateConfigOverlayImagePtrOutput 

func (o JobTemplateConfigOverlayImageOutput) ToJobTemplateConfigOverlayImagePtrOutput() JobTemplateConfigOverlayImagePtrOutput

func (JobTemplateConfigOverlayImageOutput) ToJobTemplateConfigOverlayImagePtrOutputWithContext 

func (o JobTemplateConfigOverlayImageOutput) ToJobTemplateConfigOverlayImagePtrOutputWithContext(ctx context.Context) JobTemplateConfigOverlayImagePtrOutput

func (JobTemplateConfigOverlayImageOutput) Uri 

func (o JobTemplateConfigOverlayImageOutput) Uri() pulumi.StringOutput

URI of the image in Cloud Storage. For example, gs://bucket/inputs/image.png.

type JobTemplateConfigOverlayImagePtrInput 

type JobTemplateConfigOverlayImagePtrInput interface {
	pulumi.Input

	ToJobTemplateConfigOverlayImagePtrOutput() JobTemplateConfigOverlayImagePtrOutput
	ToJobTemplateConfigOverlayImagePtrOutputWithContext(context.Context) JobTemplateConfigOverlayImagePtrOutput
}

JobTemplateConfigOverlayImagePtrInput is an input type that accepts JobTemplateConfigOverlayImageArgs, JobTemplateConfigOverlayImagePtr and JobTemplateConfigOverlayImagePtrOutput values. You can construct a concrete instance of `JobTemplateConfigOverlayImagePtrInput` via: 

        JobTemplateConfigOverlayImageArgs{...}

or:

        nil

func JobTemplateConfigOverlayImagePtr 

func JobTemplateConfigOverlayImagePtr(v *JobTemplateConfigOverlayImageArgs) JobTemplateConfigOverlayImagePtrInput

type JobTemplateConfigOverlayImagePtrOutput 

type JobTemplateConfigOverlayImagePtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigOverlayImagePtrOutput) Elem 

func (o JobTemplateConfigOverlayImagePtrOutput) Elem() JobTemplateConfigOverlayImageOutput

func (JobTemplateConfigOverlayImagePtrOutput) ElementType 

func (JobTemplateConfigOverlayImagePtrOutput) ElementType() reflect.Type

func (JobTemplateConfigOverlayImagePtrOutput) ToJobTemplateConfigOverlayImagePtrOutput 

func (o JobTemplateConfigOverlayImagePtrOutput) ToJobTemplateConfigOverlayImagePtrOutput() JobTemplateConfigOverlayImagePtrOutput

func (JobTemplateConfigOverlayImagePtrOutput) ToJobTemplateConfigOverlayImagePtrOutputWithContext 

func (o JobTemplateConfigOverlayImagePtrOutput) ToJobTemplateConfigOverlayImagePtrOutputWithContext(ctx context.Context) JobTemplateConfigOverlayImagePtrOutput

func (JobTemplateConfigOverlayImagePtrOutput) Uri 

func (o JobTemplateConfigOverlayImagePtrOutput) Uri() pulumi.StringPtrOutput

URI of the image in Cloud Storage. For example, gs://bucket/inputs/image.png.

type JobTemplateConfigOverlayInput 

type JobTemplateConfigOverlayInput interface {
	pulumi.Input

	ToJobTemplateConfigOverlayOutput() JobTemplateConfigOverlayOutput
	ToJobTemplateConfigOverlayOutputWithContext(context.Context) JobTemplateConfigOverlayOutput
}

JobTemplateConfigOverlayInput is an input type that accepts JobTemplateConfigOverlayArgs and JobTemplateConfigOverlayOutput values. You can construct a concrete instance of `JobTemplateConfigOverlayInput` via: 

JobTemplateConfigOverlayArgs{...}

type JobTemplateConfigOverlayOutput 

type JobTemplateConfigOverlayOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigOverlayOutput) Animations 

func (o JobTemplateConfigOverlayOutput) Animations() JobTemplateConfigOverlayAnimationArrayOutput

List of animations. The list should be chronological, without any time overlap. Structure is documented below.

func (JobTemplateConfigOverlayOutput) ElementType 

func (JobTemplateConfigOverlayOutput) ElementType() reflect.Type

func (JobTemplateConfigOverlayOutput) Image 

func (o JobTemplateConfigOverlayOutput) Image() JobTemplateConfigOverlayImagePtrOutput

Image overlay. Structure is documented below.

func (JobTemplateConfigOverlayOutput) ToJobTemplateConfigOverlayOutput 

func (o JobTemplateConfigOverlayOutput) ToJobTemplateConfigOverlayOutput() JobTemplateConfigOverlayOutput

func (JobTemplateConfigOverlayOutput) ToJobTemplateConfigOverlayOutputWithContext 

func (o JobTemplateConfigOverlayOutput) ToJobTemplateConfigOverlayOutputWithContext(ctx context.Context) JobTemplateConfigOverlayOutput

type JobTemplateConfigPtrInput 

type JobTemplateConfigPtrInput interface {
	pulumi.Input

	ToJobTemplateConfigPtrOutput() JobTemplateConfigPtrOutput
	ToJobTemplateConfigPtrOutputWithContext(context.Context) JobTemplateConfigPtrOutput
}

JobTemplateConfigPtrInput is an input type that accepts JobTemplateConfigArgs, JobTemplateConfigPtr and JobTemplateConfigPtrOutput values. You can construct a concrete instance of `JobTemplateConfigPtrInput` via: 

        JobTemplateConfigArgs{...}

or:

        nil

func JobTemplateConfigPtr 

func JobTemplateConfigPtr(v *JobTemplateConfigArgs) JobTemplateConfigPtrInput

type JobTemplateConfigPtrOutput 

type JobTemplateConfigPtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigPtrOutput) AdBreaks 

func (o JobTemplateConfigPtrOutput) AdBreaks() JobTemplateConfigAdBreakArrayOutput

Ad break. Structure is documented below.

func (JobTemplateConfigPtrOutput) EditLists 

func (o JobTemplateConfigPtrOutput) EditLists() JobTemplateConfigEditListArrayOutput

List of input assets stored in Cloud Storage. Structure is documented below.

func (JobTemplateConfigPtrOutput) Elem 

func (o JobTemplateConfigPtrOutput) Elem() JobTemplateConfigOutput

func (JobTemplateConfigPtrOutput) ElementType 

func (JobTemplateConfigPtrOutput) ElementType() reflect.Type

func (JobTemplateConfigPtrOutput) ElementaryStreams 

func (o JobTemplateConfigPtrOutput) ElementaryStreams() JobTemplateConfigElementaryStreamArrayOutput

List of input assets stored in Cloud Storage. Structure is documented below.

func (JobTemplateConfigPtrOutput) Encryptions 

func (o JobTemplateConfigPtrOutput) Encryptions() JobTemplateConfigEncryptionArrayOutput

List of encryption configurations for the content. Structure is documented below.

func (JobTemplateConfigPtrOutput) Inputs 

func (o JobTemplateConfigPtrOutput) Inputs() JobTemplateConfigInputTypeArrayOutput

List of input assets stored in Cloud Storage. Structure is documented below.

func (JobTemplateConfigPtrOutput) Manifests 

func (o JobTemplateConfigPtrOutput) Manifests() JobTemplateConfigManifestArrayOutput

Manifest configuration. Structure is documented below.

func (JobTemplateConfigPtrOutput) MuxStreams 

func (o JobTemplateConfigPtrOutput) MuxStreams() JobTemplateConfigMuxStreamArrayOutput

Multiplexing settings for output stream. Structure is documented below.

func (JobTemplateConfigPtrOutput) Output 

func (o JobTemplateConfigPtrOutput) Output() JobTemplateConfigOutputTypePtrOutput

Location of output file(s) in a Cloud Storage bucket. Structure is documented below.

func (JobTemplateConfigPtrOutput) Overlays 

func (o JobTemplateConfigPtrOutput) Overlays() JobTemplateConfigOverlayArrayOutput

List of overlays on the output video, in descending Z-order. Structure is documented below.

func (JobTemplateConfigPtrOutput) PubsubDestination 

func (o JobTemplateConfigPtrOutput) PubsubDestination() JobTemplateConfigPubsubDestinationPtrOutput

Pub/Sub destination. Structure is documented below.

func (JobTemplateConfigPtrOutput) ToJobTemplateConfigPtrOutput 

func (o JobTemplateConfigPtrOutput) ToJobTemplateConfigPtrOutput() JobTemplateConfigPtrOutput

func (JobTemplateConfigPtrOutput) ToJobTemplateConfigPtrOutputWithContext 

func (o JobTemplateConfigPtrOutput) ToJobTemplateConfigPtrOutputWithContext(ctx context.Context) JobTemplateConfigPtrOutput

type JobTemplateConfigPubsubDestination 

type JobTemplateConfigPubsubDestination struct {
	// The name of the Pub/Sub topic to publish job completion notification to. For example: projects/{project}/topics/{topic}.
	Topic *string `pulumi:"topic"`
}

type JobTemplateConfigPubsubDestinationArgs 

type JobTemplateConfigPubsubDestinationArgs struct {
	// The name of the Pub/Sub topic to publish job completion notification to. For example: projects/{project}/topics/{topic}.
	Topic pulumi.StringPtrInput `pulumi:"topic"`
}

func (JobTemplateConfigPubsubDestinationArgs) ElementType 

func (JobTemplateConfigPubsubDestinationArgs) ElementType() reflect.Type

func (JobTemplateConfigPubsubDestinationArgs) ToJobTemplateConfigPubsubDestinationOutput 

func (i JobTemplateConfigPubsubDestinationArgs) ToJobTemplateConfigPubsubDestinationOutput() JobTemplateConfigPubsubDestinationOutput

func (JobTemplateConfigPubsubDestinationArgs) ToJobTemplateConfigPubsubDestinationOutputWithContext 

func (i JobTemplateConfigPubsubDestinationArgs) ToJobTemplateConfigPubsubDestinationOutputWithContext(ctx context.Context) JobTemplateConfigPubsubDestinationOutput

func (JobTemplateConfigPubsubDestinationArgs) ToJobTemplateConfigPubsubDestinationPtrOutput 

func (i JobTemplateConfigPubsubDestinationArgs) ToJobTemplateConfigPubsubDestinationPtrOutput() JobTemplateConfigPubsubDestinationPtrOutput

func (JobTemplateConfigPubsubDestinationArgs) ToJobTemplateConfigPubsubDestinationPtrOutputWithContext 

func (i JobTemplateConfigPubsubDestinationArgs) ToJobTemplateConfigPubsubDestinationPtrOutputWithContext(ctx context.Context) JobTemplateConfigPubsubDestinationPtrOutput

type JobTemplateConfigPubsubDestinationInput 

type JobTemplateConfigPubsubDestinationInput interface {
	pulumi.Input

	ToJobTemplateConfigPubsubDestinationOutput() JobTemplateConfigPubsubDestinationOutput
	ToJobTemplateConfigPubsubDestinationOutputWithContext(context.Context) JobTemplateConfigPubsubDestinationOutput
}

JobTemplateConfigPubsubDestinationInput is an input type that accepts JobTemplateConfigPubsubDestinationArgs and JobTemplateConfigPubsubDestinationOutput values. You can construct a concrete instance of `JobTemplateConfigPubsubDestinationInput` via: 

JobTemplateConfigPubsubDestinationArgs{...}

type JobTemplateConfigPubsubDestinationOutput 

type JobTemplateConfigPubsubDestinationOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigPubsubDestinationOutput) ElementType 

func (JobTemplateConfigPubsubDestinationOutput) ElementType() reflect.Type

func (JobTemplateConfigPubsubDestinationOutput) ToJobTemplateConfigPubsubDestinationOutput 

func (o JobTemplateConfigPubsubDestinationOutput) ToJobTemplateConfigPubsubDestinationOutput() JobTemplateConfigPubsubDestinationOutput

func (JobTemplateConfigPubsubDestinationOutput) ToJobTemplateConfigPubsubDestinationOutputWithContext 

func (o JobTemplateConfigPubsubDestinationOutput) ToJobTemplateConfigPubsubDestinationOutputWithContext(ctx context.Context) JobTemplateConfigPubsubDestinationOutput

func (JobTemplateConfigPubsubDestinationOutput) ToJobTemplateConfigPubsubDestinationPtrOutput 

func (o JobTemplateConfigPubsubDestinationOutput) ToJobTemplateConfigPubsubDestinationPtrOutput() JobTemplateConfigPubsubDestinationPtrOutput

func (JobTemplateConfigPubsubDestinationOutput) ToJobTemplateConfigPubsubDestinationPtrOutputWithContext 

func (o JobTemplateConfigPubsubDestinationOutput) ToJobTemplateConfigPubsubDestinationPtrOutputWithContext(ctx context.Context) JobTemplateConfigPubsubDestinationPtrOutput

func (JobTemplateConfigPubsubDestinationOutput) Topic 

func (o JobTemplateConfigPubsubDestinationOutput) Topic() pulumi.StringPtrOutput

The name of the Pub/Sub topic to publish job completion notification to. For example: projects/{project}/topics/{topic}.

type JobTemplateConfigPubsubDestinationPtrInput 

type JobTemplateConfigPubsubDestinationPtrInput interface {
	pulumi.Input

	ToJobTemplateConfigPubsubDestinationPtrOutput() JobTemplateConfigPubsubDestinationPtrOutput
	ToJobTemplateConfigPubsubDestinationPtrOutputWithContext(context.Context) JobTemplateConfigPubsubDestinationPtrOutput
}

JobTemplateConfigPubsubDestinationPtrInput is an input type that accepts JobTemplateConfigPubsubDestinationArgs, JobTemplateConfigPubsubDestinationPtr and JobTemplateConfigPubsubDestinationPtrOutput values. You can construct a concrete instance of `JobTemplateConfigPubsubDestinationPtrInput` via: 

        JobTemplateConfigPubsubDestinationArgs{...}

or:

        nil

func JobTemplateConfigPubsubDestinationPtr 

func JobTemplateConfigPubsubDestinationPtr(v *JobTemplateConfigPubsubDestinationArgs) JobTemplateConfigPubsubDestinationPtrInput

type JobTemplateConfigPubsubDestinationPtrOutput 

type JobTemplateConfigPubsubDestinationPtrOutput struct{ *pulumi.OutputState }

func (JobTemplateConfigPubsubDestinationPtrOutput) Elem 

func (o JobTemplateConfigPubsubDestinationPtrOutput) Elem() JobTemplateConfigPubsubDestinationOutput

func (JobTemplateConfigPubsubDestinationPtrOutput) ElementType 

func (JobTemplateConfigPubsubDestinationPtrOutput) ElementType() reflect.Type

func (JobTemplateConfigPubsubDestinationPtrOutput) ToJobTemplateConfigPubsubDestinationPtrOutput 

func (o JobTemplateConfigPubsubDestinationPtrOutput) ToJobTemplateConfigPubsubDestinationPtrOutput() JobTemplateConfigPubsubDestinationPtrOutput

func (JobTemplateConfigPubsubDestinationPtrOutput) ToJobTemplateConfigPubsubDestinationPtrOutputWithContext 

func (o JobTemplateConfigPubsubDestinationPtrOutput) ToJobTemplateConfigPubsubDestinationPtrOutputWithContext(ctx context.Context) JobTemplateConfigPubsubDestinationPtrOutput

func (JobTemplateConfigPubsubDestinationPtrOutput) Topic 

func (o JobTemplateConfigPubsubDestinationPtrOutput) Topic() pulumi.StringPtrOutput

The name of the Pub/Sub topic to publish job completion notification to. For example: projects/{project}/topics/{topic}.

type JobTemplateInput 

type JobTemplateInput interface {
	pulumi.Input

	ToJobTemplateOutput() JobTemplateOutput
	ToJobTemplateOutputWithContext(ctx context.Context) JobTemplateOutput
}

type JobTemplateMap 

type JobTemplateMap map[string]JobTemplateInput

func (JobTemplateMap) ElementType 

func (JobTemplateMap) ElementType() reflect.Type

func (JobTemplateMap) ToJobTemplateMapOutput 

func (i JobTemplateMap) ToJobTemplateMapOutput() JobTemplateMapOutput

func (JobTemplateMap) ToJobTemplateMapOutputWithContext 

func (i JobTemplateMap) ToJobTemplateMapOutputWithContext(ctx context.Context) JobTemplateMapOutput

type JobTemplateMapInput 

type JobTemplateMapInput interface {
	pulumi.Input

	ToJobTemplateMapOutput() JobTemplateMapOutput
	ToJobTemplateMapOutputWithContext(context.Context) JobTemplateMapOutput
}

JobTemplateMapInput is an input type that accepts JobTemplateMap and JobTemplateMapOutput values. You can construct a concrete instance of `JobTemplateMapInput` via: 

JobTemplateMap{ "key": JobTemplateArgs{...} }

type JobTemplateMapOutput 

type JobTemplateMapOutput struct{ *pulumi.OutputState }

func (JobTemplateMapOutput) ElementType 

func (JobTemplateMapOutput) ElementType() reflect.Type

func (JobTemplateMapOutput) MapIndex 

func (o JobTemplateMapOutput) MapIndex(k pulumi.StringInput) JobTemplateOutput

func (JobTemplateMapOutput) ToJobTemplateMapOutput 

func (o JobTemplateMapOutput) ToJobTemplateMapOutput() JobTemplateMapOutput

func (JobTemplateMapOutput) ToJobTemplateMapOutputWithContext 

func (o JobTemplateMapOutput) ToJobTemplateMapOutputWithContext(ctx context.Context) JobTemplateMapOutput

type JobTemplateOutput 

type JobTemplateOutput struct{ *pulumi.OutputState }

func (JobTemplateOutput) Config 

func (o JobTemplateOutput) Config() JobTemplateConfigOutput

The configuration for this template. Structure is documented below.

func (JobTemplateOutput) EffectiveLabels 

func (o JobTemplateOutput) EffectiveLabels() pulumi.StringMapOutput

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

func (JobTemplateOutput) ElementType 

func (JobTemplateOutput) ElementType() reflect.Type

func (JobTemplateOutput) JobTemplateId 

func (o JobTemplateOutput) JobTemplateId() pulumi.StringOutput

ID to use for the Transcoding job template.

func (JobTemplateOutput) Labels 

func (o JobTemplateOutput) Labels() pulumi.StringMapOutput

The labels associated with this job template. You can use these to organize and group your job templates.

**Note**: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field `effectiveLabels` for all of the labels present on the resource.

func (JobTemplateOutput) Location 

func (o JobTemplateOutput) Location() pulumi.StringOutput

The location of the transcoding job template resource.

***

func (JobTemplateOutput) Name 

func (o JobTemplateOutput) Name() pulumi.StringOutput

The resource name of the job template.

func (JobTemplateOutput) Project 

func (o JobTemplateOutput) Project() pulumi.StringOutput

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

func (JobTemplateOutput) PulumiLabels 

func (o JobTemplateOutput) PulumiLabels() pulumi.StringMapOutput

The combination of labels configured directly on the resource and default labels configured on the provider.

func (JobTemplateOutput) ToJobTemplateOutput 

func (o JobTemplateOutput) ToJobTemplateOutput() JobTemplateOutput

func (JobTemplateOutput) ToJobTemplateOutputWithContext 

func (o JobTemplateOutput) ToJobTemplateOutputWithContext(ctx context.Context) JobTemplateOutput

type JobTemplateState 

type JobTemplateState struct {
	// The configuration for this template.
	// Structure is documented below.
	Config JobTemplateConfigPtrInput
	// All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
	EffectiveLabels pulumi.StringMapInput
	// ID to use for the Transcoding job template.
	JobTemplateId pulumi.StringPtrInput
	// The labels associated with this job template. You can use these to organize and group your job templates.
	//
	// **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
	// Please refer to the field `effectiveLabels` for all of the labels present on the resource.
	Labels pulumi.StringMapInput
	// The location of the transcoding job template resource.
	//
	// ***
	Location pulumi.StringPtrInput
	// The resource name of the job template.
	Name pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
	// The combination of labels configured directly on the resource
	// and default labels configured on the provider.
	PulumiLabels pulumi.StringMapInput
}

func (JobTemplateState) ElementType 

func (JobTemplateState) ElementType() reflect.Type

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.