v6.2.0/google-beta/services/migrationcenter/resource_migration_center_preference_set.go

// Copyright (c) HashiCorp, Inc.
// SPDX-License-Identifier: MPL-2.0

// ----------------------------------------------------------------------------
//
//     ***     AUTO GENERATED CODE    ***    Type: MMv1     ***
//
// ----------------------------------------------------------------------------
//
//     This file is automatically generated by Magic Modules and manual
//     changes will be clobbered when the file is regenerated.
//
//     Please read more about how to change this file in
//     .github/CONTRIBUTING.md.
//
// ----------------------------------------------------------------------------

package migrationcenter

import (
	"fmt"
	"log"
	"net/http"
	"reflect"
	"strings"
	"time"

	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/customdiff"
	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"

	"github.com/hashicorp/terraform-provider-google-beta/google-beta/tpgresource"
	transport_tpg "github.com/hashicorp/terraform-provider-google-beta/google-beta/transport"
)

func ResourceMigrationCenterPreferenceSet() *schema.Resource {
	return &schema.Resource{
		Create: resourceMigrationCenterPreferenceSetCreate,
		Read:   resourceMigrationCenterPreferenceSetRead,
		Update: resourceMigrationCenterPreferenceSetUpdate,
		Delete: resourceMigrationCenterPreferenceSetDelete,

		Importer: &schema.ResourceImporter{
			State: resourceMigrationCenterPreferenceSetImport,
		},

		Timeouts: &schema.ResourceTimeout{
			Create: schema.DefaultTimeout(20 * time.Minute),
			Update: schema.DefaultTimeout(20 * time.Minute),
			Delete: schema.DefaultTimeout(20 * time.Minute),
		},

		CustomizeDiff: customdiff.All(
			tpgresource.DefaultProviderProject,
		),

		Schema: map[string]*schema.Schema{
			"location": {
				Type:        schema.TypeString,
				Required:    true,
				ForceNew:    true,
				Description: `Part of 'parent'. See documentation of 'projectsId'.`,
			},
			"preference_set_id": {
				Type:        schema.TypeString,
				Required:    true,
				ForceNew:    true,
				Description: `Required. User specified ID for the preference set. It will become the last component of the preference set name. The ID must be unique within the project, must conform with RFC-1034, is restricted to lower-cased letters, and has a maximum length of 63 characters. The ID must match the regular expression '[a-z]([a-z0-9-]{0,61}[a-z0-9])?'.`,
			},
			"description": {
				Type:        schema.TypeString,
				Optional:    true,
				Description: `A description of the preference set.`,
			},
			"display_name": {
				Type:        schema.TypeString,
				Optional:    true,
				Description: `User-friendly display name. Maximum length is 63 characters.`,
			},
			"virtual_machine_preferences": {
				Type:        schema.TypeList,
				Optional:    true,
				Description: `VirtualMachinePreferences enables you to create sets of assumptions, for example, a geographical location and pricing track, for your migrated virtual machines. The set of preferences influence recommendations for migrating virtual machine assets.`,
				MaxItems:    1,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"commitment_plan": {
							Type:        schema.TypeString,
							Optional:    true,
							Description: `Commitment plan to consider when calculating costs for virtual machine insights and recommendations. If you are unsure which value to set, a 3 year commitment plan is often a good value to start with. Possible values: 'COMMITMENT_PLAN_UNSPECIFIED', 'COMMITMENT_PLAN_NONE', 'COMMITMENT_PLAN_ONE_YEAR', 'COMMITMENT_PLAN_THREE_YEARS'`,
						},
						"compute_engine_preferences": {
							Type:        schema.TypeList,
							Optional:    true,
							Description: `The user preferences relating to Compute Engine target platform.`,
							MaxItems:    1,
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									"license_type": {
										Type:        schema.TypeString,
										Optional:    true,
										Description: `License type to consider when calculating costs for virtual machine insights and recommendations. If unspecified, costs are calculated based on the default licensing plan. Possible values: 'LICENSE_TYPE_UNSPECIFIED', 'LICENSE_TYPE_DEFAULT', 'LICENSE_TYPE_BRING_YOUR_OWN_LICENSE'`,
									},
									"machine_preferences": {
										Type:        schema.TypeList,
										Optional:    true,
										Description: `The type of machines to consider when calculating virtual machine migration insights and recommendations. Not all machine types are available in all zones and regions.`,
										MaxItems:    1,
										Elem: &schema.Resource{
											Schema: map[string]*schema.Schema{
												"allowed_machine_series": {
													Type:        schema.TypeList,
													Optional:    true,
													Description: `Compute Engine machine series to consider for insights and recommendations. If empty, no restriction is applied on the machine series.`,
													Elem: &schema.Resource{
														Schema: map[string]*schema.Schema{
															"code": {
																Type:        schema.TypeString,
																Optional:    true,
																Description: `Code to identify a Compute Engine machine series. Consult https://cloud.google.com/compute/docs/machine-resource#machine_type_comparison for more details on the available series.`,
															},
														},
													},
												},
											},
										},
									},
								},
							},
						},
						"region_preferences": {
							Type:        schema.TypeList,
							Optional:    true,
							Description: `The user preferences relating to target regions.`,
							MaxItems:    1,
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									"preferred_regions": {
										Type:        schema.TypeList,
										Optional:    true,
										Description: `A list of preferred regions, ordered by the most preferred region first. Set only valid Google Cloud region names. See https://cloud.google.com/compute/docs/regions-zones for available regions.`,
										Elem: &schema.Schema{
											Type: schema.TypeString,
										},
									},
								},
							},
						},
						"sizing_optimization_strategy": {
							Type:        schema.TypeString,
							Optional:    true,
							Description: `Sizing optimization strategy specifies the preferred strategy used when extrapolating usage data to calculate insights and recommendations for a virtual machine. If you are unsure which value to set, a moderate sizing optimization strategy is often a good value to start with. Possible values: 'SIZING_OPTIMIZATION_STRATEGY_UNSPECIFIED', 'SIZING_OPTIMIZATION_STRATEGY_SAME_AS_SOURCE', 'SIZING_OPTIMIZATION_STRATEGY_MODERATE', 'SIZING_OPTIMIZATION_STRATEGY_AGGRESSIVE'`,
						},
						"sole_tenancy_preferences": {
							Type:        schema.TypeList,
							Optional:    true,
							Description: `Preferences concerning Sole Tenancy nodes and VMs.`,
							MaxItems:    1,
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									"commitment_plan": {
										Type:        schema.TypeString,
										Optional:    true,
										Description: `Commitment plan to consider when calculating costs for virtual machine insights and recommendations. If you are unsure which value to set, a 3 year commitment plan is often a good value to start with. Possible values: 'COMMITMENT_PLAN_UNSPECIFIED', 'ON_DEMAND', 'COMMITMENT_1_YEAR', 'COMMITMENT_3_YEAR'`,
									},
									"cpu_overcommit_ratio": {
										Type:        schema.TypeFloat,
										Optional:    true,
										Description: `CPU overcommit ratio. Acceptable values are between 1.0 and 2.0 inclusive.`,
									},
									"host_maintenance_policy": {
										Type:        schema.TypeString,
										Optional:    true,
										Description: `Sole Tenancy nodes maintenance policy. Possible values: 'HOST_MAINTENANCE_POLICY_UNSPECIFIED', 'HOST_MAINTENANCE_POLICY_DEFAULT', 'HOST_MAINTENANCE_POLICY_RESTART_IN_PLACE', 'HOST_MAINTENANCE_POLICY_MIGRATE_WITHIN_NODE_GROUP'`,
									},
									"node_types": {
										Type:        schema.TypeList,
										Optional:    true,
										Description: `A list of sole tenant node types. An empty list means that all possible node types will be considered.`,
										Elem: &schema.Resource{
											Schema: map[string]*schema.Schema{
												"node_name": {
													Type:        schema.TypeString,
													Optional:    true,
													Description: `Name of the Sole Tenant node. Consult https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes`,
												},
											},
										},
									},
								},
							},
						},
						"target_product": {
							Type:        schema.TypeString,
							Optional:    true,
							Description: `Target product for assets using this preference set. Specify either target product or business goal, but not both. Possible values: 'COMPUTE_MIGRATION_TARGET_PRODUCT_UNSPECIFIED', 'COMPUTE_MIGRATION_TARGET_PRODUCT_COMPUTE_ENGINE', 'COMPUTE_MIGRATION_TARGET_PRODUCT_VMWARE_ENGINE', 'COMPUTE_MIGRATION_TARGET_PRODUCT_SOLE_TENANCY'`,
						},
						"vmware_engine_preferences": {
							Type:        schema.TypeList,
							Optional:    true,
							Description: `The user preferences relating to Google Cloud VMware Engine target platform.`,
							MaxItems:    1,
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									"commitment_plan": {
										Type:        schema.TypeString,
										Optional:    true,
										Description: `Commitment plan to consider when calculating costs for virtual machine insights and recommendations. If you are unsure which value to set, a 3 year commitment plan is often a good value to start with. Possible values: 'COMMITMENT_PLAN_UNSPECIFIED', 'ON_DEMAND', 'COMMITMENT_1_YEAR_MONTHLY_PAYMENTS', 'COMMITMENT_3_YEAR_MONTHLY_PAYMENTS', 'COMMITMENT_1_YEAR_UPFRONT_PAYMENT', 'COMMITMENT_3_YEAR_UPFRONT_PAYMENT',`,
									},
									"cpu_overcommit_ratio": {
										Type:        schema.TypeFloat,
										Optional:    true,
										Description: `CPU overcommit ratio. Acceptable values are between 1.0 and 8.0, with 0.1 increment.`,
									},
									"memory_overcommit_ratio": {
										Type:        schema.TypeFloat,
										Optional:    true,
										Description: `Memory overcommit ratio. Acceptable values are 1.0, 1.25, 1.5, 1.75 and 2.0.`,
									},
									"storage_deduplication_compression_ratio": {
										Type:        schema.TypeFloat,
										Optional:    true,
										Description: `The Deduplication and Compression ratio is based on the logical (Used Before) space required to store data before applying deduplication and compression, in relation to the physical (Used After) space required after applying deduplication and compression. Specifically, the ratio is the Used Before space divided by the Used After space. For example, if the Used Before space is 3 GB, but the physical Used After space is 1 GB, the deduplication and compression ratio is 3x. Acceptable values are between 1.0 and 4.0.`,
									},
								},
							},
						},
					},
				},
			},
			"create_time": {
				Type:        schema.TypeString,
				Computed:    true,
				Description: `Output only. The timestamp when the preference set was created.`,
			},
			"name": {
				Type:        schema.TypeString,
				Computed:    true,
				Description: `Output only. Name of the preference set.`,
			},
			"update_time": {
				Type:        schema.TypeString,
				Computed:    true,
				Description: `Output only. The timestamp when the preference set was last updated.`,
			},
			"project": {
				Type:     schema.TypeString,
				Optional: true,
				Computed: true,
				ForceNew: true,
			},
		},
		UseJSONNumber: true,
	}
}

