tfplan2cai/converters/google/resources/services/transcoder/transcoder_job.go

// ----------------------------------------------------------------------------
//
//     ***     AUTO GENERATED CODE    ***    Type: MMv1     ***
//
// ----------------------------------------------------------------------------
//
//     This code is generated by Magic Modules using the following:
//
//     Configuration: https://github.com/GoogleCloudPlatform/magic-modules/tree/main/mmv1/products/transcoder/Job.yaml
//     Template:      https://github.com/GoogleCloudPlatform/magic-modules/tree/main/mmv1/templates/tgc/resource_converter.go.tmpl
//
//     DO NOT EDIT this file directly. Any changes made to this file will be
//     overwritten during the next generation cycle.
//
// ----------------------------------------------------------------------------

package transcoder

import (
	"reflect"

	"github.com/GoogleCloudPlatform/terraform-google-conversion/v6/tfplan2cai/converters/google/resources/cai"
	"github.com/hashicorp/terraform-provider-google-beta/google-beta/tpgresource"
	transport_tpg "github.com/hashicorp/terraform-provider-google-beta/google-beta/transport"
)

const TranscoderJobAssetType string = "transcoder.googleapis.com/Job"

func ResourceConverterTranscoderJob() cai.ResourceConverter {
	return cai.ResourceConverter{
		AssetType: TranscoderJobAssetType,
		Convert:   GetTranscoderJobCaiObject,
	}
}

func GetTranscoderJobCaiObject(d tpgresource.TerraformResourceData, config *transport_tpg.Config) ([]cai.Asset, error) {
	name, err := cai.AssetName(d, config, "//transcoder.googleapis.com/{{name}}")
	if err != nil {
		return []cai.Asset{}, err
	}
	if obj, err := GetTranscoderJobApiObject(d, config); err == nil {
		return []cai.Asset{{
			Name: name,
			Type: TranscoderJobAssetType,
			Resource: &cai.AssetResource{
				Version:              "v1",
				DiscoveryDocumentURI: "https://www.googleapis.com/discovery/v1/apis/transcoder/v1/rest",
				DiscoveryName:        "Job",
				Data:                 obj,
			},
		}}, nil
	} else {
		return []cai.Asset{}, err
	}
}

