tfplan2cai/converters/google/resources/services/developerconnect/developerconnect_connection.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/developerconnect/Connection.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 developerconnect

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 DeveloperConnectConnectionAssetType string = "developerconnect.googleapis.com/Connection"

func ResourceConverterDeveloperConnectConnection() cai.ResourceConverter {
	return cai.ResourceConverter{
		AssetType: DeveloperConnectConnectionAssetType,
		Convert:   GetDeveloperConnectConnectionCaiObject,
	}
}

func GetDeveloperConnectConnectionCaiObject(d tpgresource.TerraformResourceData, config *transport_tpg.Config) ([]cai.Asset, error) {
	name, err := cai.AssetName(d, config, "//developerconnect.googleapis.com/projects/{{project}}/locations/{{location}}/connections/{{connection_id}}")
	if err != nil {
		return []cai.Asset{}, err
	}
	if obj, err := GetDeveloperConnectConnectionApiObject(d, config); err == nil {
		return []cai.Asset{{
			Name: name,
			Type: DeveloperConnectConnectionAssetType,
			Resource: &cai.AssetResource{
				Version:              "v1",
				DiscoveryDocumentURI: "https://www.googleapis.com/discovery/v1/apis/developerconnect/v1/rest",
				DiscoveryName:        "Connection",
				Data:                 obj,
			},
		}}, nil
	} else {
		return []cai.Asset{}, err
	}
}

func GetDeveloperConnectConnectionApiObject(d tpgresource.TerraformResourceData, config *transport_tpg.Config) (map[string]interface{}, error) {
	obj := make(map[string]interface{})
	githubConfigProp, err := expandDeveloperConnectConnectionGithubConfig(d.Get("github_config"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("github_config"); !tpgresource.IsEmptyValue(reflect.ValueOf(githubConfigProp)) && (ok || !reflect.DeepEqual(v, githubConfigProp)) {
		obj["githubConfig"] = githubConfigProp
	}
	githubEnterpriseConfigProp, err := expandDeveloperConnectConnectionGithubEnterpriseConfig(d.Get("github_enterprise_config"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("github_enterprise_config"); !tpgresource.IsEmptyValue(reflect.ValueOf(githubEnterpriseConfigProp)) && (ok || !reflect.DeepEqual(v, githubEnterpriseConfigProp)) {
		obj["githubEnterpriseConfig"] = githubEnterpriseConfigProp
	}
	etagProp, err := expandDeveloperConnectConnectionEtag(d.Get("etag"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("etag"); !tpgresource.IsEmptyValue(reflect.ValueOf(etagProp)) && (ok || !reflect.DeepEqual(v, etagProp)) {
		obj["etag"] = etagProp
	}
	gitlabEnterpriseConfigProp, err := expandDeveloperConnectConnectionGitlabEnterpriseConfig(d.Get("gitlab_enterprise_config"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("gitlab_enterprise_config"); !tpgresource.IsEmptyValue(reflect.ValueOf(gitlabEnterpriseConfigProp)) && (ok || !reflect.DeepEqual(v, gitlabEnterpriseConfigProp)) {
		obj["gitlabEnterpriseConfig"] = gitlabEnterpriseConfigProp
	}
	bitbucketCloudConfigProp, err := expandDeveloperConnectConnectionBitbucketCloudConfig(d.Get("bitbucket_cloud_config"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("bitbucket_cloud_config"); !tpgresource.IsEmptyValue(reflect.ValueOf(bitbucketCloudConfigProp)) && (ok || !reflect.DeepEqual(v, bitbucketCloudConfigProp)) {
		obj["bitbucketCloudConfig"] = bitbucketCloudConfigProp
	}
	bitbucketDataCenterConfigProp, err := expandDeveloperConnectConnectionBitbucketDataCenterConfig(d.Get("bitbucket_data_center_config"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("bitbucket_data_center_config"); !tpgresource.IsEmptyValue(reflect.ValueOf(bitbucketDataCenterConfigProp)) && (ok || !reflect.DeepEqual(v, bitbucketDataCenterConfigProp)) {
		obj["bitbucketDataCenterConfig"] = bitbucketDataCenterConfigProp
	}
	disabledProp, err := expandDeveloperConnectConnectionDisabled(d.Get("disabled"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("disabled"); !tpgresource.IsEmptyValue(reflect.ValueOf(disabledProp)) && (ok || !reflect.DeepEqual(v, disabledProp)) {
		obj["disabled"] = disabledProp
	}
	gitlabConfigProp, err := expandDeveloperConnectConnectionGitlabConfig(d.Get("gitlab_config"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("gitlab_config"); !tpgresource.IsEmptyValue(reflect.ValueOf(gitlabConfigProp)) && (ok || !reflect.DeepEqual(v, gitlabConfigProp)) {
		obj["gitlabConfig"] = gitlabConfigProp
	}
	cryptoKeyConfigProp, err := expandDeveloperConnectConnectionCryptoKeyConfig(d.Get("crypto_key_config"), d, config)
	if err != nil {
		return nil, err
	} else if v, ok := d.GetOkExists("crypto_key_config"); !tpgresource.IsEmptyValue(reflect.ValueOf(cryptoKeyConfigProp)) && (ok || !reflect.DeepEqual(v, cryptoKeyConfigProp)) {
		obj["cryptoKeyConfig"] = cryptoKeyConfigProp
	}
	labelsProp, err := expandDeveloperConnectConnectionEffectiveLabels(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
	}
	annotationsProp, err := expandDeveloperConnectConnectionEffectiveAnnotations(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
	}

	return obj, nil
}

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return transformed, nil
}

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

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

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

	return transformed, nil
}

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

	return transformed, nil
}

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

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

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

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

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

	return transformed, nil
}

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

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

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

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

	return transformed, nil
}

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

func expandDeveloperConnectConnectionEffectiveLabels(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 expandDeveloperConnectConnectionEffectiveAnnotations(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
}