func resourceMigrationCenterPreferenceSetCreate(d *schema.ResourceData, meta interface{}) error {
	config := meta.(*transport_tpg.Config)
	userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent)
	if err != nil {
		return err
	}

	obj := make(map[string]interface{})
	displayNameProp, err := expandMigrationCenterPreferenceSetDisplayName(d.Get("display_name"), d, config)
	if err != nil {
		return err
	} else if v, ok := d.GetOkExists("display_name"); !tpgresource.IsEmptyValue(reflect.ValueOf(displayNameProp)) && (ok || !reflect.DeepEqual(v, displayNameProp)) {
		obj["displayName"] = displayNameProp
	}
	descriptionProp, err := expandMigrationCenterPreferenceSetDescription(d.Get("description"), d, config)
	if err != nil {
		return err
	} else if v, ok := d.GetOkExists("description"); !tpgresource.IsEmptyValue(reflect.ValueOf(descriptionProp)) && (ok || !reflect.DeepEqual(v, descriptionProp)) {
		obj["description"] = descriptionProp
	}
	virtualMachinePreferencesProp, err := expandMigrationCenterPreferenceSetVirtualMachinePreferences(d.Get("virtual_machine_preferences"), d, config)
	if err != nil {
		return err
	} else if v, ok := d.GetOkExists("virtual_machine_preferences"); !tpgresource.IsEmptyValue(reflect.ValueOf(virtualMachinePreferencesProp)) && (ok || !reflect.DeepEqual(v, virtualMachinePreferencesProp)) {
		obj["virtualMachinePreferences"] = virtualMachinePreferencesProp
	}

	url, err := tpgresource.ReplaceVars(d, config, "{{MigrationCenterBasePath}}projects/{{project}}/locations/{{location}}/preferenceSets?preferenceSetId={{preference_set_id}}")
	if err != nil {
		return err
	}

	log.Printf("[DEBUG] Creating new PreferenceSet: %#v", obj)
	billingProject := ""

	project, err := tpgresource.GetProject(d, config)
	if err != nil {
		return fmt.Errorf("Error fetching project for PreferenceSet: %s", err)
	}
	billingProject = project

	// err == nil indicates that the billing_project value was found
	if bp, err := tpgresource.GetBillingProject(d, config); err == nil {
		billingProject = bp
	}

	headers := make(http.Header)
	res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{
		Config:    config,
		Method:    "POST",
		Project:   billingProject,
		RawURL:    url,
		UserAgent: userAgent,
		Body:      obj,
		Timeout:   d.Timeout(schema.TimeoutCreate),
		Headers:   headers,
	})
	if err != nil {
		return fmt.Errorf("Error creating PreferenceSet: %s", err)
	}

	// Store the ID now
	id, err := tpgresource.ReplaceVars(d, config, "projects/{{project}}/locations/{{location}}/preferenceSets/{{preference_set_id}}")
	if err != nil {
		return fmt.Errorf("Error constructing id: %s", err)
	}
	d.SetId(id)

	// Use the resource in the operation response to populate
	// identity fields and d.Id() before read
	var opRes map[string]interface{}
	err = MigrationCenterOperationWaitTimeWithResponse(
		config, res, &opRes, project, "Creating PreferenceSet", userAgent,
		d.Timeout(schema.TimeoutCreate))
	if err != nil {
		// The resource didn't actually create
		d.SetId("")

		return fmt.Errorf("Error waiting to create PreferenceSet: %s", err)
	}

	if err := d.Set("name", flattenMigrationCenterPreferenceSetName(opRes["name"], d, config)); err != nil {
		return err
	}

	// This may have caused the ID to update - update it if so.
	id, err = tpgresource.ReplaceVars(d, config, "projects/{{project}}/locations/{{location}}/preferenceSets/{{preference_set_id}}")
	if err != nil {
		return fmt.Errorf("Error constructing id: %s", err)
	}
	d.SetId(id)

	log.Printf("[DEBUG] Finished creating PreferenceSet %q: %#v", d.Id(), res)

	return resourceMigrationCenterPreferenceSetRead(d, meta)
}

