tfplan2cai/converters/google/resources/services/eventarc/eventarc_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/eventarc/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 eventarc

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

func ResourceConverterEventarcPipeline() cai.ResourceConverter {
	return cai.ResourceConverter{
		AssetType: EventarcPipelineAssetType,
		Convert:   GetEventarcPipelineCaiObject,
	}
}

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

func GetEventarcPipelineApiObject(d tpgresource.TerraformResourceData, config *transport_tpg.Config) (map[string]interface{}, error) {
	obj := make(map[string]interface{})
	displayNameProp, err := expandEventarcPipelineDisplayName(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
	}
	cryptoKeyNameProp, err := expandEventarcPipelineCryptoKeyName(d.Get("crypto_key_name"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("crypto_key_name"); !tpgresource.IsEmptyValue(reflect.ValueOf(cryptoKeyNameProp)) && (ok || !reflect.DeepEqual(v, cryptoKeyNameProp)) {
		obj["cryptoKeyName"] = cryptoKeyNameProp
	}
	inputPayloadFormatProp, err := expandEventarcPipelineInputPayloadFormat(d.Get("input_payload_format"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("input_payload_format"); !tpgresource.IsEmptyValue(reflect.ValueOf(inputPayloadFormatProp)) && (ok || !reflect.DeepEqual(v, inputPayloadFormatProp)) {
		obj["inputPayloadFormat"] = inputPayloadFormatProp
	}
	retryPolicyProp, err := expandEventarcPipelineRetryPolicy(d.Get("retry_policy"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("retry_policy"); !tpgresource.IsEmptyValue(reflect.ValueOf(retryPolicyProp)) && (ok || !reflect.DeepEqual(v, retryPolicyProp)) {
		obj["retryPolicy"] = retryPolicyProp
	}
	destinationsProp, err := expandEventarcPipelineDestinations(d.Get("destinations"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("destinations"); !tpgresource.IsEmptyValue(reflect.ValueOf(destinationsProp)) && (ok || !reflect.DeepEqual(v, destinationsProp)) {
		obj["destinations"] = destinationsProp
	}
	mediationsProp, err := expandEventarcPipelineMediations(d.Get("mediations"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("mediations"); !tpgresource.IsEmptyValue(reflect.ValueOf(mediationsProp)) && (ok || !reflect.DeepEqual(v, mediationsProp)) {
		obj["mediations"] = mediationsProp
	}
	loggingConfigProp, err := expandEventarcPipelineLoggingConfig(d.Get("logging_config"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("logging_config"); !tpgresource.IsEmptyValue(reflect.ValueOf(loggingConfigProp)) && (ok || !reflect.DeepEqual(v, loggingConfigProp)) {
		obj["loggingConfig"] = loggingConfigProp
	}
	annotationsProp, err := expandEventarcPipelineEffectiveAnnotations(d.Get("effective_annotations"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("effective_annotations"); !tpgresource.IsEmptyValue(reflect.ValueOf(annotationsProp)) && (ok || !reflect.DeepEqual(v, annotationsProp)) {
		obj["annotations"] = annotationsProp
	}
	labelsProp, err := expandEventarcPipelineEffectiveLabels(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 expandEventarcPipelineDisplayName(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
	return v, nil
}

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

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

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

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

	transformedJson, err := expandEventarcPipelineInputPayloadFormatJson(original["json"], d, config)
	if err != nil {
		return nil, err
	} else {
		transformed["json"] = transformedJson
	}

	return transformed, nil
}

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

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

	return transformed, nil
}

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

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

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

	return transformed, nil
}

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return transformed, nil
}

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

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

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

	return transformed, nil
}

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

	transformedJson, err := expandEventarcPipelineDestinationsOutputPayloadFormatJson(original["json"], d, config)
	if err != nil {
		return nil, err
	} else {
		transformed["json"] = transformedJson
	}

	return transformed, nil
}

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

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

	return transformed, nil
}

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

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

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

	return transformed, nil
}

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

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

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

	return transformed, nil
}

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

func expandEventarcPipelineDestinationsHttpEndpoint(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 := expandEventarcPipelineDestinationsHttpEndpointUri(original["uri"], d, config)
	if err != nil {
		return nil, err
	} else if val := reflect.ValueOf(transformedUri); val.IsValid() && !tpgresource.IsEmptyValue(val) {
		transformed["uri"] = transformedUri
	}

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

	return transformed, nil
}

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

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

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

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

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

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

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

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

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

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

	return transformed, nil
}

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

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

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

	return transformed, nil
}

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

func expandEventarcPipelineEffectiveAnnotations(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 expandEventarcPipelineEffectiveLabels(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
}