func GetTranscoderJobApiObject(d tpgresource.TerraformResourceData, config *transport_tpg.Config) (map[string]interface{}, error) {
	obj := make(map[string]interface{})
	templateIdProp, err := expandTranscoderJobTemplateId(d.Get("template_id"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("template_id"); !tpgresource.IsEmptyValue(reflect.ValueOf(templateIdProp)) && (ok || !reflect.DeepEqual(v, templateIdProp)) {
		obj["templateId"] = templateIdProp
	}
	configProp, err := expandTranscoderJobConfig(d.Get("config"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("config"); !tpgresource.IsEmptyValue(reflect.ValueOf(configProp)) && (ok || !reflect.DeepEqual(v, configProp)) {
		obj["config"] = configProp
	}
	labelsProp, err := expandTranscoderJobEffectiveLabels(d.Get("effective_labels"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("effective_labels"); !tpgresource.IsEmptyValue(reflect.ValueOf(labelsProp)) && (ok || !reflect.DeepEqual(v, labelsProp)) {
		obj["labels"] = labelsProp
	}

	return obj, nil
}

func expandTranscoderJobTemplateId(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfig(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 || l[0] == nil {
		return nil, nil
	}
	raw := l[0]
	original := raw.(map[string]interface{})
	transformed := make(map[string]interface{})

	transformedInputs, err := expandTranscoderJobConfigInputs(original["inputs"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedInputs); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["inputs"] = transformedInputs
	}

	transformedEditList, err := expandTranscoderJobConfigEditList(original["edit_list"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedEditList); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["editList"] = transformedEditList
	}

	transformedElementaryStreams, err := expandTranscoderJobConfigElementaryStreams(original["elementary_streams"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedElementaryStreams); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["elementaryStreams"] = transformedElementaryStreams
	}

	transformedMuxStreams, err := expandTranscoderJobConfigMuxStreams(original["mux_streams"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedMuxStreams); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["muxStreams"] = transformedMuxStreams
	}

	transformedManifests, err := expandTranscoderJobConfigManifests(original["manifests"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedManifests); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["manifests"] = transformedManifests
	}

	transformedOutput, err := expandTranscoderJobConfigOutput(original["output"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedOutput); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["output"] = transformedOutput
	}

	transformedAdBreaks, err := expandTranscoderJobConfigAdBreaks(original["ad_breaks"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedAdBreaks); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["adBreaks"] = transformedAdBreaks
	}

	transformedPubsubDestination, err := expandTranscoderJobConfigPubsubDestination(original["pubsub_destination"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedPubsubDestination); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["pubsubDestination"] = transformedPubsubDestination
	}

	transformedOverlays, err := expandTranscoderJobConfigOverlays(original["overlays"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedOverlays); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["overlays"] = transformedOverlays
	}

	transformedEncryptions, err := expandTranscoderJobConfigEncryptions(original["encryptions"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedEncryptions); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["encryptions"] = transformedEncryptions
	}

	return transformed, nil
}

func expandTranscoderJobConfigInputs(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	req := make([]interface{}, 0, len(l))
	for _, raw := range l {
		if raw == nil {
			continue
		}
		original := raw.(map[string]interface{})
		transformed := make(map[string]interface{})

		transformedKey, err := expandTranscoderJobConfigInputsKey(original["key"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedKey); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["key"] = transformedKey
		}

		transformedUri, err := expandTranscoderJobConfigInputsUri(original["uri"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedUri); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["uri"] = transformedUri
		}

		req = append(req, transformed)
	}
	return req, nil
}

func expandTranscoderJobConfigInputsKey(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigInputsUri(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigEditList(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	req := make([]interface{}, 0, len(l))
	for _, raw := range l {
		if raw == nil {
			continue
		}
		original := raw.(map[string]interface{})
		transformed := make(map[string]interface{})

		transformedKey, err := expandTranscoderJobConfigEditListKey(original["key"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedKey); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["key"] = transformedKey
		}

		transformedInputs, err := expandTranscoderJobConfigEditListInputs(original["inputs"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedInputs); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["inputs"] = transformedInputs
		}

		transformedStartTimeOffset, err := expandTranscoderJobConfigEditListStartTimeOffset(original["start_time_offset"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedStartTimeOffset); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["startTimeOffset"] = transformedStartTimeOffset
		}

		req = append(req, transformed)
	}
	return req, nil
}

func expandTranscoderJobConfigEditListKey(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigEditListInputs(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigEditListStartTimeOffset(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreams(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	req := make([]interface{}, 0, len(l))
	for _, raw := range l {
		if raw == nil {
			continue
		}
		original := raw.(map[string]interface{})
		transformed := make(map[string]interface{})

		transformedKey, err := expandTranscoderJobConfigElementaryStreamsKey(original["key"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedKey); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["key"] = transformedKey
		}

		transformedVideoStream, err := expandTranscoderJobConfigElementaryStreamsVideoStream(original["video_stream"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedVideoStream); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["videoStream"] = transformedVideoStream
		}

		transformedAudioStream, err := expandTranscoderJobConfigElementaryStreamsAudioStream(original["audio_stream"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedAudioStream); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["audioStream"] = transformedAudioStream
		}

		req = append(req, transformed)
	}
	return req, nil
}

func expandTranscoderJobConfigElementaryStreamsKey(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStream(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 || l[0] == nil {
		return nil, nil
	}
	raw := l[0]
	original := raw.(map[string]interface{})
	transformed := make(map[string]interface{})

	transformedH264, err := expandTranscoderJobConfigElementaryStreamsVideoStreamH264(original["h264"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedH264); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["h264"] = transformedH264
	}

	return transformed, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStreamH264(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 || l[0] == nil {
		return nil, nil
	}
	raw := l[0]
	original := raw.(map[string]interface{})
	transformed := make(map[string]interface{})

	transformedWidthPixels, err := expandTranscoderJobConfigElementaryStreamsVideoStreamH264WidthPixels(original["width_pixels"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedWidthPixels); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["widthPixels"] = transformedWidthPixels
	}

	transformedHeightPixels, err := expandTranscoderJobConfigElementaryStreamsVideoStreamH264HeightPixels(original["height_pixels"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedHeightPixels); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["heightPixels"] = transformedHeightPixels
	}

	transformedFrameRate, err := expandTranscoderJobConfigElementaryStreamsVideoStreamH264FrameRate(original["frame_rate"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedFrameRate); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["frameRate"] = transformedFrameRate
	}

	transformedBitrateBps, err := expandTranscoderJobConfigElementaryStreamsVideoStreamH264BitrateBps(original["bitrate_bps"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedBitrateBps); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["bitrateBps"] = transformedBitrateBps
	}

	transformedPixelFormat, err := expandTranscoderJobConfigElementaryStreamsVideoStreamH264PixelFormat(original["pixel_format"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedPixelFormat); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["pixelFormat"] = transformedPixelFormat
	}

	transformedRateControlMode, err := expandTranscoderJobConfigElementaryStreamsVideoStreamH264RateControlMode(original["rate_control_mode"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedRateControlMode); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["rateControlMode"] = transformedRateControlMode
	}

	transformedCrfLevel, err := expandTranscoderJobConfigElementaryStreamsVideoStreamH264CrfLevel(original["crf_level"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedCrfLevel); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["crfLevel"] = transformedCrfLevel
	}

	transformedVbvSizeBits, err := expandTranscoderJobConfigElementaryStreamsVideoStreamH264VbvSizeBits(original["vbv_size_bits"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedVbvSizeBits); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["vbvSizeBits"] = transformedVbvSizeBits
	}

	transformedVbvFullnessBits, err := expandTranscoderJobConfigElementaryStreamsVideoStreamH264VbvFullnessBits(original["vbv_fullness_bits"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedVbvFullnessBits); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["vbvFullnessBits"] = transformedVbvFullnessBits
	}

	transformedEntropyCoder, err := expandTranscoderJobConfigElementaryStreamsVideoStreamH264EntropyCoder(original["entropy_coder"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedEntropyCoder); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["entropyCoder"] = transformedEntropyCoder
	}

	transformedProfile, err := expandTranscoderJobConfigElementaryStreamsVideoStreamH264Profile(original["profile"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedProfile); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["profile"] = transformedProfile
	}

	transformedPreset, err := expandTranscoderJobConfigElementaryStreamsVideoStreamH264Preset(original["preset"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedPreset); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["preset"] = transformedPreset
	}

	transformedGopDuration, err := expandTranscoderJobConfigElementaryStreamsVideoStreamH264GopDuration(original["gop_duration"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedGopDuration); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["gopDuration"] = transformedGopDuration
	}

	transformedSdr, err := expandTranscoderJobConfigElementaryStreamsVideoStreamH264Sdr(original["sdr"], d, config)
	if err != nil {
		return nil, err
	} else {
		transformed["sdr"] = transformedSdr
	}

	transformedHlg, err := expandTranscoderJobConfigElementaryStreamsVideoStreamH264Hlg(original["hlg"], d, config)
	if err != nil {
		return nil, err
	} else {
		transformed["hlg"] = transformedHlg
	}

	return transformed, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStreamH264WidthPixels(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStreamH264HeightPixels(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStreamH264FrameRate(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStreamH264BitrateBps(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStreamH264PixelFormat(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStreamH264RateControlMode(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStreamH264CrfLevel(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStreamH264VbvSizeBits(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStreamH264VbvFullnessBits(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStreamH264EntropyCoder(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStreamH264Profile(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStreamH264Preset(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStreamH264GopDuration(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStreamH264Sdr(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 {
		return nil, nil
	}

	if l[0] == nil {
		transformed := make(map[string]interface{})
		return transformed, nil
	}
	transformed := make(map[string]interface{})

	return transformed, nil
}

func expandTranscoderJobConfigElementaryStreamsVideoStreamH264Hlg(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 {
		return nil, nil
	}

	if l[0] == nil {
		transformed := make(map[string]interface{})
		return transformed, nil
	}
	transformed := make(map[string]interface{})

	return transformed, nil
}

func expandTranscoderJobConfigElementaryStreamsAudioStream(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 || l[0] == nil {
		return nil, nil
	}
	raw := l[0]
	original := raw.(map[string]interface{})
	transformed := make(map[string]interface{})

	transformedCodec, err := expandTranscoderJobConfigElementaryStreamsAudioStreamCodec(original["codec"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedCodec); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["codec"] = transformedCodec
	}

	transformedBitrateBps, err := expandTranscoderJobConfigElementaryStreamsAudioStreamBitrateBps(original["bitrate_bps"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedBitrateBps); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["bitrateBps"] = transformedBitrateBps
	}

	transformedChannelCount, err := expandTranscoderJobConfigElementaryStreamsAudioStreamChannelCount(original["channel_count"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedChannelCount); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["channelCount"] = transformedChannelCount
	}

	transformedChannelLayout, err := expandTranscoderJobConfigElementaryStreamsAudioStreamChannelLayout(original["channel_layout"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedChannelLayout); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["channelLayout"] = transformedChannelLayout
	}

	transformedSampleRateHertz, err := expandTranscoderJobConfigElementaryStreamsAudioStreamSampleRateHertz(original["sample_rate_hertz"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedSampleRateHertz); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["sampleRateHertz"] = transformedSampleRateHertz
	}

	return transformed, nil
}

func expandTranscoderJobConfigElementaryStreamsAudioStreamCodec(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsAudioStreamBitrateBps(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsAudioStreamChannelCount(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsAudioStreamChannelLayout(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigElementaryStreamsAudioStreamSampleRateHertz(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigMuxStreams(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	req := make([]interface{}, 0, len(l))
	for _, raw := range l {
		if raw == nil {
			continue
		}
		original := raw.(map[string]interface{})
		transformed := make(map[string]interface{})

		transformedKey, err := expandTranscoderJobConfigMuxStreamsKey(original["key"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedKey); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["key"] = transformedKey
		}

		transformedFileName, err := expandTranscoderJobConfigMuxStreamsFileName(original["file_name"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedFileName); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["fileName"] = transformedFileName
		}

		transformedContainer, err := expandTranscoderJobConfigMuxStreamsContainer(original["container"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedContainer); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["container"] = transformedContainer
		}

		transformedElementaryStreams, err := expandTranscoderJobConfigMuxStreamsElementaryStreams(original["elementary_streams"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedElementaryStreams); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["elementaryStreams"] = transformedElementaryStreams
		}

		transformedSegmentSettings, err := expandTranscoderJobConfigMuxStreamsSegmentSettings(original["segment_settings"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedSegmentSettings); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["segmentSettings"] = transformedSegmentSettings
		}

		transformedEncryptionId, err := expandTranscoderJobConfigMuxStreamsEncryptionId(original["encryption_id"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedEncryptionId); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["encryptionId"] = transformedEncryptionId
		}

		req = append(req, transformed)
	}
	return req, nil
}

func expandTranscoderJobConfigMuxStreamsKey(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigMuxStreamsFileName(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigMuxStreamsContainer(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigMuxStreamsElementaryStreams(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigMuxStreamsSegmentSettings(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 || l[0] == nil {
		return nil, nil
	}
	raw := l[0]
	original := raw.(map[string]interface{})
	transformed := make(map[string]interface{})

	transformedSegmentDuration, err := expandTranscoderJobConfigMuxStreamsSegmentSettingsSegmentDuration(original["segment_duration"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedSegmentDuration); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["segmentDuration"] = transformedSegmentDuration
	}

	return transformed, nil
}

func expandTranscoderJobConfigMuxStreamsSegmentSettingsSegmentDuration(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigMuxStreamsEncryptionId(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigManifests(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	req := make([]interface{}, 0, len(l))
	for _, raw := range l {
		if raw == nil {
			continue
		}
		original := raw.(map[string]interface{})
		transformed := make(map[string]interface{})

		transformedFileName, err := expandTranscoderJobConfigManifestsFileName(original["file_name"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedFileName); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["fileName"] = transformedFileName
		}

		transformedType, err := expandTranscoderJobConfigManifestsType(original["type"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedType); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["type"] = transformedType
		}

		transformedMuxStreams, err := expandTranscoderJobConfigManifestsMuxStreams(original["mux_streams"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedMuxStreams); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["muxStreams"] = transformedMuxStreams
		}

		req = append(req, transformed)
	}
	return req, nil
}

func expandTranscoderJobConfigManifestsFileName(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigManifestsType(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigManifestsMuxStreams(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigOutput(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 || l[0] == nil {
		return nil, nil
	}
	raw := l[0]
	original := raw.(map[string]interface{})
	transformed := make(map[string]interface{})

	transformedUri, err := expandTranscoderJobConfigOutputUri(original["uri"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedUri); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["uri"] = transformedUri
	}

	return transformed, nil
}

func expandTranscoderJobConfigOutputUri(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigAdBreaks(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	req := make([]interface{}, 0, len(l))
	for _, raw := range l {
		if raw == nil {
			continue
		}
		original := raw.(map[string]interface{})
		transformed := make(map[string]interface{})

		transformedStartTimeOffset, err := expandTranscoderJobConfigAdBreaksStartTimeOffset(original["start_time_offset"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedStartTimeOffset); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["startTimeOffset"] = transformedStartTimeOffset
		}

		req = append(req, transformed)
	}
	return req, nil
}

func expandTranscoderJobConfigAdBreaksStartTimeOffset(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigPubsubDestination(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 || l[0] == nil {
		return nil, nil
	}
	raw := l[0]
	original := raw.(map[string]interface{})
	transformed := make(map[string]interface{})

	transformedTopic, err := expandTranscoderJobConfigPubsubDestinationTopic(original["topic"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedTopic); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["topic"] = transformedTopic
	}

	return transformed, nil
}

func expandTranscoderJobConfigPubsubDestinationTopic(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigOverlays(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	req := make([]interface{}, 0, len(l))
	for _, raw := range l {
		if raw == nil {
			continue
		}
		original := raw.(map[string]interface{})
		transformed := make(map[string]interface{})

		transformedImage, err := expandTranscoderJobConfigOverlaysImage(original["image"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedImage); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["image"] = transformedImage
		}

		transformedAnimations, err := expandTranscoderJobConfigOverlaysAnimations(original["animations"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedAnimations); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["animations"] = transformedAnimations
		}

		req = append(req, transformed)
	}
	return req, nil
}

func expandTranscoderJobConfigOverlaysImage(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 || l[0] == nil {
		return nil, nil
	}
	raw := l[0]
	original := raw.(map[string]interface{})
	transformed := make(map[string]interface{})

	transformedUri, err := expandTranscoderJobConfigOverlaysImageUri(original["uri"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedUri); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["uri"] = transformedUri
	}

	return transformed, nil
}

func expandTranscoderJobConfigOverlaysImageUri(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigOverlaysAnimations(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	req := make([]interface{}, 0, len(l))
	for _, raw := range l {
		if raw == nil {
			continue
		}
		original := raw.(map[string]interface{})
		transformed := make(map[string]interface{})

		transformedAnimationFade, err := expandTranscoderJobConfigOverlaysAnimationsAnimationFade(original["animation_fade"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedAnimationFade); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["animationFade"] = transformedAnimationFade
		}

		req = append(req, transformed)
	}
	return req, nil
}

func expandTranscoderJobConfigOverlaysAnimationsAnimationFade(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 || l[0] == nil {
		return nil, nil
	}
	raw := l[0]
	original := raw.(map[string]interface{})
	transformed := make(map[string]interface{})

	transformedXy, err := expandTranscoderJobConfigOverlaysAnimationsAnimationFadeXy(original["xy"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedXy); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["xy"] = transformedXy
	}

	transformedStartTimeOffset, err := expandTranscoderJobConfigOverlaysAnimationsAnimationFadeStartTimeOffset(original["start_time_offset"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedStartTimeOffset); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["startTimeOffset"] = transformedStartTimeOffset
	}

	transformedEndTimeOffset, err := expandTranscoderJobConfigOverlaysAnimationsAnimationFadeEndTimeOffset(original["end_time_offset"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedEndTimeOffset); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["endTimeOffset"] = transformedEndTimeOffset
	}

	transformedFadeType, err := expandTranscoderJobConfigOverlaysAnimationsAnimationFadeFadeType(original["fade_type"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedFadeType); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["fadeType"] = transformedFadeType
	}

	return transformed, nil
}

func expandTranscoderJobConfigOverlaysAnimationsAnimationFadeXy(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 || l[0] == nil {
		return nil, nil
	}
	raw := l[0]
	original := raw.(map[string]interface{})
	transformed := make(map[string]interface{})

	transformedX, err := expandTranscoderJobConfigOverlaysAnimationsAnimationFadeXyX(original["x"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedX); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["x"] = transformedX
	}

	transformedY, err := expandTranscoderJobConfigOverlaysAnimationsAnimationFadeXyY(original["y"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedY); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["y"] = transformedY
	}

	return transformed, nil
}

func expandTranscoderJobConfigOverlaysAnimationsAnimationFadeXyX(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigOverlaysAnimationsAnimationFadeXyY(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigOverlaysAnimationsAnimationFadeStartTimeOffset(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigOverlaysAnimationsAnimationFadeEndTimeOffset(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigOverlaysAnimationsAnimationFadeFadeType(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigEncryptions(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	req := make([]interface{}, 0, len(l))
	for _, raw := range l {
		if raw == nil {
			continue
		}
		original := raw.(map[string]interface{})
		transformed := make(map[string]interface{})

		transformedId, err := expandTranscoderJobConfigEncryptionsId(original["id"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedId); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["id"] = transformedId
		}

		transformedDrmSystems, err := expandTranscoderJobConfigEncryptionsDrmSystems(original["drm_systems"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedDrmSystems); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["drmSystems"] = transformedDrmSystems
		}

		transformedAes128, err := expandTranscoderJobConfigEncryptionsAes128(original["aes128"], d, config)
		if err != nil {
			return nil, err
		} else {
			transformed["aes128"] = transformedAes128
		}

		transformedSampleAes, err := expandTranscoderJobConfigEncryptionsSampleAes(original["sample_aes"], d, config)
		if err != nil {
			return nil, err
		} else {
			transformed["sampleAes"] = transformedSampleAes
		}

		transformedMpegCenc, err := expandTranscoderJobConfigEncryptionsMpegCenc(original["mpeg_cenc"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedMpegCenc); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["mpegCenc"] = transformedMpegCenc
		}

		transformedSecretManagerKeySource, err := expandTranscoderJobConfigEncryptionsSecretManagerKeySource(original["secret_manager_key_source"], d, config)
		if err != nil {
			return nil, err
		} else if val := reflect.ValueOf(transformedSecretManagerKeySource); val.IsValid() && !tpgresource.IsEmptyValue(val) {
			transformed["secretManagerKeySource"] = transformedSecretManagerKeySource
		}

		req = append(req, transformed)
	}
	return req, nil
}

func expandTranscoderJobConfigEncryptionsId(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigEncryptionsDrmSystems(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 || l[0] == nil {
		return nil, nil
	}
	raw := l[0]
	original := raw.(map[string]interface{})
	transformed := make(map[string]interface{})

	transformedWidevine, err := expandTranscoderJobConfigEncryptionsDrmSystemsWidevine(original["widevine"], d, config)
	if err != nil {
		return nil, err
	} else {
		transformed["widevine"] = transformedWidevine
	}

	transformedFairplay, err := expandTranscoderJobConfigEncryptionsDrmSystemsFairplay(original["fairplay"], d, config)
	if err != nil {
		return nil, err
	} else {
		transformed["fairplay"] = transformedFairplay
	}

	transformedPlayready, err := expandTranscoderJobConfigEncryptionsDrmSystemsPlayready(original["playready"], d, config)
	if err != nil {
		return nil, err
	} else {
		transformed["playready"] = transformedPlayready
	}

	transformedClearkey, err := expandTranscoderJobConfigEncryptionsDrmSystemsClearkey(original["clearkey"], d, config)
	if err != nil {
		return nil, err
	} else {
		transformed["clearkey"] = transformedClearkey
	}

	return transformed, nil
}

func expandTranscoderJobConfigEncryptionsDrmSystemsWidevine(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 {
		return nil, nil
	}

	if l[0] == nil {
		transformed := make(map[string]interface{})
		return transformed, nil
	}
	transformed := make(map[string]interface{})

	return transformed, nil
}

func expandTranscoderJobConfigEncryptionsDrmSystemsFairplay(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 {
		return nil, nil
	}

	if l[0] == nil {
		transformed := make(map[string]interface{})
		return transformed, nil
	}
	transformed := make(map[string]interface{})

	return transformed, nil
}

func expandTranscoderJobConfigEncryptionsDrmSystemsPlayready(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 {
		return nil, nil
	}

	if l[0] == nil {
		transformed := make(map[string]interface{})
		return transformed, nil
	}
	transformed := make(map[string]interface{})

	return transformed, nil
}

func expandTranscoderJobConfigEncryptionsDrmSystemsClearkey(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 {
		return nil, nil
	}

	if l[0] == nil {
		transformed := make(map[string]interface{})
		return transformed, nil
	}
	transformed := make(map[string]interface{})

	return transformed, nil
}

func expandTranscoderJobConfigEncryptionsAes128(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 {
		return nil, nil
	}

	if l[0] == nil {
		transformed := make(map[string]interface{})
		return transformed, nil
	}
	transformed := make(map[string]interface{})

	return transformed, nil
}

func expandTranscoderJobConfigEncryptionsSampleAes(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 {
		return nil, nil
	}

	if l[0] == nil {
		transformed := make(map[string]interface{})
		return transformed, nil
	}
	transformed := make(map[string]interface{})

	return transformed, nil
}

func expandTranscoderJobConfigEncryptionsMpegCenc(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 || l[0] == nil {
		return nil, nil
	}
	raw := l[0]
	original := raw.(map[string]interface{})
	transformed := make(map[string]interface{})

	transformedScheme, err := expandTranscoderJobConfigEncryptionsMpegCencScheme(original["scheme"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedScheme); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["scheme"] = transformedScheme
	}

	return transformed, nil
}

func expandTranscoderJobConfigEncryptionsMpegCencScheme(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobConfigEncryptionsSecretManagerKeySource(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	l := v.([]interface{})
	if len(l) == 0 || l[0] == nil {
		return nil, nil
	}
	raw := l[0]
	original := raw.(map[string]interface{})
	transformed := make(map[string]interface{})

	transformedSecretVersion, err := expandTranscoderJobConfigEncryptionsSecretManagerKeySourceSecretVersion(original["secret_version"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedSecretVersion); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["secretVersion"] = transformedSecretVersion
	}

	return transformed, nil
}

func expandTranscoderJobConfigEncryptionsSecretManagerKeySourceSecretVersion(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

func expandTranscoderJobEffectiveLabels(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (map[string]string, error) {
	if v == nil {
		return map[string]string{}, nil
	}
	m := make(map[string]string)
	for k, val := range v.(map[string]interface{}) {
		m[k] = val.(string)
	}
	return m, nil
}