func resourceMigrationCenterPreferenceSetRead(d *schema.ResourceData, meta interface{}) error {
	config := meta.(*transport_tpg.Config)
	userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent)
	if err != nil {
		return err
	}

	url, err := tpgresource.ReplaceVars(d, config, "{{MigrationCenterBasePath}}projects/{{project}}/locations/{{location}}/preferenceSets/{{preference_set_id}}")
	if err != nil {
		return err
	}

	billingProject := ""

	project, err := tpgresource.GetProject(d, config)
	if err != nil {
		return fmt.Errorf("Error fetching project for PreferenceSet: %s", err)
	}
	billingProject = project

	// err == nil indicates that the billing_project value was found
	if bp, err := tpgresource.GetBillingProject(d, config); err == nil {
		billingProject = bp
	}

	headers := make(http.Header)
	res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{
		Config:    config,
		Method:    "GET",
		Project:   billingProject,
		RawURL:    url,
		UserAgent: userAgent,
		Headers:   headers,
	})
	if err != nil {
		return transport_tpg.HandleNotFoundError(err, d, fmt.Sprintf("MigrationCenterPreferenceSet %q", d.Id()))
	}

	if err := d.Set("project", project); err != nil {
		return fmt.Errorf("Error reading PreferenceSet: %s", err)
	}

	if err := d.Set("name", flattenMigrationCenterPreferenceSetName(res["name"], d, config)); err != nil {
		return fmt.Errorf("Error reading PreferenceSet: %s", err)
	}
	if err := d.Set("create_time", flattenMigrationCenterPreferenceSetCreateTime(res["createTime"], d, config)); err != nil {
		return fmt.Errorf("Error reading PreferenceSet: %s", err)
	}
	if err := d.Set("update_time", flattenMigrationCenterPreferenceSetUpdateTime(res["updateTime"], d, config)); err != nil {
		return fmt.Errorf("Error reading PreferenceSet: %s", err)
	}
	if err := d.Set("display_name", flattenMigrationCenterPreferenceSetDisplayName(res["displayName"], d, config)); err != nil {
		return fmt.Errorf("Error reading PreferenceSet: %s", err)
	}
	if err := d.Set("description", flattenMigrationCenterPreferenceSetDescription(res["description"], d, config)); err != nil {
		return fmt.Errorf("Error reading PreferenceSet: %s", err)
	}
	if err := d.Set("virtual_machine_preferences", flattenMigrationCenterPreferenceSetVirtualMachinePreferences(res["virtualMachinePreferences"], d, config)); err != nil {
		return fmt.Errorf("Error reading PreferenceSet: %s", err)
	}

	return nil
}

