tfplan2cai/converters/google/resources/services/datapipeline/datapipeline_pipeline.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/datapipeline/Pipeline.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 datapipeline

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 DataPipelinePipelineAssetType string = "datapipelines.googleapis.com/Pipeline"

func ResourceConverterDataPipelinePipeline() cai.ResourceConverter {
	return cai.ResourceConverter{
		AssetType: DataPipelinePipelineAssetType,
		Convert:   GetDataPipelinePipelineCaiObject,
	}
}

func GetDataPipelinePipelineCaiObject(d tpgresource.TerraformResourceData, config *transport_tpg.Config) ([]cai.Asset, error) {
	name, err := cai.AssetName(d, config, "//datapipelines.googleapis.com/projects/{{project}}/locations/{{region}}/pipelines/{{name}}")
	if err != nil {
		return []cai.Asset{}, err
	}
	if obj, err := GetDataPipelinePipelineApiObject(d, config); err == nil {
		return []cai.Asset{{
			Name: name,
			Type: DataPipelinePipelineAssetType,
			Resource: &cai.AssetResource{
				Version:              "v1",
				DiscoveryDocumentURI: "https://www.googleapis.com/discovery/v1/apis/datapipelines/v1/rest",
				DiscoveryName:        "Pipeline",
				Data:                 obj,
			},
		}}, nil
	} else {
		return []cai.Asset{}, err
	}
}

func GetDataPipelinePipelineApiObject(d tpgresource.TerraformResourceData, config *transport_tpg.Config) (map[string]interface{}, error) {
	obj := make(map[string]interface{})
	nameProp, err := expandDataPipelinePipelineName(d.Get("name"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("name"); !tpgresource.IsEmptyValue(reflect.ValueOf(nameProp)) && (ok || !reflect.DeepEqual(v, nameProp)) {
		obj["name"] = nameProp
	}
	displayNameProp, err := expandDataPipelinePipelineDisplayName(d.Get("display_name"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("display_name"); !tpgresource.IsEmptyValue(reflect.ValueOf(displayNameProp)) && (ok || !reflect.DeepEqual(v, displayNameProp)) {
		obj["displayName"] = displayNameProp
	}
	typeProp, err := expandDataPipelinePipelineType(d.Get("type"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("type"); !tpgresource.IsEmptyValue(reflect.ValueOf(typeProp)) && (ok || !reflect.DeepEqual(v, typeProp)) {
		obj["type"] = typeProp
	}
	stateProp, err := expandDataPipelinePipelineState(d.Get("state"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("state"); !tpgresource.IsEmptyValue(reflect.ValueOf(stateProp)) && (ok || !reflect.DeepEqual(v, stateProp)) {
		obj["state"] = stateProp
	}
	workloadProp, err := expandDataPipelinePipelineWorkload(d.Get("workload"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("workload"); !tpgresource.IsEmptyValue(reflect.ValueOf(workloadProp)) && (ok || !reflect.DeepEqual(v, workloadProp)) {
		obj["workload"] = workloadProp
	}
	scheduleInfoProp, err := expandDataPipelinePipelineScheduleInfo(d.Get("schedule_info"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("schedule_info"); !tpgresource.IsEmptyValue(reflect.ValueOf(scheduleInfoProp)) && (ok || !reflect.DeepEqual(v, scheduleInfoProp)) {
		obj["scheduleInfo"] = scheduleInfoProp
	}
	schedulerServiceAccountEmailProp, err := expandDataPipelinePipelineSchedulerServiceAccountEmail(d.Get("scheduler_service_account_email"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("scheduler_service_account_email"); !tpgresource.IsEmptyValue(reflect.ValueOf(schedulerServiceAccountEmailProp)) && (ok || !reflect.DeepEqual(v, schedulerServiceAccountEmailProp)) {
		obj["schedulerServiceAccountEmail"] = schedulerServiceAccountEmailProp
	}
	pipelineSourcesProp, err := expandDataPipelinePipelinePipelineSources(d.Get("pipeline_sources"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("pipeline_sources"); !tpgresource.IsEmptyValue(reflect.ValueOf(pipelineSourcesProp)) && (ok || !reflect.DeepEqual(v, pipelineSourcesProp)) {
		obj["pipelineSources"] = pipelineSourcesProp
	}

	return obj, nil
}

func expandDataPipelinePipelineName(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return tpgresource.ReplaceVars(d, config, "projects/{{project}}/locations/{{region}}/pipelines/{{name}}")
}

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

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

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

func expandDataPipelinePipelineWorkload(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{})

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

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

	return transformed, nil
}

func expandDataPipelinePipelineWorkloadDataflowLaunchTemplateRequest(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{})

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

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

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

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

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

	return transformed, nil
}

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

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

func expandDataPipelinePipelineWorkloadDataflowLaunchTemplateRequestLaunchParameters(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{})

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

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

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

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

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

	return transformed, nil
}

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

func expandDataPipelinePipelineWorkloadDataflowLaunchTemplateRequestLaunchParametersParameters(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
}

func expandDataPipelinePipelineWorkloadDataflowLaunchTemplateRequestLaunchParametersEnvironment(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{})

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

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

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

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

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

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

func expandDataPipelinePipelineWorkloadDataflowLaunchTemplateRequestLaunchParametersEnvironmentAdditionalUserLabels(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
}

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

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

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

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

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

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

func expandDataPipelinePipelineWorkloadDataflowLaunchTemplateRequestLaunchParametersTransformNameMapping(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
}

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

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

func expandDataPipelinePipelineWorkloadDataflowFlexTemplateRequest(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{})

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

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

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

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

	return transformed, nil
}

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

func expandDataPipelinePipelineWorkloadDataflowFlexTemplateRequestLaunchParameter(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{})

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

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

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

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

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

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

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

	return transformed, nil
}

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

func expandDataPipelinePipelineWorkloadDataflowFlexTemplateRequestLaunchParameterParameters(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
}

func expandDataPipelinePipelineWorkloadDataflowFlexTemplateRequestLaunchParameterLaunchOptions(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
}

func expandDataPipelinePipelineWorkloadDataflowFlexTemplateRequestLaunchParameterEnvironment(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{})

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

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

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

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

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

func expandDataPipelinePipelineWorkloadDataflowFlexTemplateRequestLaunchParameterEnvironmentAdditionalUserLabels(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
}

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

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

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

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

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

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

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

func expandDataPipelinePipelineWorkloadDataflowFlexTemplateRequestLaunchParameterTransformNameMappings(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
}

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

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

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

func expandDataPipelinePipelineScheduleInfo(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{})

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

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

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

	return transformed, nil
}

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

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

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

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

func expandDataPipelinePipelinePipelineSources(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
}