func resourceMigrationCenterPreferenceSetUpdate(d *schema.ResourceData, meta interface{}) error {
	config := meta.(*transport_tpg.Config)
	userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent)
	if err != nil {
		return err
	}

	billingProject := ""

	project, err := tpgresource.GetProject(d, config)
	if err != nil {
		return fmt.Errorf("Error fetching project for PreferenceSet: %s", err)
	}
	billingProject = project

	obj := make(map[string]interface{})
	displayNameProp, err := expandMigrationCenterPreferenceSetDisplayName(d.Get("display_name"), d, config)
	if err != nil {
		return err
	} else if v, ok := d.GetOkExists("display_name"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, displayNameProp)) {
		obj["displayName"] = displayNameProp
	}
	descriptionProp, err := expandMigrationCenterPreferenceSetDescription(d.Get("description"), d, config)
	if err != nil {
		return err
	} else if v, ok := d.GetOkExists("description"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, descriptionProp)) {
		obj["description"] = descriptionProp
	}
	virtualMachinePreferencesProp, err := expandMigrationCenterPreferenceSetVirtualMachinePreferences(d.Get("virtual_machine_preferences"), d, config)
	if err != nil {
		return err
	} else if v, ok := d.GetOkExists("virtual_machine_preferences"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, virtualMachinePreferencesProp)) {
		obj["virtualMachinePreferences"] = virtualMachinePreferencesProp
	}

	url, err := tpgresource.ReplaceVars(d, config, "{{MigrationCenterBasePath}}projects/{{project}}/locations/{{location}}/preferenceSets/{{preference_set_id}}")
	if err != nil {
		return err
	}

	log.Printf("[DEBUG] Updating PreferenceSet %q: %#v", d.Id(), obj)
	headers := make(http.Header)
	updateMask := []string{}

	if d.HasChange("display_name") {
		updateMask = append(updateMask, "displayName")
	}

	if d.HasChange("description") {
		updateMask = append(updateMask, "description")
	}

	if d.HasChange("virtual_machine_preferences") {
		updateMask = append(updateMask, "virtualMachinePreferences")
	}
	// updateMask is a URL parameter but not present in the schema, so ReplaceVars
	// won't set it
	url, err = transport_tpg.AddQueryParams(url, map[string]string{"updateMask": strings.Join(updateMask, ",")})
	if err != nil {
		return err
	}

	// err == nil indicates that the billing_project value was found
	if bp, err := tpgresource.GetBillingProject(d, config); err == nil {
		billingProject = bp
	}

	// if updateMask is empty we are not updating anything so skip the post
	if len(updateMask) > 0 {
		res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{
			Config:    config,
			Method:    "PATCH",
			Project:   billingProject,
			RawURL:    url,
			UserAgent: userAgent,
			Body:      obj,
			Timeout:   d.Timeout(schema.TimeoutUpdate),
			Headers:   headers,
		})

		if err != nil {
			return fmt.Errorf("Error updating PreferenceSet %q: %s", d.Id(), err)
		} else {
			log.Printf("[DEBUG] Finished updating PreferenceSet %q: %#v", d.Id(), res)
		}

		err = MigrationCenterOperationWaitTime(
			config, res, project, "Updating PreferenceSet", userAgent,
			d.Timeout(schema.TimeoutUpdate))

		if err != nil {
			return err
		}
	}

	return resourceMigrationCenterPreferenceSetRead(d, meta)
}

func resourceMigrationCenterPreferenceSetDelete(d *schema.ResourceData, meta interface{}) error {
	config := meta.(*transport_tpg.Config)
	userAgent, err := tpgresource.GenerateUserAgentString(d, config.UserAgent)
	if err != nil {
		return err
	}

	billingProject := ""

	project, err := tpgresource.GetProject(d, config)
	if err != nil {
		return fmt.Errorf("Error fetching project for PreferenceSet: %s", err)
	}
	billingProject = project

	url, err := tpgresource.ReplaceVars(d, config, "{{MigrationCenterBasePath}}projects/{{project}}/locations/{{location}}/preferenceSets/{{preference_set_id}}")
	if err != nil {
		return err
	}

	var obj map[string]interface{}

	// err == nil indicates that the billing_project value was found
	if bp, err := tpgresource.GetBillingProject(d, config); err == nil {
		billingProject = bp
	}

	headers := make(http.Header)

	log.Printf("[DEBUG] Deleting PreferenceSet %q", d.Id())
	res, err := transport_tpg.SendRequest(transport_tpg.SendRequestOptions{
		Config:    config,
		Method:    "DELETE",
		Project:   billingProject,
		RawURL:    url,
		UserAgent: userAgent,
		Body:      obj,
		Timeout:   d.Timeout(schema.TimeoutDelete),
		Headers:   headers,
	})
	if err != nil {
		return transport_tpg.HandleNotFoundError(err, d, "PreferenceSet")
	}

	err = MigrationCenterOperationWaitTime(
		config, res, project, "Deleting PreferenceSet", userAgent,
		d.Timeout(schema.TimeoutDelete))

	if err != nil {
		return err
	}

	log.Printf("[DEBUG] Finished deleting PreferenceSet %q: %#v", d.Id(), res)
	return nil
}

func resourceMigrationCenterPreferenceSetImport(d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) {
	config := meta.(*transport_tpg.Config)
	if err := tpgresource.ParseImportId([]string{
		"^projects/(?P<project>[^/]+)/locations/(?P<location>[^/]+)/preferenceSets/(?P<preference_set_id>[^/]+)$",
		"^(?P<project>[^/]+)/(?P<location>[^/]+)/(?P<preference_set_id>[^/]+)$",
		"^(?P<location>[^/]+)/(?P<preference_set_id>[^/]+)$",
	}, d, config); err != nil {
		return nil, err
	}

	// Replace import id for the resource id
	id, err := tpgresource.ReplaceVars(d, config, "projects/{{project}}/locations/{{location}}/preferenceSets/{{preference_set_id}}")
	if err != nil {
		return nil, fmt.Errorf("Error constructing id: %s", err)
	}
	d.SetId(id)

	return []*schema.ResourceData{d}, nil
}

func flattenMigrationCenterPreferenceSetName(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetCreateTime(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetUpdateTime(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetDisplayName(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetDescription(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetVirtualMachinePreferences(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	if v == nil {
		return nil
	}
	original := v.(map[string]interface{})
	if len(original) == 0 {
		return nil
	}
	transformed := make(map[string]interface{})
	transformed["target_product"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesTargetProduct(original["targetProduct"], d, config)
	transformed["region_preferences"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesRegionPreferences(original["regionPreferences"], d, config)
	transformed["commitment_plan"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesCommitmentPlan(original["commitmentPlan"], d, config)
	transformed["sizing_optimization_strategy"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesSizingOptimizationStrategy(original["sizingOptimizationStrategy"], d, config)
	transformed["compute_engine_preferences"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesComputeEnginePreferences(original["computeEnginePreferences"], d, config)
	transformed["vmware_engine_preferences"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesVmwareEnginePreferences(original["vmwareEnginePreferences"], d, config)
	transformed["sole_tenancy_preferences"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesSoleTenancyPreferences(original["soleTenancyPreferences"], d, config)
	return []interface{}{transformed}
}
func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesTargetProduct(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesRegionPreferences(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	if v == nil {
		return nil
	}
	original := v.(map[string]interface{})
	if len(original) == 0 {
		return nil
	}
	transformed := make(map[string]interface{})
	transformed["preferred_regions"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesRegionPreferencesPreferredRegions(original["preferredRegions"], d, config)
	return []interface{}{transformed}
}
func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesRegionPreferencesPreferredRegions(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesCommitmentPlan(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesSizingOptimizationStrategy(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesComputeEnginePreferences(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	if v == nil {
		return nil
	}
	original := v.(map[string]interface{})
	if len(original) == 0 {
		return nil
	}
	transformed := make(map[string]interface{})
	transformed["machine_preferences"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesComputeEnginePreferencesMachinePreferences(original["machinePreferences"], d, config)
	transformed["license_type"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesComputeEnginePreferencesLicenseType(original["licenseType"], d, config)
	return []interface{}{transformed}
}
func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesComputeEnginePreferencesMachinePreferences(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	if v == nil {
		return nil
	}
	original := v.(map[string]interface{})
	if len(original) == 0 {
		return nil
	}
	transformed := make(map[string]interface{})
	transformed["allowed_machine_series"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesComputeEnginePreferencesMachinePreferencesAllowedMachineSeries(original["allowedMachineSeries"], d, config)
	return []interface{}{transformed}
}
func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesComputeEnginePreferencesMachinePreferencesAllowedMachineSeries(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	if v == nil {
		return v
	}
	l := v.([]interface{})
	transformed := make([]interface{}, 0, len(l))
	for _, raw := range l {
		original := raw.(map[string]interface{})
		if len(original) < 1 {
			// Do not include empty json objects coming back from the api
			continue
		}
		transformed = append(transformed, map[string]interface{}{
			"code": flattenMigrationCenterPreferenceSetVirtualMachinePreferencesComputeEnginePreferencesMachinePreferencesAllowedMachineSeriesCode(original["code"], d, config),
		})
	}
	return transformed
}
func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesComputeEnginePreferencesMachinePreferencesAllowedMachineSeriesCode(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesComputeEnginePreferencesLicenseType(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesVmwareEnginePreferences(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	if v == nil {
		return nil
	}
	original := v.(map[string]interface{})
	if len(original) == 0 {
		return nil
	}
	transformed := make(map[string]interface{})
	transformed["cpu_overcommit_ratio"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesVmwareEnginePreferencesCpuOvercommitRatio(original["cpuOvercommitRatio"], d, config)
	transformed["memory_overcommit_ratio"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesVmwareEnginePreferencesMemoryOvercommitRatio(original["memoryOvercommitRatio"], d, config)
	transformed["storage_deduplication_compression_ratio"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesVmwareEnginePreferencesStorageDeduplicationCompressionRatio(original["storageDeduplicationCompressionRatio"], d, config)
	transformed["commitment_plan"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesVmwareEnginePreferencesCommitmentPlan(original["commitmentPlan"], d, config)
	return []interface{}{transformed}
}
func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesVmwareEnginePreferencesCpuOvercommitRatio(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesVmwareEnginePreferencesMemoryOvercommitRatio(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesVmwareEnginePreferencesStorageDeduplicationCompressionRatio(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesVmwareEnginePreferencesCommitmentPlan(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesSoleTenancyPreferences(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	if v == nil {
		return nil
	}
	original := v.(map[string]interface{})
	if len(original) == 0 {
		return nil
	}
	transformed := make(map[string]interface{})
	transformed["cpu_overcommit_ratio"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesSoleTenancyPreferencesCpuOvercommitRatio(original["cpuOvercommitRatio"], d, config)
	transformed["host_maintenance_policy"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesSoleTenancyPreferencesHostMaintenancePolicy(original["hostMaintenancePolicy"], d, config)
	transformed["commitment_plan"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesSoleTenancyPreferencesCommitmentPlan(original["commitmentPlan"], d, config)
	transformed["node_types"] =
		flattenMigrationCenterPreferenceSetVirtualMachinePreferencesSoleTenancyPreferencesNodeTypes(original["nodeTypes"], d, config)
	return []interface{}{transformed}
}
func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesSoleTenancyPreferencesCpuOvercommitRatio(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesSoleTenancyPreferencesHostMaintenancePolicy(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesSoleTenancyPreferencesCommitmentPlan(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesSoleTenancyPreferencesNodeTypes(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	if v == nil {
		return v
	}
	l := v.([]interface{})
	transformed := make([]interface{}, 0, len(l))
	for _, raw := range l {
		original := raw.(map[string]interface{})
		if len(original) < 1 {
			// Do not include empty json objects coming back from the api
			continue
		}
		transformed = append(transformed, map[string]interface{}{
			"node_name": flattenMigrationCenterPreferenceSetVirtualMachinePreferencesSoleTenancyPreferencesNodeTypesNodeName(original["nodeName"], d, config),
		})
	}
	return transformed
}
func flattenMigrationCenterPreferenceSetVirtualMachinePreferencesSoleTenancyPreferencesNodeTypesNodeName(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
	return v
}

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

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

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

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

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

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

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

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

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

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

	return transformed, nil
}

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

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

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

	return transformed, nil
}

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

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

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

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

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

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

	return transformed, nil
}

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

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

	return transformed, nil
}

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

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

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

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

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

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

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

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