Repository: databricks/terraform-provider-databricks

Issue:
[ISSUE] Issue with `databricks_catalog ` resource - Modifying predictive optimization is unsupported for this catalog
When running the `terraform plan` the following was the changes to be updated

```bash
Terraform used the selected providers to generate the following execution
plan. Resource actions are indicated with the following symbols:
  ~ update in-place

Terraform will perform the following actions:

  # databricks_catalog.glue_uc_catalog will be updated in-place
  ~ resource "databricks_catalog" "glue_uc_catalog" {
        id                             = "glue-dev"
        name                           = "glue-dev"
      ~ options                        = {
          ~ "authorized_paths" = "s3://glue-dev-logs/" -> "s3://glue-dev-logs/,s3://glue-dev-additional-logs/"
        }
        # (7 unchanged attributes hidden)
    }
```

but the `terraform apply` failed with the following error

```bash
Error: cannot update catalog: Modifying predictive optimization is unsupported for this catalog.
```

## Important note

`glue-dev` is a `FOREIGN_CATALOG`. Due to that, the concept `predictive optimization` does not make any sense because the actual catalogue is is not managed by databricks and hence cannot do any predictive optimization. This feels like a leaky API abstraction to the `databricks_catalog` resource, probably foreign catalogues should have a separate API and resource.

### Terraform and provider versions

```bash
Terraform version: 1.9.8
Provider version: 1.80.0
```


Discussion:
@alexott: Try the latest version - it should be fixed already@kishaningithub: @alexott Thanks a lot for the very fast turn around!

 I see the PR is pending to be merged, any hints on how i can point to this version?@alexott: It should be already fixed, my PR is just a bit different implementation@kishaningithub: @alexott I am getting the same issue when using the latest version `v1.99.0` as well

```terraform
databricks = {
  source  = "databricks/databricks"
  version = "~> 1.99.0"
}
```@kishaningithub: @alexott Thanks a lot for merging the fix!

Any look ahead on when the next release might happen?@alexott: Should be this week (not sure today or tomorrow)

Solution patch:
diff --git a/NEXT_CHANGELOG.md b/NEXT_CHANGELOG.md
index efdf3e55..1ce7590c 100644
--- a/NEXT_CHANGELOG.md
+++ b/NEXT_CHANGELOG.md
@@ -7,13 +7,19 @@
 ### New Features and Improvements
 
 * Recreate `databricks_credential` on the `name` change ([#5248](https://github.com/databricks/terraform-provider-databricks/pull/5248)).
+* Allow to specify default catalog and schema for `databricks_dashboard` ([#5259](https://github.com/databricks/terraform-provider-databricks/pull/5259)).
 
 ### Bug Fixes
 
 * Fix retrieving of latest DBR versions in `databricks_spark_version` ([#5255](https://github.com/databricks/terraform-provider-databricks/pull/5255))
+* Reset PO flag for non-managed UC Catalogs ([#5260](https://github.com/databricks/terraform-provider-databricks/pull/5260)).
 
 ### Documentation
 
+* Add missing GCP IAM permission `topics.detachSubscription` for Databricks file events ([#5269](https://github.com/databricks/terraform-provider-databricks/pull/5269))
+
 ### Exporter
 
+* Added `-targetCloud` and `-nodeTypeMappingFile` flags for cross-cloud attribute and node-type conversion ([#5236](https://github.com/databricks/terraform-provider-databricks/issues/5236)).
+
 ### Internal Changes
diff --git a/catalog/resource_catalog.go b/catalog/resource_catalog.go
index 663ed562..b9313906 100644
--- a/catalog/resource_catalog.go
+++ b/catalog/resource_catalog.go
@@ -58,6 +58,7 @@ func ResourceCatalog() common.Resource {
 				common.CustomizeSchemaPath(s, v).SetReadOnly()
 			}
 			common.CustomizeSchemaPath(s, "effective_predictive_optimization_flag").SetComputed().SetSuppressDiff()
+			common.CustomizeSchemaPath(s, "provisioning_info").SetComputed().SetSuppressDiff()
 			return s
 		})
 	return common.Resource{
@@ -118,7 +119,7 @@ func ResourceCatalog() common.Resource {
 			}
 			var origCatalogData catalog.CatalogInfo
 			common.DataToStructPointer(d, catalogSchema, &origCatalogData)
-			if (origCatalogData.ShareName != "" || origCatalogData.ConnectionName != "" || origCatalogData.ProviderName != "") &&
+			if origCatalogData.CatalogType != "MANAGED_CATALOG" &&
 				string(origCatalogData.EnablePredictiveOptimization) == "" {
 				ci.EnablePredictiveOptimization = origCatalogData.EnablePredictiveOptimization
 			}
@@ -169,6 +170,10 @@ func ResourceCatalog() common.Resource {
 					updateCatalogRequest.Options = nil
 				}
 			}
+			// we shouldn't send PO flag for non-managed catalogs
+			if d.Get("catalog_type").(string) != "MANAGED_CATALOG" && updateCatalogRequest.EnablePredictiveOptimization != "" {
+				updateCatalogRequest.EnablePredictiveOptimization = ""
+			}
 			ci, err := w.Catalogs.Update(ctx, updateCatalogRequest)
 
 			if err != nil {
diff --git a/dashboards/resource_dashboard.go b/dashboards/resource_dashboard.go
index b1c9d71b..9f4b15bb 100644
--- a/dashboards/resource_dashboard.go
+++ b/dashboards/resource_dashboard.go
@@ -18,6 +18,8 @@ type Dashboard struct {
 	FilePath                string `json:"file_path,omitempty"`
 	Md5                     string `json:"md5,omitempty"`
 	DashboardChangeDetected bool   `json:"dashboard_change_detected,omitempty"`
+	DatasetCatalog          string `json:"dataset_catalog,omitempty"`
+	DatasetSchema           string `json:"dataset_schema,omitempty"`
 }
 
 func customDiffSerializedDashboard(k, old, new string, d *schema.ResourceData) bool {
@@ -78,7 +80,11 @@ func ResourceDashboard() common.Resource {
 			}
 			d.Set("md5", md5Hash)
 			dashboard.SerializedDashboard = content
-			createdDashboard, err := w.Lakeview.Create(ctx, dashboards.CreateDashboardRequest{Dashboard: dashboard})
+			createdDashboard, err := w.Lakeview.Create(ctx, dashboards.CreateDashboardRequest{
+				Dashboard:      dashboard,
+				DatasetCatalog: d.Get("dataset_catalog").(string),
+				DatasetSchema:  d.Get("dataset_schema").(string),
+			})
 			if err != nil && isParentDoesntExistError(err) {
 				log.Printf("[DEBUG] Parent folder '%s' doesn't exist, creating...", dashboard.ParentPath)
 				err = w.Workspace.MkdirsByPath(ctx, dashboard.ParentPath)
@@ -144,16 +150,18 @@ func ResourceDashboard() common.Resource {
 			}
 			var dashboard dashboards.Dashboard
 			common.DataToStructPointer(d, dashboardSchema, &dashboard)
-			dashboard.DashboardId = d.Id()
 			content, md5Hash, err := common.ReadSerializedJsonContent(d.Get("serialized_dashboard").(string), d.Get("file_path").(string))
+			dashboard.DashboardId = d.Id()
 			if err != nil {
 				return err
 			}
 			d.Set("md5", md5Hash)
 			dashboard.SerializedDashboard = content
 			updatedDashboard, err := w.Lakeview.Update(ctx, dashboards.UpdateDashboardRequest{
-				DashboardId: dashboard.DashboardId,
-				Dashboard:   dashboard,
+				DashboardId:    dashboard.DashboardId,
+				Dashboard:      dashboard,
+				DatasetCatalog: d.Get("dataset_catalog").(string),
+				DatasetSchema:  d.Get("dataset_schema").(string),
 			})
 			if err != nil {
 				return err
diff --git a/docs/guides/experimental-exporter.md b/docs/guides/experimental-exporter.md
index 28c655bc..6c255566 100644
--- a/docs/guides/experimental-exporter.md
+++ b/docs/guides/experimental-exporter.md
@@ -77,6 +77,55 @@ All arguments are optional, and they tune what code is being generated.
 * `-mounts` - List DBFS mount points, an extremely slow operation that would not trigger unless explicitly specified.
 * `-generateProviderDeclaration` - the flag that toggles the generation of `databricks.tf` file with the declaration of the Databricks Terraform provider that is necessary for Terraform versions since Terraform 0.13 (disabled by default).
 * `-prefix` - optional prefix that will be added to the name of all exported resources - that's useful for exporting resources from multiple workspaces for merging into a single one.
+* `-targetCloud` - Target cloud for generated code (`aws`, `azure`, `gcp`). If different from the source cloud, the exporter will convert cloud-specific attributes (`aws_attributes`, `azure_attributes`, `gcp_attributes`) to the target cloud format. Only compatible attributes are converted:
+  * `availability` - Converted between cloud-specific formats (e.g., `SPOT` → `SPOT_AZURE` → `PREEMPTIBLE_GCP`)
+  * `first_on_demand` - Preserved across all clouds
+  * `zone_id` - Only converted between AWS and GCP when value is `auto`
+  * `ebs_volume_count` (AWS) ↔ `local_ssd_count` (GCP) - Only when `ebs_volume_type` is `GENERAL_PURPOSE_SSD`
+  * `disk_spec.disk_type` (for instance pools):
+    * AWS `ebs_volume_type` (`GENERAL_PURPOSE_SSD`, `THROUGHPUT_OPTIMIZED_HDD`) ↔ Azure `azure_disk_volume_type` (`PREMIUM_LRS`, `STANDARD_LRS`)
+    * When converting to GCP, `disk_type` is removed entirely (GCP only supports `disk_count`)
+    * When converting from GCP, `disk_count` is preserved but `disk_type` cannot be added
+  * Other attributes (e.g., `instance_profile_arn`) are not compatible and will be omitted
+* `-nodeTypeMappingFile` - Path to JSON file containing node type mappings between clouds. Can only be used with `-targetCloud` flag. When specified, the exporter will convert `node_type_id` and `driver_node_type_id` fields to the target cloud's node types. The JSON file should have the following format:
+
+  ```json
+  {
+    "version": "1.0",
+    "mappings": [
+      {
+        "azure": "Standard_F4s",
+        "aws": "i3.xlarge",
+        "gcp": "n1-standard-4"
+      },
+      {
+        "azure": "Standard_F8s",
+        "aws": "i3.2xlarge",
+        "gcp": "n1-standard-8"
+      }
+    ]
+  }
+  ```
+  
+  Node types without mappings will be preserved unchanged with a warning logged.
+
+  To generate a mapping file, use the `exporter/generate_node_mappings.py` script:
+  
+  ```bash
+  # Extract node types from each cloud workspace
+  databricks api get /api/2.1/clusters/list-node-types --profile aws > node-types-aws.json
+  databricks api get /api/2.1/clusters/list-node-types --profile azure > node-types-azure.json
+  databricks api get /api/2.1/clusters/list-node-types --profile gcp > node-types-gcp.json
+
+  # Generate the mapping file
+  python3 exporter/generate_node_mappings.py \
+    --aws node-types-aws.json \
+    --azure node-types-azure.json \
+    --gcp node-types-gcp.json \
+    --output node_type_mapping.json
+  ```
+
+  The script generates comprehensive three-way mappings (~99.5% coverage) using similarity scoring based on cores, memory, category, and disk configuration. See `exporter/AGENTS.md` for detailed algorithm documentation.
 * `-skip-interactive` - optionally run in a non-interactive mode.
 * `-includeUserDomains` - optionally include the domain name in the generated resource name for `databricks_user` resource.
 * `-importAllUsers` - optionally includes all users and service principals even if they are only part of the `users` group.
diff --git a/docs/guides/unity-catalog-gcp.md b/docs/guides/unity-catalog-gcp.md
index ea697f85..4cb2ba12 100644
--- a/docs/guides/unity-catalog-gcp.md
+++ b/docs/guides/unity-catalog-gcp.md
@@ -153,6 +153,7 @@ resource "google_project_iam_custom_role" "uc_file_events" {
     "pubsub.subscriptions.list",
     "pubsub.subscriptions.update",
     "pubsub.topics.attachSubscription",
+    "pubsub.topics.detachSubscription",
     "pubsub.topics.create",
     "pubsub.topics.delete",
     "pubsub.topics.get",
diff --git a/docs/resources/dashboard.md b/docs/resources/dashboard.md
index 09e0211b..81e8b03a 100644
--- a/docs/resources/dashboard.md
+++ b/docs/resources/dashboard.md
@@ -52,6 +52,8 @@ The following arguments are supported:
 * `file_path` - (Optional) The path to the dashboard JSON file. Conflicts with `serialized_dashboard`.
 * `embed_credentials` - (Optional) Whether to embed credentials in the dashboard. Default is `true`.
 * `parent_path` - (Required) The workspace path of the folder containing the dashboard. Includes leading slash and no trailing slash.  If folder doesn't exist, it will be created.
+* `dataset_catalog` - (Optional) Sets the default catalog for all datasets in this dashboard. Does not impact table references that use fully qualified catalog names (ex: samples.nyctaxi.trips).
+* `dataset_schema` - (Optional) Sets the default schema for all datasets in this dashboard. Does not impact table references that use fully qualified catalog names (ex: samples.nyctaxi.trips).
 
 ## Attribute Reference
 
diff --git a/exporter/AGENTS.md b/exporter/AGENTS.md
index 72805ede..00a62b0c 100644
--- a/exporter/AGENTS.md
+++ b/exporter/AGENTS.md
@@ -1,6 +1,6 @@
 # Terraform Exporter
 
-The exporter (`exporter/` directory) generates Terraform configuration (`.tf` files) and import scripts from existing Databricks resources.
+You're experienced senior engineer working on  the exporter utility (`exporter/` directory) that generates Terraform configuration (`.tf` files) and import scripts from existing Databricks resources.
 
 ## How it works under the hood
 
@@ -124,3 +124,133 @@ For a resource with `node_count` (input-only) and `effective_node_count` (API-re
 - Generated HCL omits: `enable_readable_secondaries = false` (zero value)
 
 For more details, see `exporter/EFFECTIVE_FIELDS_PATTERN.md`.
+
+## Cloud Attribute Conversion
+
+The exporter supports converting cloud-specific attributes when exporting for a different target cloud using the `-targetCloud` flag.
+
+**Supported Resources:**
+- `databricks_cluster`
+- `databricks_job` (new_cluster in tasks and job_clusters)
+- `databricks_pipeline`
+- `databricks_instance_pool`
+
+**Compatible Attributes:**
+- `availability` - Automatically converted to target cloud format
+- `first_on_demand` - Preserved as-is
+- `zone_id` - Only "auto" value is portable between AWS and GCP
+- `ebs_volume_count` ↔ `local_ssd_count` - Only with GENERAL_PURPOSE_SSD
+- `disk_spec.disk_type` (instance pools only):
+  - AWS `ebs_volume_type` ↔ Azure `azure_disk_volume_type`
+    - `GENERAL_PURPOSE_SSD` ↔ `PREMIUM_LRS`
+    - `THROUGHPUT_OPTIMIZED_HDD` ↔ `STANDARD_LRS`
+  - GCP: `disk_type` not supported (removed when converting to GCP)
+  - `disk_count` is preserved across all clouds
+
+**Incompatible Attributes:**
+Attributes without equivalents in the target cloud (e.g., `instance_profile_arn` on AWS) are omitted from the converted output.
+
+**Implementation:**
+Cloud conversion logic is in `exporter/cloud_utils.go` and integrates into the resource import pipeline before HCL generation.
+
+**Policy for Incompatible Attributes:**
+When converting cloud attributes, source blocks are ALWAYS cleared. If no compatible attributes exist for conversion, the resource will have no cloud attributes block in the generated HCL. Users should review the generated code and manually add cloud-specific attributes as needed.
+
+**Important Limitations:**
+- Only the attributes block is converted; instance types, zones, and other resource-specific configurations must be updated manually
+- Instance profile ARNs and similar cloud-specific identifiers cannot be converted and will be omitted
+- The exporter will log warnings when attributes cannot be converted
+
+## Node Type Mapping
+
+The exporter supports converting `node_type_id` and `driver_node_type_id` fields using an external JSON mapping file specified via the `-nodeTypeMappingFile` flag.
+
+**Usage:**
+```bash
+databricks exporter -targetCloud azure -nodeTypeMappingFile node_mappings.json
+```
+
+**Mapping File Format:**
+```json
+{
+  "version": "1.0",
+  "mappings": [
+    {
+      "azure": "Standard_F4s",
+      "aws": "i3.xlarge",
+      "gcp": "n1-standard-4"
+    }
+  ]
+}
+```
+
+**Features:**
+- Bidirectional mappings: Single file works for all cloud combinations
+- Converts both `node_type_id` and `driver_node_type_id` in clusters, jobs, and pipelines
+- Preserves unmapped node types with warnings
+- Can only be used together with `-targetCloud` flag
+
+**Implementation:**
+- Node type mapping logic is in `exporter/node_type_mapping.go`
+- Integration happens in `cloud_utils.go` alongside cloud attribute conversion
+- Conversion is applied at both top-level and nested cluster configurations
+
+### Generating Node Type Mappings
+
+The `exporter/generate_node_mappings.py` script generates node type mapping files from Databricks API responses.
+
+**Obtaining Node Type Data:**
+
+First, extract node type information from each cloud using the Databricks CLI or API:
+
+```bash
+# AWS workspace
+databricks clusters list-node-types --profile aws-workspace > node-types-aws.json
+
+# Azure workspace
+databricks clusters list-node-types --profile azure-workspace > node-types-azure.json
+
+# GCP workspace
+databricks clusters list-node-types --profile gcp-workspace > node-types-gcp.json
+```
+
+**Running the Generator:**
+
+```bash
+cd exporter
+python3 generate_node_mappings.py \
+  --aws node-types-aws.json \
+  --azure node-types-azure.json \
+  --gcp node-types-gcp.json \
+  --output node_type_mapping.json
+```
+
+**Algorithm:**
+
+The script uses a two-phase approach to maximize mapping coverage:
+
+1. **Exact Matching Phase** (minimum similarity score: 150)
+   - Core count must match exactly (required)
+   - Memory within 90% tolerance (weighted: 50 points)
+   - Category matching: memory/highmem, compute, storage, general (weighted: 30 points)
+   - Disk configuration similarity (weighted: 20 points)
+
+2. **Approximate Matching Phase**
+   - For mappings missing one or two clouds, finds approximate matches
+   - Uses existing cloud mapping characteristics as reference
+   - Requires same core count, accepts lower similarity scores
+   - Results in ~99.5% complete three-way mappings (AWS + Azure + GCP)
+
+**Output:**
+
+The script generates a bidirectional JSON mapping file with statistics:
+- Total mappings: typically 800-850
+- Complete three-way mappings: ~99.5%
+- Incomplete mappings: ~0.5% (usually high-core instances without cross-cloud equivalents)
+
+**Filters Applied:**
+
+The script automatically filters out:
+- Deprecated node types (`is_deprecated: true`)
+- Hidden node types (`is_hidden: true`)
+- GPU-enabled instances (handled separately)
diff --git a/exporter/cloud_utils.go b/exporter/cloud_utils.go
new file mode 100644
index 00000000..8e9ad150
--- /dev/null
+++ b/exporter/cloud_utils.go
@@ -0,0 +1,689 @@
+package exporter
+
+import (
+	"fmt"
+	"log"
+	"strings"
+)
+
+// getSourceCloud detects the source cloud from the client configuration
+func (ic *importContext) getSourceCloud() string {
+	if ic.Client.IsAws() {
+		return "aws"
+	} else if ic.Client.IsAzure() {
+		return "azure"
+	} else if ic.Client.IsGcp() {
+		return "gcp"
+	}
+	return ""
+}
+
+// validTargetClouds is a map of valid target cloud values
+var validTargetClouds = map[string]bool{
+	"":      true,
+	"aws":   true,
+	"azure": true,
+	"gcp":   true,
+}
+
+// isValidTargetCloud validates the target cloud parameter
+func isValidTargetCloud(cloud string) bool {
+	return validTargetClouds[cloud]
+}
+
+// availabilityType represents the normalized availability type
+type availabilityType int
+
+const (
+	availabilityUnknown availabilityType = iota
+	availabilitySpot
+	availabilityOnDemand
+	availabilitySpotWithFallback
+)
+
+// availabilityParsers maps cloud provider to availability string mappings
+var availabilityParsers = map[string]map[string]availabilityType{
+	"aws": {
+		"SPOT":               availabilitySpot,
+		"ON_DEMAND":          availabilityOnDemand,
+		"SPOT_WITH_FALLBACK": availabilitySpotWithFallback,
+	},
+	"azure": {
+		"SPOT_AZURE":               availabilitySpot,
+		"ON_DEMAND_AZURE":          availabilityOnDemand,
+		"SPOT_WITH_FALLBACK_AZURE": availabilitySpotWithFallback,
+	},
+	"gcp": {
+		"PREEMPTIBLE_GCP":               availabilitySpot,
+		"ON_DEMAND_GCP":                 availabilityOnDemand,
+		"PREEMPTIBLE_WITH_FALLBACK_GCP": availabilitySpotWithFallback,
+	},
+}
+
+// availabilityFormatters maps cloud provider and availability type to string
+var availabilityFormatters = map[string]map[availabilityType]string{
+	"aws": {
+		availabilitySpot:             "SPOT",
+		availabilityOnDemand:         "ON_DEMAND",
+		availabilitySpotWithFallback: "SPOT_WITH_FALLBACK",
+	},
+	"azure": {
+		availabilitySpot:             "SPOT_AZURE",
+		availabilityOnDemand:         "ON_DEMAND_AZURE",
+		availabilitySpotWithFallback: "SPOT_WITH_FALLBACK_AZURE",
+	},
+	"gcp": {
+		availabilitySpot:             "PREEMPTIBLE_GCP",
+		availabilityOnDemand:         "ON_DEMAND_GCP",
+		availabilitySpotWithFallback: "PREEMPTIBLE_WITH_FALLBACK_GCP",
+	},
+}
+
+// parseAvailability parses cloud-specific availability string to normalized type
+func parseAvailability(availability string, cloud string) availabilityType {
+	if parser, ok := availabilityParsers[cloud]; ok {
+		if availType, ok := parser[availability]; ok {
+			return availType
+		}
+	}
+	return availabilityUnknown
+}
+
+// formatAvailability formats normalized availability type to cloud-specific string
+func formatAvailability(availType availabilityType, cloud string) string {
+	if formatter, ok := availabilityFormatters[cloud]; ok {
+		if str, ok := formatter[availType]; ok {
+			return str
+		}
+	}
+	return ""
+}
+
+// diskVolumeType represents the normalized disk volume type
+type diskVolumeType int
+
+const (
+	diskVolumeUnknown diskVolumeType = iota
+	diskVolumeSSD
+	diskVolumeHDD
+)
+
+// diskVolumeParsers maps cloud provider to disk type string mappings
+var diskVolumeParsers = map[string]map[string]diskVolumeType{
+	"aws": {
+		"GENERAL_PURPOSE_SSD":      diskVolumeSSD,
+		"THROUGHPUT_OPTIMIZED_HDD": diskVolumeHDD,
+	},
+	"azure": {
+		"PREMIUM_LRS":  diskVolumeSSD,
+		"STANDARD_LRS": diskVolumeHDD,
+	},
+}
+
+// diskVolumeFormatters maps cloud provider and disk type to string
+var diskVolumeFormatters = map[string]map[diskVolumeType]string{
+	"aws": {
+		diskVolumeSSD: "GENERAL_PURPOSE_SSD",
+		diskVolumeHDD: "THROUGHPUT_OPTIMIZED_HDD",
+	},
+	"azure": {
+		diskVolumeSSD: "PREMIUM_LRS",
+		diskVolumeHDD: "STANDARD_LRS",
+	},
+}
+
+// parseDiskVolumeType parses cloud-specific disk type string to normalized type
+func parseDiskVolumeType(diskType string, cloud string) diskVolumeType {
+	if parser, ok := diskVolumeParsers[cloud]; ok {
+		if volType, ok := parser[diskType]; ok {
+			return volType
+		}
+	}
+	return diskVolumeUnknown
+}
+
+// formatDiskVolumeType formats normalized disk type to cloud-specific string
+func formatDiskVolumeType(volType diskVolumeType, cloud string) string {
+	if formatter, ok := diskVolumeFormatters[cloud]; ok {
+		if str, ok := formatter[volType]; ok {
+			return str
+		}
+	}
+	return ""
+}
+
+// convertAvailability converts availability string from source to target cloud
+func convertAvailability(availability, sourceCloud, targetCloud string) string {
+	if sourceCloud == targetCloud {
+		return availability
+	}
+
+	availType := parseAvailability(availability, sourceCloud)
+	if availType == availabilityUnknown {
+		return availability // return unchanged if unknown
+	}
+
+	converted := formatAvailability(availType, targetCloud)
+	if converted == "" {
+		return availability // fallback to original if conversion fails
+	}
+
+	return converted
+}
+
+// isCompatibleAttribute checks if an attribute can be converted between clouds
+func isCompatibleAttribute(attrName string, attrValue interface{}, sourceCloud, targetCloud string, additionalData map[string]interface{}) bool {
+	if sourceCloud == targetCloud {
+		return true
+	}
+
+	switch attrName {
+	case "availability", "first_on_demand":
+		return true
+
+	case "zone_id":
+		// zone_id is only compatible between AWS and GCP when value is "auto" (case insensitive)
+		if (sourceCloud == "aws" && targetCloud == "gcp") || (sourceCloud == "gcp" && targetCloud == "aws") {
+			if strValue, ok := attrValue.(string); ok {
+				return strings.EqualFold(strValue, "auto")
+			}
+		}
+		return false
+
+	case "ebs_volume_count":
+		// ebs_volume_count (AWS) is compatible with local_ssd_count (GCP) only if ebs_volume_type is GENERAL_PURPOSE_SSD
+		if sourceCloud == "aws" && targetCloud == "gcp" {
+			if ebsType, ok := additionalData["ebs_volume_type"].(string); ok {
+				return ebsType == "GENERAL_PURPOSE_SSD"
+			}
+		}
+		return false
+
+	case "local_ssd_count":
+		// local_ssd_count (GCP) is compatible with ebs_volume_count (AWS) if we're going from GCP to AWS
+		if sourceCloud == "gcp" && targetCloud == "aws" {
+			return true
+		}
+		return false
+
+	default:
+		// All other attributes are not compatible
+		return false
+	}
+}
+
+// getTargetAttributeName returns the target attribute name for conversion
+func getTargetAttributeName(attrName, sourceCloud, targetCloud string) string {
+	if sourceCloud == targetCloud {
+		return attrName
+	}
+
+	// ebs_volume_count <-> local_ssd_count
+	if attrName == "ebs_volume_count" && sourceCloud == "aws" && targetCloud == "gcp" {
+		return "local_ssd_count"
+	}
+	if attrName == "local_ssd_count" && sourceCloud == "gcp" && targetCloud == "aws" {
+		return "ebs_volume_count"
+	}
+
+	// All other compatible attributes keep the same name
+	return attrName
+}
+
+// convertCloudAttributesBlock converts a cloud attributes block from source to target cloud
+// Returns nil if no conversion is needed (same cloud)
+func convertCloudAttributesBlock(sourceAttrs map[string]interface{}, sourceCloud, targetCloud string) map[string]interface{} {
+	if sourceCloud == targetCloud || sourceCloud == "" || targetCloud == "" {
+		return nil
+	}
+
+	targetAttrs := make(map[string]interface{})
+
+	for attrName, attrValue := range sourceAttrs {
+		// Check if this attribute is compatible
+		if isCompatibleAttribute(attrName, attrValue, sourceCloud, targetCloud, sourceAttrs) {
+			targetAttrName := getTargetAttributeName(attrName, sourceCloud, targetCloud)
+
+			// Convert the value if needed
+			if attrName == "availability" {
+				if strValue, ok := attrValue.(string); ok {
+					targetAttrs[targetAttrName] = convertAvailability(strValue, sourceCloud, targetCloud)
+				}
+			} else {
+				targetAttrs[targetAttrName] = attrValue
+			}
+		}
+	}
+
+	if len(targetAttrs) == 0 {
+		return nil
+	}
+
+	return targetAttrs
+}
+
+// shouldConvertCloudAttributes checks if the resource type should have cloud attributes converted
+func shouldConvertCloudAttributes(resourceType string) bool {
+	switch resourceType {
+	case "databricks_cluster", "databricks_job", "databricks_pipeline", "databricks_instance_pool":
+		return true
+	default:
+		return false
+	}
+}
+
+// convertResourceDataCloudAttributes converts cloud-specific attributes using unified wrapper
+// This works for both SDKv2 and Plugin Framework resources
+func (ic *importContext) convertResourceDataCloudAttributes(wrapper ResourceDataWrapper, resourceType string) {
+	if ic.targetCloud == "" || !shouldConvertCloudAttributes(resourceType) {
+		return
+	}
+
+	sourceCloud := ic.getSourceCloud()
+	if sourceCloud == ic.targetCloud {
+		return
+	}
+
+	log.Printf("[DEBUG] Converting cloud attributes for %s from %s to %s", resourceType, sourceCloud, ic.targetCloud)
+
+	// Convert top-level cloud attributes (for clusters and instance pools)
+	converted := ic.convertTopLevelCloudAttributes(wrapper, sourceCloud, ic.targetCloud)
+
+	// Convert node types if mappings are loaded
+	if ic.nodeTypeMappings != nil {
+		nodeTypeConverted := ic.convertTopLevelNodeTypes(wrapper, sourceCloud, ic.targetCloud)
+		converted = converted || nodeTypeConverted
+	}
+
+	// Convert nested cloud attributes (for jobs with new_cluster, job_clusters, etc.)
+	if resourceType == "databricks_job" {
+		nestedConverted := ic.convertJobCloudAttributes(wrapper, sourceCloud, ic.targetCloud)
+		converted = converted || nestedConverted
+	}
+
+	// Convert pipeline cloud attributes
+	if resourceType == "databricks_pipeline" {
+		nestedConverted := ic.convertPipelineCloudAttributes(wrapper, sourceCloud, ic.targetCloud)
+		converted = converted || nestedConverted
+	}
+
+	// Convert disk_spec for instance pools
+	if resourceType == "databricks_instance_pool" {
+		diskSpecConverted := ic.convertInstancePoolDiskSpec(wrapper, sourceCloud, ic.targetCloud)
+		converted = converted || diskSpecConverted
+	}
+
+	// Warn if nothing was converted
+	if !converted {
+		log.Printf("[WARN] No cloud attributes found or converted for %s (resource %s)", resourceType, wrapper.Id())
+	}
+}
+
+// convertTopLevelCloudAttributes converts cloud attributes at the resource root level
+// Returns true if any conversion was performed
+func (ic *importContext) convertTopLevelCloudAttributes(wrapper ResourceDataWrapper, sourceCloud, targetCloud string) bool {
+	// Determine source attribute name
+	sourceAttrName := getCloudAttributeName(sourceCloud)
+	if sourceAttrName == "" {
+		return false
+	}
+
+	// Get source attributes
+	sourceAttrs, hasSource := wrapper.GetOk(sourceAttrName)
+	if !hasSource || sourceAttrs == nil {
+		return false
+	}
+
+	// Convert to map
+	var sourceAttrsMap map[string]interface{}
+	if attrsList, ok := sourceAttrs.([]interface{}); ok && len(attrsList) > 0 {
+		if attrsMap, ok := attrsList[0].(map[string]interface{}); ok {
+			sourceAttrsMap = attrsMap
+		}
+	}
+
+	if sourceAttrsMap == nil {
+		return false
+	}
+
+	// Convert the attributes
+	targetAttrs := convertCloudAttributesBlock(sourceAttrsMap, sourceCloud, targetCloud)
+
+	// Determine target attribute name
+	targetAttrName := getCloudAttributeName(targetCloud)
+	if targetAttrName == "" {
+		return false
+	}
+
+	// ALWAYS clear source attributes, even if conversion yields nothing
+	wrapper.Set(sourceAttrName, nil)
+	log.Printf("[DEBUG] Cleared %s from resource %s", sourceAttrName, wrapper.Id())
+
+	if len(targetAttrs) == 0 {
+		log.Printf("[WARN] No compatible attributes found for conversion from %s to %s in resource %s",
+			sourceCloud, targetCloud, wrapper.Id())
+		return true // We did clear the source, so return true
+	}
+
+	// Set target attributes
+	err := wrapper.Set(targetAttrName, []interface{}{targetAttrs})
+	if err != nil {
+		log.Printf("[ERROR] Failed to set %s: %v", targetAttrName, err)
+		return true // Still cleared source
+	}
+
+	log.Printf("[DEBUG] Converted %s to %s with %d attributes for resource %s",
+		sourceAttrName, targetAttrName, len(targetAttrs), wrapper.Id())
+	return true
+}
+
+// getCloudAttributeName returns the attribute name for a given cloud
+func getCloudAttributeName(cloud string) string {
+	if cloud == "" {
+		return ""
+	}
+	return cloud + "_attributes"
+}
+
+// convertJobCloudAttributes converts cloud attributes in job resource (new_cluster, job_clusters, etc.)
+// Returns true if any conversion was performed
+func (ic *importContext) convertJobCloudAttributes(wrapper ResourceDataWrapper, sourceCloud, targetCloud string) bool {
+	converted := false
+
+	// Handle task-level new_cluster
+	if tasks, ok := wrapper.GetOk("task"); ok {
+		if tasksList, ok := tasks.([]interface{}); ok {
+			for i, task := range tasksList {
+				if taskMap, ok := task.(map[string]interface{}); ok {
+					if ic.convertClusterConfigInMap(taskMap, "new_cluster", sourceCloud, targetCloud, fmt.Sprintf("task.%d.new_cluster", i)) {
+						converted = true
+					}
+				}
+			}
+			// Write the modified tasks list back to the wrapper
+			if converted {
+				wrapper.Set("task", tasksList)
+			}
+		}
+	}
+
+	// Handle job_cluster
+	if jobClusters, ok := wrapper.GetOk("job_cluster"); ok {
+		if clustersList, ok := jobClusters.([]interface{}); ok {
+			jobConverted := false
+			for i, cluster := range clustersList {
+				if clusterMap, ok := cluster.(map[string]interface{}); ok {
+					if ic.convertClusterConfigInMap(clusterMap, "new_cluster", sourceCloud, targetCloud, fmt.Sprintf("job_cluster.%d.new_cluster", i)) {
+						jobConverted = true
+						converted = true
+					}
+				}
+			}
+			// Write the modified job_cluster list back to the wrapper
+			if jobConverted {
+				wrapper.Set("job_cluster", clustersList)
+			}
+		}
+	}
+
+	return converted
+}
+
+// convertPipelineCloudAttributes converts cloud attributes in pipeline resource
+// Returns true if any conversion was performed
+func (ic *importContext) convertPipelineCloudAttributes(wrapper ResourceDataWrapper, sourceCloud, targetCloud string) bool {
+	converted := false
+
+	if clusters, ok := wrapper.GetOk("cluster"); ok {
+		if clustersList, ok := clusters.([]interface{}); ok {
+			for i, cluster := range clustersList {
+				if clusterMap, ok := cluster.(map[string]interface{}); ok {
+					if ic.convertClusterConfigInMap(clusterMap, "", sourceCloud, targetCloud, fmt.Sprintf("cluster.%d", i)) {
+						converted = true
+					}
+				}
+			}
+			// Write the modified cluster list back to the wrapper
+			if converted {
+				wrapper.Set("cluster", clustersList)
+			}
+		}
+	}
+
+	return converted
+}
+
+// convertClusterConfigInMap converts cloud attributes within a cluster configuration map
+// Returns true if conversion was performed
+func (ic *importContext) convertClusterConfigInMap(m map[string]interface{}, key string, sourceCloud, targetCloud, debugPath string) bool {
+	var clusterConfig map[string]interface{}
+
+	if key == "" {
+		clusterConfig = m
+	} else {
+		if config, ok := m[key]; ok {
+			if configList, ok := config.([]interface{}); ok && len(configList) > 0 {
+				if configMap, ok := configList[0].(map[string]interface{}); ok {
+					clusterConfig = configMap
+				}
+			}
+		}
+	}
+
+	if clusterConfig == nil {
+		return false
+	}
+
+	converted := false
+
+	// Convert cloud attributes
+	// Determine source attribute name
+	sourceAttrName := getCloudAttributeName(sourceCloud)
+	if sourceAttrName != "" {
+		// Get source attributes
+		sourceAttrs, ok := clusterConfig[sourceAttrName]
+		if ok {
+			var sourceAttrsMap map[string]interface{}
+			if attrsList, ok := sourceAttrs.([]interface{}); ok && len(attrsList) > 0 {
+				if attrsMap, ok := attrsList[0].(map[string]interface{}); ok {
+					sourceAttrsMap = attrsMap
+				}
+			}
+
+			if sourceAttrsMap != nil {
+				// Convert the attributes
+				targetAttrs := convertCloudAttributesBlock(sourceAttrsMap, sourceCloud, targetCloud)
+
+				// Determine target attribute name
+				targetAttrName := getCloudAttributeName(targetCloud)
+				if targetAttrName != "" {
+					// ALWAYS clear source attributes, even if conversion yields nothing
+					delete(clusterConfig, sourceAttrName)
+					log.Printf("[DEBUG] Cleared %s at %s", sourceAttrName, debugPath)
+					converted = true
+
+					if len(targetAttrs) == 0 {
+						log.Printf("[WARN] No compatible attributes found for conversion at %s", debugPath)
+					} else {
+						// Set target attributes
+						clusterConfig[targetAttrName] = []interface{}{targetAttrs}
+						log.Printf("[DEBUG] Converted cloud attributes at %s to %s with %d attributes",
+							debugPath, targetAttrName, len(targetAttrs))
+					}
+				}
+			}
+		}
+	}
+
+	// Convert node types if mappings are loaded
+	if ic.nodeTypeMappings != nil {
+		nodeTypeConverted := ic.convertNodeTypesInClusterConfig(clusterConfig, sourceCloud, targetCloud, debugPath)
+		converted = converted || nodeTypeConverted
+	}
+
+	return converted
+}
+
+// convertTopLevelNodeTypes converts node_type_id and driver_node_type_id at the resource root level
+// Returns true if any conversion was performed
+func (ic *importContext) convertTopLevelNodeTypes(wrapper ResourceDataWrapper, sourceCloud, targetCloud string) bool {
+	converted := false
+
+	// Convert node_type_id
+	if nodeTypeID, ok := wrapper.GetOk("node_type_id"); ok {
+		if nodeType, ok := nodeTypeID.(string); ok && nodeType != "" {
+			newNodeType := convertNodeType(nodeType, sourceCloud, targetCloud, ic.nodeTypeMappings)
+			if newNodeType != nodeType {
+				wrapper.Set("node_type_id", newNodeType)
+				converted = true
+			}
+		}
+	}
+
+	// Convert driver_node_type_id
+	if driverNodeTypeID, ok := wrapper.GetOk("driver_node_type_id"); ok {
+		if driverNodeType, ok := driverNodeTypeID.(string); ok && driverNodeType != "" {
+			newDriverNodeType := convertNodeType(driverNodeType, sourceCloud, targetCloud, ic.nodeTypeMappings)
+			if newDriverNodeType != driverNodeType {
+				wrapper.Set("driver_node_type_id", newDriverNodeType)
+				converted = true
+			}
+		}
+	}
+
+	return converted
+}
+
+// convertNodeTypesInClusterConfig converts node types within a cluster configuration map
+// Returns true if conversion was performed
+func (ic *importContext) convertNodeTypesInClusterConfig(clusterConfig map[string]interface{}, sourceCloud, targetCloud, debugPath string) bool {
+	converted := false
+
+	// Convert node_type_id
+	if nodeTypeID, ok := clusterConfig["node_type_id"]; ok {
+		if nodeType, ok := nodeTypeID.(string); ok && nodeType != "" {
+			newNodeType := convertNodeType(nodeType, sourceCloud, targetCloud, ic.nodeTypeMappings)
+			if newNodeType != nodeType {
+				clusterConfig["node_type_id"] = newNodeType
+				log.Printf("[DEBUG] Converted node_type_id at %s: %s -> %s", debugPath, nodeType, newNodeType)
+				converted = true
+			}
+		}
+	}
+
+	// Convert driver_node_type_id
+	if driverNodeTypeID, ok := clusterConfig["driver_node_type_id"]; ok {
+		if driverNodeType, ok := driverNodeTypeID.(string); ok && driverNodeType != "" {
+			newDriverNodeType := convertNodeType(driverNodeType, sourceCloud, targetCloud, ic.nodeTypeMappings)
+			if newDriverNodeType != driverNodeType {
+				clusterConfig["driver_node_type_id"] = newDriverNodeType
+				log.Printf("[DEBUG] Converted driver_node_type_id at %s: %s -> %s", debugPath, driverNodeType, newDriverNodeType)
+				converted = true
+			}
+		}
+	}
+
+	return converted
+}
+
+// convertInstancePoolDiskSpec converts disk_spec for instance pools between clouds
+// AWS: disk_spec.disk_type.ebs_volume_type (GENERAL_PURPOSE_SSD, THROUGHPUT_OPTIMIZED_HDD)
+// Azure: disk_spec.disk_type.azure_disk_volume_type (PREMIUM_LRS, STANDARD_LRS)
+// GCP: disk_spec.disk_type not supported, only disk_spec.disk_count
+func (ic *importContext) convertInstancePoolDiskSpec(wrapper ResourceDataWrapper, sourceCloud, targetCloud string) bool {
+	if sourceCloud == targetCloud {
+		return false
+	}
+
+	// Get disk_spec
+	diskSpec, hasDiskSpec := wrapper.GetOk("disk_spec")
+	if !hasDiskSpec || diskSpec == nil {
+		return false
+	}
+
+	// Convert to slice and map
+	var diskSpecMap map[string]interface{}
+	if diskSpecList, ok := diskSpec.([]interface{}); ok && len(diskSpecList) > 0 {
+		if specMap, ok := diskSpecList[0].(map[string]interface{}); ok {
+			diskSpecMap = specMap
+		}
+	}
+
+	if diskSpecMap == nil {
+		return false
+	}
+
+	converted := false
+
+	// Get disk_type if present
+	diskType, hasDiskType := diskSpecMap["disk_type"]
+	var diskTypeMap map[string]interface{}
+	if hasDiskType && diskType != nil {
+		if diskTypeList, ok := diskType.([]interface{}); ok && len(diskTypeList) > 0 {
+			if typeMap, ok := diskTypeList[0].(map[string]interface{}); ok {
+				diskTypeMap = typeMap
+			}
+		}
+	}
+
+	// Handle conversion based on source and target clouds
+	if diskTypeMap != nil {
+		// Conversion from AWS to Azure or vice versa
+		if (sourceCloud == "aws" && targetCloud == "azure") || (sourceCloud == "azure" && targetCloud == "aws") {
+			var sourceVolumeType string
+			var sourceFieldName string
+
+			if sourceCloud == "aws" {
+				if ebsType, ok := diskTypeMap["ebs_volume_type"].(string); ok {
+					sourceVolumeType = ebsType
+					sourceFieldName = "ebs_volume_type"
+				}
+			} else if sourceCloud == "azure" {
+				if azureType, ok := diskTypeMap["azure_disk_volume_type"].(string); ok {
+					sourceVolumeType = azureType
+					sourceFieldName = "azure_disk_volume_type"
+				}
+			}
+
+			if sourceVolumeType != "" {
+				// Parse and convert
+				volType := parseDiskVolumeType(sourceVolumeType, sourceCloud)
+				if volType != diskVolumeUnknown {
+					targetVolumeType := formatDiskVolumeType(volType, targetCloud)
+					if targetVolumeType != "" {
+						// Clear source field
+						delete(diskTypeMap, sourceFieldName)
+
+						// Set target field
+						targetFieldName := "ebs_volume_type"
+						if targetCloud == "azure" {
+							targetFieldName = "azure_disk_volume_type"
+						}
+						diskTypeMap[targetFieldName] = targetVolumeType
+
+						log.Printf("[DEBUG] Converted disk_spec.disk_type for instance pool %s: %s=%s -> %s=%s",
+							wrapper.Id(), sourceFieldName, sourceVolumeType, targetFieldName, targetVolumeType)
+						converted = true
+					}
+				}
+			}
+		}
+
+		// Conversion to GCP: remove disk_type entirely (GCP doesn't support it)
+		if targetCloud == "gcp" {
+			delete(diskSpecMap, "disk_type")
+			log.Printf("[DEBUG] Removed disk_spec.disk_type for instance pool %s (GCP doesn't support disk_type)", wrapper.Id())
+			converted = true
+		}
+	}
+
+	// Conversion from GCP to AWS/Azure: Can't add disk_type (doesn't exist in source)
+	// Just keep disk_count if present
+
+	// Update the disk_spec if changes were made
+	if converted {
+		wrapper.Set("disk_spec", []interface{}{diskSpecMap})
+	}
+
+	return converted
+}
diff --git a/exporter/command.go b/exporter/command.go
index c3fbbdd5..fa866385 100644
--- a/exporter/command.go
+++ b/exporter/command.go
@@ -141,6 +141,14 @@ func Run(args ...string) error {
 		"all dependencies of just one cluster, specify -listing=compute")
 	prefix := ""
 	flags.StringVar(&prefix, "prefix", "", "Prefix that will be added to the name of all exported resources")
+	var targetCloud string
+	flags.StringVar(&targetCloud, "targetCloud", "",
+		"Target cloud for generated code (aws, azure, gcp). "+
+			"If different from source cloud, will convert cloud-specific attributes.")
+	var nodeTypeMappingFile string
+	flags.StringVar(&nodeTypeMappingFile, "nodeTypeMappingFile", "",
+		"Path to JSON file containing node type mappings between clouds. "+
+			"Can only be used with -targetCloud flag.")
 	newArgs := args
 	if len(args) > 1 && args[1] == "exporter" {
 		newArgs = args[2:]
@@ -155,6 +163,25 @@ func Run(args ...string) error {
 	if len(prefix) > 0 {
 		ic.prefix = prefix + "_"
 	}
+	if !isValidTargetCloud(targetCloud) {
+		return fmt.Errorf("invalid targetCloud value: %s. Must be one of: aws, azure, gcp", targetCloud)
+	}
+	ic.targetCloud = targetCloud
+
+	// Validate nodeTypeMappingFile can only be used with targetCloud
+	if nodeTypeMappingFile != "" && targetCloud == "" {
+		return fmt.Errorf("nodeTypeMappingFile can only be specified together with targetCloud")
+	}
+
+	// Load node type mappings if specified
+	if nodeTypeMappingFile != "" {
+		mappings, err := loadNodeTypeMappings(nodeTypeMappingFile)
+		if err != nil {
+			return fmt.Errorf("failed to load node type mappings: %w", err)
+		}
+		ic.nodeTypeMappings = mappings
+		log.Printf("[INFO] Loaded %d node type mappings from %s", len(mappings.Mappings), nodeTypeMappingFile)
+	}
 	if trace {
 		logLevel = append(logLevel, "[DEBUG]", "[TRACE]")
 	} else if debug {
diff --git a/exporter/context.go b/exporter/context.go
index 86620559..1dd892f2 100644
--- a/exporter/context.go
+++ b/exporter/context.go
@@ -126,6 +126,8 @@ type importContext struct {
 	notebooksFormat                         string
 	updatedSinceStr                         string
 	updatedSinceMs                          int64
+	targetCloud                             string
+	nodeTypeMappings                        *nodeTypeMappings
 
 	waitGroup *sync.WaitGroup
 
diff --git a/exporter/generate_node_mappings.py b/exporter/generate_node_mappings.py
new file mode 100644
index 00000000..33d94c6e
--- /dev/null
+++ b/exporter/generate_node_mappings.py
@@ -0,0 +1,422 @@
+#!/usr/bin/env python3
+"""
+Generate node type mappings between AWS, Azure, and GCP based on similarity.
+Matching criteria: num_cores, memory_mb, category, and local disk configuration.
+
+The script generates three-way mappings (AWS <-> Azure <-> GCP) with the following strategy:
+1. Find exact/close matches using strict similarity scoring (min score 150)
+2. Fill in missing clouds with approximate matches based on core count and other characteristics
+3. Result: ~99.5% of mappings have all three clouds populated
+
+This ensures maximum compatibility when converting resources across clouds.
+"""
+
+import argparse
+import json
+import sys
+from typing import Dict, List, Optional, Tuple
+
+
+def load_node_types(file_path: str) -> List[Dict]:
+    """Load node types from a JSON file."""
+    with open(file_path, 'r') as f:
+        data = json.load(f)
+    return data.get('node_types', [])
+
+
+def normalize_category(category: str) -> str:
+    """Normalize category names for comparison."""
+    category = category.lower()
+    # Map similar categories
+    if 'memory' in category or 'highmem' in category:
+        return 'memory'
+    elif 'compute' in category:
+        return 'compute'
+    elif 'storage' in category:
+        return 'storage'
+    elif 'general' in category or 'standard' in category:
+        return 'general'
+    return 'general'
+
+
+def calculate_similarity(node1: Dict, node2: Dict) -> float:
+    """
+    Calculate similarity score between two node types.
+    Higher score = more similar.
+    """
+    score = 0.0
+
+    # Cores match (most important) - must match exactly for consideration
+    cores1 = node1.get('num_cores', 0)
+    cores2 = node2.get('num_cores', 0)
+    if cores1 != cores2:
+        return -1.0  # Not compatible
+    score += 100.0
+
+    # Memory match (very important)
+    mem1 = node1.get('memory_mb', 0)
+    mem2 = node2.get('memory_mb', 0)
+    if mem1 > 0 and mem2 > 0:
+        mem_ratio = min(mem1, mem2) / max(mem1, mem2)
+        # Allow up to 10% difference in memory
+        if mem_ratio >= 0.9:
+            score += 50.0 * mem_ratio
+        else:
+            score -= 20.0  # Penalize large memory differences
+
+    # Category match
+    cat1 = normalize_category(node1.get('category', ''))
+    cat2 = normalize_category(node2.get('category', ''))
+    if cat1 == cat2:
+        score += 30.0
+
+    # Disk configuration similarity
+    node1_type = node1.get('node_instance_type', {})
+    node2_type = node2.get('node_instance_type', {})
+
+    disk1_size = node1_type.get('local_disk_size_gb', 0)
+    disk2_size = node2_type.get('local_disk_size_gb', 0)
+
+    # Both have local disks or both don't
+    if (disk1_size > 0) == (disk2_size > 0):
+        score += 10.0
+
+        # If both have disks, compare sizes
+        if disk1_size > 0 and disk2_size > 0:
+            disk_ratio = min(disk1_size, disk2_size) / max(disk1_size, disk2_size)
+            if disk_ratio >= 0.5:  # Within 2x of each other
+                score += 10.0 * disk_ratio
+
+    return score
+
+
+def filter_node_types(nodes: List[Dict]) -> List[Dict]:
+    """Filter out deprecated, hidden, or special node types."""
+    filtered = []
+    for node in nodes:
+        # Skip deprecated or hidden nodes
+        if node.get('is_deprecated', False) or node.get('is_hidden', False):
+            continue
+
+        # Skip GPU nodes for now (different category)
+        if node.get('num_gpus', 0) > 0:
+            continue
+
+        filtered.append(node)
+
+    return filtered
+
+
+def find_best_matches(
+    source_nodes: List[Dict],
+    target_nodes: List[Dict],
+    min_score: float = 150.0
+) -> Dict[str, str]:
+    """
+    Find best matches from source to target node types.
+    Returns a dict mapping source node_type_id to target node_type_id.
+    """
+    matches = {}
+
+    for source_node in source_nodes:
+        source_id = source_node.get('node_type_id', '')
+        best_match = None
+        best_score = min_score
+
+        for target_node in target_nodes:
+            score = calculate_similarity(source_node, target_node)
+            if score > best_score:
+                best_score = score
+                best_match = target_node.get('node_type_id', '')
+
+        if best_match:
+            matches[source_id] = best_match
+
+    return matches
+
+
+def find_approximate_match(
+    reference_node: Dict,
+    target_nodes: List[Dict],
+    min_score: float = 0.0
+) -> Optional[str]:
+    """
+    Find the best approximate match for a node in target cloud.
+    Returns the node_type_id of the best match, even if score is low.
+    """
+    best_match = None
+    best_score = min_score
+
+    for target_node in target_nodes:
+        score = calculate_similarity(reference_node, target_node)
+        if score > best_score:
+            best_score = score
+            best_match = target_node.get('node_type_id', '')
+
+    return best_match
+
+
+def get_node_by_id(node_id: str, nodes: List[Dict]) -> Optional[Dict]:
+    """Get a node by its node_type_id."""
+    for node in nodes:
+        if node.get('node_type_id') == node_id:
+            return node
+    return None
+
+
+def fill_missing_clouds(
+    mappings: List[Dict],
+    aws_nodes: List[Dict],
+    azure_nodes: List[Dict],
+    gcp_nodes: List[Dict]
+) -> List[Dict]:
+    """
+    Fill in missing cloud mappings with approximate matches.
+    Uses the characteristics of existing mappings to find best approximations.
+    """
+    completed_mappings = []
+    nodes_by_cloud = {
+        'aws': aws_nodes,
+        'azure': azure_nodes,
+        'gcp': gcp_nodes
+    }
+
+    for mapping in mappings:
+        new_mapping = mapping.copy()
+
+        # Determine which clouds are present and which are missing
+        present_clouds = [cloud for cloud in ['aws', 'azure', 'gcp'] if cloud in mapping]
+        missing_clouds = [cloud for cloud in ['aws', 'azure', 'gcp'] if cloud not in mapping]
+
+        # For each missing cloud, find an approximate match
+        for missing_cloud in missing_clouds:
+            # Use the first available present cloud as reference
+            if present_clouds:
+                reference_cloud = present_clouds[0]
+                reference_id = mapping[reference_cloud]
+                reference_node = get_node_by_id(reference_id, nodes_by_cloud[reference_cloud])
+
+                if reference_node:
+                    # Find approximate match in missing cloud
+                    approx_match = find_approximate_match(
+                        reference_node,
+                        nodes_by_cloud[missing_cloud],
+                        min_score=0.0  # Accept any match with same core count
+                    )
+                    if approx_match:
+                        new_mapping[missing_cloud] = approx_match
+
+        completed_mappings.append(new_mapping)
+
+    return completed_mappings
+
+
+def generate_mappings(
+    aws_nodes: List[Dict],
+    azure_nodes: List[Dict],
+    gcp_nodes: List[Dict]
+) -> List[Dict]:
+    """
+    Generate three-way mappings between AWS, Azure, and GCP.
+    """
+    # Filter nodes
+    aws_filtered = filter_node_types(aws_nodes)
+    azure_filtered = filter_node_types(azure_nodes)
+    gcp_filtered = filter_node_types(gcp_nodes)
+
+    print(f"Filtered node types: AWS={len(aws_filtered)}, Azure={len(azure_filtered)}, GCP={len(gcp_filtered)}")
+
+    # Create mappings from each cloud to every other cloud
+    aws_to_azure = find_best_matches(aws_filtered, azure_filtered)
+    aws_to_gcp = find_best_matches(aws_filtered, gcp_filtered)
+    azure_to_aws = find_best_matches(azure_filtered, aws_filtered)
+    azure_to_gcp = find_best_matches(azure_filtered, gcp_filtered)
+    gcp_to_aws = find_best_matches(gcp_filtered, aws_filtered)
+    gcp_to_azure = find_best_matches(gcp_filtered, azure_filtered)
+
+    print(f"Found mappings: AWS->Azure={len(aws_to_azure)}, AWS->GCP={len(aws_to_gcp)}")
+    print(f"                Azure->AWS={len(azure_to_aws)}, Azure->GCP={len(azure_to_gcp)}")
+    print(f"                GCP->AWS={len(gcp_to_aws)}, GCP->Azure={len(gcp_to_azure)}")
+
+    # Build three-way mappings
+    mappings = []
+    all_aws_ids = set(aws_to_azure.keys()) | set(aws_to_gcp.keys()) | set(azure_to_aws.values()) | set(gcp_to_aws.values())
+
+    for aws_id in sorted(all_aws_ids):
+        azure_id = aws_to_azure.get(aws_id)
+        gcp_id = aws_to_gcp.get(aws_id)
+
+        # Try to fill in missing mappings through reverse lookups
+        if not azure_id and aws_id in gcp_to_azure.values():
+            # Find GCP node that maps to this AWS node
+            for g_id, a_id in gcp_to_aws.items():
+                if a_id == aws_id and g_id in gcp_to_azure:
+                    azure_id = gcp_to_azure[g_id]
+                    break
+
+        if not gcp_id and aws_id in azure_to_gcp.values():
+            # Find Azure node that maps to this AWS node
+            for az_id, a_id in azure_to_aws.items():
+                if a_id == aws_id and az_id in azure_to_gcp:
+                    gcp_id = azure_to_gcp[az_id]
+                    break
+
+        # Only add if we have at least 2 out of 3 clouds mapped
+        if sum([bool(aws_id), bool(azure_id), bool(gcp_id)]) >= 2:
+            mapping = {}
+            if aws_id:
+                mapping['aws'] = aws_id
+            if azure_id:
+                mapping['azure'] = azure_id
+            if gcp_id:
+                mapping['gcp'] = gcp_id
+
+            # Avoid duplicates
+            if mapping not in mappings:
+                mappings.append(mapping)
+
+    # Also process Azure-centric mappings
+    all_azure_ids = set(azure_to_aws.keys()) | set(azure_to_gcp.keys())
+    for azure_id in sorted(all_azure_ids):
+        aws_id = azure_to_aws.get(azure_id)
+        gcp_id = azure_to_gcp.get(azure_id)
+
+        if sum([bool(aws_id), bool(azure_id), bool(gcp_id)]) >= 2:
+            mapping = {}
+            if aws_id:
+                mapping['aws'] = aws_id
+            if azure_id:
+                mapping['azure'] = azure_id
+            if gcp_id:
+                mapping['gcp'] = gcp_id
+
+            if mapping not in mappings:
+                mappings.append(mapping)
+
+    # And GCP-centric mappings
+    all_gcp_ids = set(gcp_to_aws.keys()) | set(gcp_to_azure.keys())
+    for gcp_id in sorted(all_gcp_ids):
+        aws_id = gcp_to_aws.get(gcp_id)
+        azure_id = gcp_to_azure.get(gcp_id)
+
+        if sum([bool(aws_id), bool(azure_id), bool(gcp_id)]) >= 2:
+            mapping = {}
+            if aws_id:
+                mapping['aws'] = aws_id
+            if azure_id:
+                mapping['azure'] = azure_id
+            if gcp_id:
+                mapping['gcp'] = gcp_id
+
+            if mapping not in mappings:
+                mappings.append(mapping)
+
+    print(f"\nFilling in missing cloud mappings with approximations...")
+    # Fill in missing clouds with approximate matches
+    mappings = fill_missing_clouds(mappings, aws_filtered, azure_filtered, gcp_filtered)
+
+    # Count how many complete mappings we now have
+    complete_mappings = sum(1 for m in mappings if 'aws' in m and 'azure' in m and 'gcp' in m)
+    print(f"Complete three-way mappings after approximation: {complete_mappings}/{len(mappings)}")
+
+    return mappings
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Generate node type mappings between AWS, Azure, and GCP clouds.',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Generate mappings from node type JSON files
+  %(prog)s --aws node-types-aws.json --azure node-types-azure.json --gcp node-types-gcp.json
+
+  # Specify custom output file
+  %(prog)s --aws aws.json --azure azure.json --gcp gcp.json --output mappings.json
+        """
+    )
+
+    parser.add_argument(
+        '--aws',
+        required=True,
+        help='Path to AWS node types JSON file'
+    )
+
+    parser.add_argument(
+        '--azure',
+        required=True,
+        help='Path to Azure node types JSON file'
+    )
+
+    parser.add_argument(
+        '--gcp',
+        required=True,
+        help='Path to GCP node types JSON file'
+    )
+
+    parser.add_argument(
+        '--output',
+        '-o',
+        default='node_type_mapping.json',
+        help='Output file path (default: node_type_mapping.json)'
+    )
+
+    args = parser.parse_args()
+
+    # Load node types from all three clouds
+    print("Loading node type data...")
+    try:
+        aws_nodes = load_node_types(args.aws)
+        azure_nodes = load_node_types(args.azure)
+        gcp_nodes = load_node_types(args.gcp)
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON format - {e}", file=sys.stderr)
+        return 1
+
+    print(f"Loaded: AWS={len(aws_nodes)}, Azure={len(azure_nodes)}, GCP={len(gcp_nodes)} node types")
+
+    # Generate mappings
+    print("\nGenerating mappings...")
+    mappings = generate_mappings(aws_nodes, azure_nodes, gcp_nodes)
+
+    print(f"\nGenerated {len(mappings)} mappings")
+
+    # Count complete mappings (all three clouds)
+    complete = sum(1 for m in mappings if 'aws' in m and 'azure' in m and 'gcp' in m)
+    incomplete = len(mappings) - complete
+
+    print(f"  - Complete (all 3 clouds): {complete}")
+    print(f"  - Incomplete (2 clouds): {incomplete}")
+
+    # Create output structure
+    output = {
+        "version": "1.0",
+        "mappings": mappings
+    }
+
+    # Write to file
+    try:
+        with open(args.output, 'w') as f:
+            json.dump(output, f, indent=2)
+        print(f"\nMapping file written to: {args.output}")
+    except IOError as e:
+        print(f"Error writing output file: {e}", file=sys.stderr)
+        return 1
+
+    # Print some sample mappings
+    print("\nSample complete mappings (first 10):")
+    complete_samples = [m for m in mappings if 'aws' in m and 'azure' in m and 'gcp' in m][:10]
+    for i, mapping in enumerate(complete_samples, 1):
+        aws = mapping.get('aws', 'N/A')
+        azure = mapping.get('azure', 'N/A')
+        gcp = mapping.get('gcp', 'N/A')
+        print(f"  {i}. AWS: {aws:20s} Azure: {azure:25s} GCP: {gcp}")
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/exporter/impl_scim.go b/exporter/impl_scim.go
index 58dc5629..f8ffd8eb 100644
--- a/exporter/impl_scim.go
+++ b/exporter/impl_scim.go
@@ -251,7 +251,7 @@ func searchServicePrincipal(ic *importContext, r *resource) error {
 
 func importServicePrincipal(ic *importContext, r *resource) error {
 	applicationID := r.Data.Get("application_id").(string)
-	if ic.currentMetastore != nil {
+	if ic.currentMetastore != nil && ic.targetCloud == "" {
 		// Users are maintained on account level and are referenced via data sources
 		setDataForDataScimBlock(r)
 		r.Data.Set("display_name", "")
diff --git a/exporter/importables.go b/exporter/importables.go
index 254347bf..29547b0f 100644
--- a/exporter/importables.go
+++ b/exporter/importables.go
@@ -577,6 +577,9 @@ var resourcesMap map[string]importable = map[string]importable{
 			}
 			if pathString == "display_name" {
 				if ic.Client.IsAzure() {
+					if ic.targetCloud != "" {
+						return false
+					}
 					applicationID := d.Get("application_id").(string)
 					displayName := d.Get("display_name").(string)
 					externalID := d.Get("external_id").(string)
@@ -584,9 +587,15 @@ var resourcesMap map[string]importable = map[string]importable{
 				}
 				return false
 			}
-			// application_id should be provided only on Azure and only for Azure-managed SPs that have external_id set
+			// application_id should be provided only on Azure and only for Azure-managed SPs that
+			// have external_id set
 			if pathString == "application_id" {
-				return !ic.Client.IsAzure() || (d.Get("external_id").(string) == "")
+				return (ic.Client.IsAzure() && ic.targetCloud != "azure" && ic.targetCloud != "") ||
+					!ic.Client.IsAzure() || (d.Get("external_id").(string) == "")
+
+			}
+			if pathString == "external_id" {
+				return ic.targetCloud != "" || d.Get("external_id").(string) == ""
 			}
 			return defaultShouldOmitFieldFunc(ic, pathString, as, d, r)
 		},
@@ -704,7 +713,7 @@ var resourcesMap map[string]importable = map[string]importable{
 		},
 		Import: func(ic *importContext, r *resource) error {
 			backendType, _ := r.Data.GetOk("backend_type")
-			if backendType != "AZURE_KEYVAULT" {
+			if backendType != "AZURE_KEYVAULT" || ic.targetCloud != "" {
 				secrets := ic.workspaceClient.Secrets.ListSecrets(ic.Context, sdk_workspace.ListSecretsRequest{
 					Scope: r.ID,
 				})
@@ -719,6 +728,10 @@ var resourcesMap map[string]importable = map[string]importable{
 					})
 				}
 			}
+			if backendType == "AZURE_KEYVAULT" || ic.targetCloud != "" {
+				r.Data.Set("backend_type ", "DATABRICKS")
+				r.Data.Set("keyvault_metadata", nil)
+			}
 			acls, err := ic.workspaceClient.Secrets.ListAclsByScope(ic.Context, r.ID)
 			if err != nil {
 				return err
diff --git a/exporter/model.go b/exporter/model.go
index 6dbe626f..2c255953 100644
--- a/exporter/model.go
+++ b/exporter/model.go
@@ -368,6 +368,10 @@ func (r *resource) ImportResource(ic *importContext) {
 			}
 		}
 	}
+	// Convert cloud attributes if target cloud is specified
+	if r.DataWrapper != nil {
+		ic.convertResourceDataCloudAttributes(r.DataWrapper, r.Resource)
+	}
 	r.Name = ic.ResourceName(r)
 	if ir.Import != nil {
 		err := runWithRetries(func() error {
diff --git a/exporter/node_type_mapping.go b/exporter/node_type_mapping.go
new file mode 100644
index 00000000..6557665c
--- /dev/null
+++ b/exporter/node_type_mapping.go
@@ -0,0 +1,79 @@
+package exporter
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+)
+
+// nodeTypeMapping represents a single mapping entry between cloud node types
+type nodeTypeMapping struct {
+	Azure string `json:"azure,omitempty"`
+	AWS   string `json:"aws,omitempty"`
+	GCP   string `json:"gcp,omitempty"`
+}
+
+// nodeTypeMappings represents the structure of the mapping file
+type nodeTypeMappings struct {
+	Version  string            `json:"version,omitempty"`
+	Mappings []nodeTypeMapping `json:"mappings"`
+}
+
+// loadNodeTypeMappings loads and parses the node type mapping file
+func loadNodeTypeMappings(filePath string) (*nodeTypeMappings, error) {
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read node type mapping file: %w", err)
+	}
+
+	var mappings nodeTypeMappings
+	if err := json.Unmarshal(data, &mappings); err != nil {
+		return nil, fmt.Errorf("failed to parse node type mapping file: %w", err)
+	}
+
+	return &mappings, nil
+}
+
+// getNodeTypeForCloud returns the node type for a specific cloud from a mapping
+func getNodeTypeForCloud(mapping nodeTypeMapping, cloud string) string {
+	switch cloud {
+	case "aws":
+		return mapping.AWS
+	case "azure":
+		return mapping.Azure
+	case "gcp":
+		return mapping.GCP
+	default:
+		return ""
+	}
+}
+
+// convertNodeType converts a node type from source cloud to target cloud format
+// Returns the original node type if no mapping is found or if clouds are the same
+func convertNodeType(nodeType string, sourceCloud, targetCloud string, mappings *nodeTypeMappings) string {
+	if sourceCloud == targetCloud || mappings == nil {
+		return nodeType
+	}
+
+	// Find the mapping entry that contains the source node type
+	for _, mapping := range mappings.Mappings {
+		sourceNodeType := getNodeTypeForCloud(mapping, sourceCloud)
+		if sourceNodeType == nodeType {
+			// Found the source node type, now get the target
+			targetNodeType := getNodeTypeForCloud(mapping, targetCloud)
+			if targetNodeType != "" {
+				log.Printf("[DEBUG] Converting node type %s (%s) to %s (%s)",
+					nodeType, sourceCloud, targetNodeType, targetCloud)
+				return targetNodeType
+			}
+			log.Printf("[WARN] No %s node type mapping found for %s (%s)",
+				targetCloud, nodeType, sourceCloud)
+			return nodeType
+		}
+	}
+
+	// No mapping found, return original
+	log.Printf("[WARN] No mapping found for node type %s (%s)", nodeType, sourceCloud)
+	return nodeType
+}
diff --git a/exporter/node_type_mapping.json b/exporter/node_type_mapping.json
new file mode 100644
index 00000000..6e5080a5
--- /dev/null
+++ b/exporter/node_type_mapping.json
@@ -0,0 +1,4106 @@
+{
+  "version": "1.0",
+  "mappings": [
+    {
+      "aws": "c-fleet.12xlarge",
+      "azure": "Standard_D48plds_v6",
+      "gcp": "n2-highcpu-48"
+    },
+    {
+      "aws": "c-fleet.24xlarge",
+      "azure": "Standard_D96plds_v6",
+      "gcp": "n1-highcpu-96"
+    },
+    {
+      "aws": "c-fleet.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c-fleet.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "n1-highcpu-16"
+    },
+    {
+      "aws": "c-fleet.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c4.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c4.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "n1-highcpu-16"
+    },
+    {
+      "aws": "c5.12xlarge",
+      "azure": "Standard_D48plds_v6",
+      "gcp": "n2-highcpu-48"
+    },
+    {
+      "aws": "c5.18xlarge",
+      "azure": "Standard_F72s_v2",
+      "gcp": "c4a-standard-72-lssd"
+    },
+    {
+      "aws": "c5.24xlarge",
+      "azure": "Standard_D96plds_v6",
+      "gcp": "n1-highcpu-96"
+    },
+    {
+      "aws": "c5.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c5.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "n1-highcpu-16"
+    },
+    {
+      "aws": "c5.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c5a.12xlarge",
+      "azure": "Standard_D48plds_v6",
+      "gcp": "n2-highcpu-48"
+    },
+    {
+      "aws": "c5a.16xlarge",
+      "azure": "Standard_F64s_v2",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "c5a.24xlarge",
+      "azure": "Standard_D96plds_v6",
+      "gcp": "n1-highcpu-96"
+    },
+    {
+      "aws": "c5a.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c5a.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "n1-highcpu-16"
+    },
+    {
+      "aws": "c5a.8xlarge",
+      "azure": "Standard_F32s_v2",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "c5a.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c5ad.16xlarge",
+      "azure": "Standard_F64s_v2",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "c5ad.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c5ad.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "c2-standard-16"
+    },
+    {
+      "aws": "c5ad.8xlarge",
+      "azure": "Standard_F32s_v2",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "c5ad.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c5d.18xlarge",
+      "azure": "Standard_F72s_v2",
+      "gcp": "c4a-standard-72-lssd"
+    },
+    {
+      "aws": "c5d.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c5d.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "c2-standard-16"
+    },
+    {
+      "aws": "c5d.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c6g.12xlarge",
+      "azure": "Standard_D48plds_v6",
+      "gcp": "n2-highcpu-48"
+    },
+    {
+      "aws": "c6g.16xlarge",
+      "azure": "Standard_F64s_v2",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "c6g.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c6g.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "n1-highcpu-16"
+    },
+    {
+      "aws": "c6g.8xlarge",
+      "azure": "Standard_F32s_v2",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "c6g.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c6gd.16xlarge",
+      "azure": "Standard_F64s_v2",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "c6gd.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c6gd.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "c2-standard-16"
+    },
+    {
+      "aws": "c6gd.8xlarge",
+      "azure": "Standard_F32s_v2",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "c6gd.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c6i.12xlarge",
+      "azure": "Standard_D48plds_v6",
+      "gcp": "n2-highcpu-48"
+    },
+    {
+      "aws": "c6i.16xlarge",
+      "azure": "Standard_F64s_v2",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "c6i.24xlarge",
+      "azure": "Standard_D96plds_v6",
+      "gcp": "n1-highcpu-96"
+    },
+    {
+      "aws": "c6i.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c6i.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "n1-highcpu-16"
+    },
+    {
+      "aws": "c6i.8xlarge",
+      "azure": "Standard_F32s_v2",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "c6i.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c6id.16xlarge",
+      "azure": "Standard_F64s_v2",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "c6id.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c6id.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "c2-standard-16"
+    },
+    {
+      "aws": "c6id.8xlarge",
+      "azure": "Standard_F32s_v2",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "c6id.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c6in.12xlarge",
+      "azure": "Standard_D48plds_v6",
+      "gcp": "n2-highcpu-48"
+    },
+    {
+      "aws": "c6in.16xlarge",
+      "azure": "Standard_F64s_v2",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "c6in.24xlarge",
+      "azure": "Standard_D96plds_v6",
+      "gcp": "n1-highcpu-96"
+    },
+    {
+      "aws": "c6in.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c6in.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "n1-highcpu-16"
+    },
+    {
+      "aws": "c6in.8xlarge",
+      "azure": "Standard_F32s_v2",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "c6in.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c7a.12xlarge",
+      "azure": "Standard_D48plds_v6",
+      "gcp": "n2-highcpu-48"
+    },
+    {
+      "aws": "c7a.16xlarge",
+      "azure": "Standard_F64s_v2",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "c7a.24xlarge",
+      "azure": "Standard_D96plds_v6",
+      "gcp": "n1-highcpu-96"
+    },
+    {
+      "aws": "c7a.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c7a.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "n1-highcpu-16"
+    },
+    {
+      "aws": "c7a.8xlarge",
+      "azure": "Standard_F32s_v2",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "c7a.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c7g.12xlarge",
+      "azure": "Standard_D48plds_v6",
+      "gcp": "n2-highcpu-48"
+    },
+    {
+      "aws": "c7g.16xlarge",
+      "azure": "Standard_F64s_v2",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "c7g.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c7g.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "n1-highcpu-16"
+    },
+    {
+      "aws": "c7g.8xlarge",
+      "azure": "Standard_F32s_v2",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "c7g.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c7gd.16xlarge",
+      "azure": "Standard_F64s_v2",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "c7gd.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c7gd.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "c2-standard-16"
+    },
+    {
+      "aws": "c7gd.8xlarge",
+      "azure": "Standard_F32s_v2",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "c7gd.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c7i.12xlarge",
+      "azure": "Standard_D48plds_v6",
+      "gcp": "n2-highcpu-48"
+    },
+    {
+      "aws": "c7i.16xlarge",
+      "azure": "Standard_F64s_v2",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "c7i.24xlarge",
+      "azure": "Standard_D96plds_v6",
+      "gcp": "n1-highcpu-96"
+    },
+    {
+      "aws": "c7i.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c7i.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "n1-highcpu-16"
+    },
+    {
+      "aws": "c7i.8xlarge",
+      "azure": "Standard_F32s_v2",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "c7i.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c8g.12xlarge",
+      "azure": "Standard_D48plds_v6",
+      "gcp": "n2-highcpu-48"
+    },
+    {
+      "aws": "c8g.16xlarge",
+      "azure": "Standard_F64s_v2",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "c8g.24xlarge",
+      "azure": "Standard_D96plds_v6",
+      "gcp": "n1-highcpu-96"
+    },
+    {
+      "aws": "c8g.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c8g.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "n1-highcpu-16"
+    },
+    {
+      "aws": "c8g.8xlarge",
+      "azure": "Standard_F32s_v2",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "c8g.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c8gd.16xlarge",
+      "azure": "Standard_F64s_v2",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "c8gd.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c8gd.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "c2-standard-16"
+    },
+    {
+      "aws": "c8gd.8xlarge",
+      "azure": "Standard_F32s_v2",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "c8gd.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "cd-fleet.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "cd-fleet.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "c2-standard-16"
+    },
+    {
+      "aws": "cd-fleet.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "cg-fleet.12xlarge",
+      "azure": "Standard_D48plds_v6",
+      "gcp": "n2-highcpu-48"
+    },
+    {
+      "aws": "cg-fleet.16xlarge",
+      "azure": "Standard_F64s_v2",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "cg-fleet.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "cg-fleet.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "n1-highcpu-16"
+    },
+    {
+      "aws": "cg-fleet.8xlarge",
+      "azure": "Standard_F32s_v2",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "cg-fleet.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "cgd-fleet.16xlarge",
+      "azure": "Standard_F64s_v2",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "cgd-fleet.2xlarge",
+      "azure": "Standard_F8",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "cgd-fleet.4xlarge",
+      "azure": "Standard_F16",
+      "gcp": "c2-standard-16"
+    },
+    {
+      "aws": "cgd-fleet.8xlarge",
+      "azure": "Standard_F32s_v2",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "cgd-fleet.xlarge",
+      "azure": "Standard_F4",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "d3.2xlarge",
+      "azure": "Standard_L8s_v2",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "d3.4xlarge",
+      "azure": "Standard_L16s_v2",
+      "gcp": "c4a-highmem-16-lssd"
+    },
+    {
+      "aws": "d3.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "d3en.2xlarge",
+      "azure": "Standard_D8s_v3",
+      "gcp": "c3-standard-8-lssd"
+    },
+    {
+      "aws": "d3en.4xlarge",
+      "azure": "Standard_D16s_v3",
+      "gcp": "c3d-standard-16-lssd"
+    },
+    {
+      "aws": "d3en.xlarge",
+      "azure": "Standard_D4s_v3",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "i2.2xlarge",
+      "azure": "Standard_L8s_v2",
+      "gcp": "c4a-highmem-8-lssd"
+    },
+    {
+      "aws": "i2.4xlarge",
+      "azure": "Standard_L16s_v2",
+      "gcp": "c4a-highmem-16-lssd"
+    },
+    {
+      "aws": "i2.8xlarge",
+      "azure": "Standard_L32s_v2",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "i2.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "i3.16xlarge",
+      "azure": "Standard_L64s_v2",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "i3.2xlarge",
+      "azure": "Standard_L8s_v2",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "i3.4xlarge",
+      "azure": "Standard_L16s_v2",
+      "gcp": "c4a-highmem-16-lssd"
+    },
+    {
+      "aws": "i3.8xlarge",
+      "azure": "Standard_L32s_v2",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "i3.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "i3en.12xlarge",
+      "azure": "Standard_L48s_v3",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "i3en.24xlarge",
+      "gcp": "n2d-highmem-96",
+      "azure": "Standard_E96ds_v6"
+    },
+    {
+      "aws": "i3en.2xlarge",
+      "azure": "Standard_L8s_v2",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "i3en.large",
+      "gcp": "n2-highmem-2",
+      "azure": "Standard_E2ads_v6"
+    },
+    {
+      "aws": "i3en.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "i4g.16xlarge",
+      "azure": "Standard_L64s_v2",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "i4g.2xlarge",
+      "azure": "Standard_L8s_v2",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "i4g.4xlarge",
+      "azure": "Standard_L16s_v2",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "i4g.8xlarge",
+      "azure": "Standard_L32s_v2",
+      "gcp": "n2-highmem-32"
+    },
+    {
+      "aws": "i4g.large",
+      "gcp": "n2-highmem-2",
+      "azure": "Standard_E2ads_v6"
+    },
+    {
+      "aws": "i4g.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "i4i.16xlarge",
+      "azure": "Standard_L64s_v2",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "i4i.2xlarge",
+      "azure": "Standard_L8s_v2",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "i4i.4xlarge",
+      "azure": "Standard_L16s_v2",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "i4i.8xlarge",
+      "azure": "Standard_L32s_v2",
+      "gcp": "n2-highmem-32"
+    },
+    {
+      "aws": "i4i.large",
+      "gcp": "n2-highmem-2",
+      "azure": "Standard_E2ads_v6"
+    },
+    {
+      "aws": "i4i.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "i7i.12xlarge",
+      "azure": "Standard_L48s_v3",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "i7i.16xlarge",
+      "azure": "Standard_L64s_v2",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "i7i.24xlarge",
+      "gcp": "n2d-highmem-96",
+      "azure": "Standard_E96ds_v6"
+    },
+    {
+      "aws": "i7i.2xlarge",
+      "azure": "Standard_L8s_v2",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "i7i.4xlarge",
+      "azure": "Standard_L16s_v2",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "i7i.8xlarge",
+      "azure": "Standard_L32s_v2",
+      "gcp": "n2-highmem-32"
+    },
+    {
+      "aws": "i7i.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "i8g.12xlarge",
+      "azure": "Standard_L48s_v3",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "i8g.16xlarge",
+      "azure": "Standard_L64s_v2",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "i8g.24xlarge",
+      "gcp": "n2d-highmem-96",
+      "azure": "Standard_E96ds_v6"
+    },
+    {
+      "aws": "i8g.2xlarge",
+      "azure": "Standard_L8s_v2",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "i8g.4xlarge",
+      "azure": "Standard_L16s_v2",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "i8g.8xlarge",
+      "azure": "Standard_L32s_v2",
+      "gcp": "n2-highmem-32"
+    },
+    {
+      "aws": "i8g.large",
+      "gcp": "n2-highmem-2",
+      "azure": "Standard_E2ads_v6"
+    },
+    {
+      "aws": "i8g.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "m-fleet.12xlarge",
+      "azure": "Standard_D48s_v5",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m-fleet.16xlarge",
+      "azure": "Standard_D64s_v5",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m-fleet.24xlarge",
+      "azure": "Standard_D96s_v5",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m-fleet.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m-fleet.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m-fleet.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m-fleet.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m4.16xlarge",
+      "azure": "Standard_D64s_v5",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m4.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m4.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m4.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "m4.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m5.12xlarge",
+      "azure": "Standard_D48s_v5",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m5.16xlarge",
+      "azure": "Standard_D64s_v5",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m5.24xlarge",
+      "azure": "Standard_D96s_v5",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m5.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m5.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m5.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m5.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "m5.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m5a.12xlarge",
+      "azure": "Standard_D48s_v5",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m5a.16xlarge",
+      "azure": "Standard_D64s_v5",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m5a.24xlarge",
+      "azure": "Standard_D96s_v5",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m5a.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m5a.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m5a.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m5a.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "m5a.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m5d.12xlarge",
+      "azure": "Standard_D48a_v4",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m5d.16xlarge",
+      "azure": "Standard_D64s_v3",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m5d.24xlarge",
+      "azure": "Standard_D96as_v4",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m5d.2xlarge",
+      "azure": "Standard_D8ds_v4",
+      "gcp": "c3d-standard-8-lssd"
+    },
+    {
+      "aws": "m5d.4xlarge",
+      "azure": "Standard_D16a_v4",
+      "gcp": "c3d-standard-16-lssd"
+    },
+    {
+      "aws": "m5d.8xlarge",
+      "azure": "Standard_D32a_v4",
+      "gcp": "c4a-standard-32-lssd"
+    },
+    {
+      "aws": "m5d.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "n2-highmem-2"
+    },
+    {
+      "aws": "m5d.xlarge",
+      "azure": "Standard_D4ds_v4",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "m5dn.12xlarge",
+      "azure": "Standard_D48a_v4",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m5dn.16xlarge",
+      "azure": "Standard_D64s_v3",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m5dn.24xlarge",
+      "azure": "Standard_D96as_v4",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m5dn.2xlarge",
+      "azure": "Standard_D8ds_v4",
+      "gcp": "c3d-standard-8-lssd"
+    },
+    {
+      "aws": "m5dn.4xlarge",
+      "azure": "Standard_D16a_v4",
+      "gcp": "c3d-standard-16-lssd"
+    },
+    {
+      "aws": "m5dn.8xlarge",
+      "azure": "Standard_D32a_v4",
+      "gcp": "c4a-standard-32-lssd"
+    },
+    {
+      "aws": "m5dn.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "n2-highmem-2"
+    },
+    {
+      "aws": "m5dn.xlarge",
+      "azure": "Standard_D4ds_v4",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "m5n.12xlarge",
+      "azure": "Standard_D48s_v5",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m5n.16xlarge",
+      "azure": "Standard_D64s_v5",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m5n.24xlarge",
+      "azure": "Standard_D96s_v5",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m5n.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m5n.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m5n.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m5n.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "m5n.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m5zn.12xlarge",
+      "azure": "Standard_D48s_v5",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m5zn.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m5zn.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "m5zn.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m6g.12xlarge",
+      "azure": "Standard_D48s_v5",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m6g.16xlarge",
+      "azure": "Standard_D64s_v5",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m6g.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m6g.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m6g.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m6g.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "m6g.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m6gd.12xlarge",
+      "azure": "Standard_D48a_v4",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m6gd.16xlarge",
+      "azure": "Standard_D64a_v4",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m6gd.2xlarge",
+      "azure": "Standard_D8ds_v4",
+      "gcp": "c3d-standard-8-lssd"
+    },
+    {
+      "aws": "m6gd.4xlarge",
+      "azure": "Standard_D16ds_v4",
+      "gcp": "c4a-standard-16-lssd"
+    },
+    {
+      "aws": "m6gd.8xlarge",
+      "azure": "Standard_D32ds_v4",
+      "gcp": "c4a-standard-32-lssd"
+    },
+    {
+      "aws": "m6gd.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "n2-highmem-2"
+    },
+    {
+      "aws": "m6gd.xlarge",
+      "azure": "Standard_D4ds_v4",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "m6i.12xlarge",
+      "azure": "Standard_D48s_v5",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m6i.16xlarge",
+      "azure": "Standard_D64s_v5",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m6i.24xlarge",
+      "azure": "Standard_D96s_v5",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m6i.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m6i.32xlarge",
+      "azure": "Standard_D128ds_v6",
+      "gcp": "n2d-standard-128"
+    },
+    {
+      "aws": "m6i.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m6i.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m6i.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "m6i.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m6id.12xlarge",
+      "azure": "Standard_D48a_v4",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m6id.16xlarge",
+      "azure": "Standard_D64a_v4",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m6id.24xlarge",
+      "azure": "Standard_D96a_v4",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m6id.2xlarge",
+      "azure": "Standard_D8ds_v4",
+      "gcp": "c3d-standard-8-lssd"
+    },
+    {
+      "aws": "m6id.32xlarge",
+      "azure": "Standard_D128ds_v6",
+      "gcp": "n2d-standard-128"
+    },
+    {
+      "aws": "m6id.4xlarge",
+      "azure": "Standard_D16ds_v4",
+      "gcp": "c4a-standard-16-lssd"
+    },
+    {
+      "aws": "m6id.8xlarge",
+      "azure": "Standard_D32ds_v4",
+      "gcp": "c4a-standard-32-lssd"
+    },
+    {
+      "aws": "m6id.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "n2-highmem-2"
+    },
+    {
+      "aws": "m6id.xlarge",
+      "azure": "Standard_D4ds_v4",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "m6idn.12xlarge",
+      "azure": "Standard_D48a_v4",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m6idn.16xlarge",
+      "azure": "Standard_D64a_v4",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m6idn.24xlarge",
+      "azure": "Standard_D96a_v4",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m6idn.2xlarge",
+      "azure": "Standard_D8ds_v4",
+      "gcp": "c3d-standard-8-lssd"
+    },
+    {
+      "aws": "m6idn.32xlarge",
+      "azure": "Standard_D128ds_v6",
+      "gcp": "n2d-standard-128"
+    },
+    {
+      "aws": "m6idn.4xlarge",
+      "azure": "Standard_D16ds_v4",
+      "gcp": "c4a-standard-16-lssd"
+    },
+    {
+      "aws": "m6idn.8xlarge",
+      "azure": "Standard_D32ds_v4",
+      "gcp": "c4a-standard-32-lssd"
+    },
+    {
+      "aws": "m6idn.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "n2-highmem-2"
+    },
+    {
+      "aws": "m6idn.xlarge",
+      "azure": "Standard_D4ds_v4",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "m6in.12xlarge",
+      "azure": "Standard_D48s_v5",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m6in.16xlarge",
+      "azure": "Standard_D64s_v5",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m6in.24xlarge",
+      "azure": "Standard_D96s_v5",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m6in.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m6in.32xlarge",
+      "azure": "Standard_D128ds_v6",
+      "gcp": "n2d-standard-128"
+    },
+    {
+      "aws": "m6in.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m6in.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m6in.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "m6in.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m7a.12xlarge",
+      "azure": "Standard_D48s_v5",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m7a.16xlarge",
+      "azure": "Standard_D64s_v5",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m7a.24xlarge",
+      "azure": "Standard_D96s_v5",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m7a.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m7a.32xlarge",
+      "azure": "Standard_D128ds_v6",
+      "gcp": "n2d-standard-128"
+    },
+    {
+      "aws": "m7a.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m7a.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m7a.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m7g.12xlarge",
+      "azure": "Standard_D48s_v5",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m7g.16xlarge",
+      "azure": "Standard_D64s_v5",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m7g.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m7g.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m7g.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m7g.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "m7g.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m7gd.12xlarge",
+      "azure": "Standard_D48a_v4",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m7gd.16xlarge",
+      "azure": "Standard_D64a_v4",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m7gd.2xlarge",
+      "azure": "Standard_D8ds_v4",
+      "gcp": "c3d-standard-8-lssd"
+    },
+    {
+      "aws": "m7gd.4xlarge",
+      "azure": "Standard_D16ds_v4",
+      "gcp": "c4a-standard-16-lssd"
+    },
+    {
+      "aws": "m7gd.8xlarge",
+      "azure": "Standard_D32ds_v4",
+      "gcp": "c4a-standard-32-lssd"
+    },
+    {
+      "aws": "m7gd.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "n2-highmem-2"
+    },
+    {
+      "aws": "m7gd.xlarge",
+      "azure": "Standard_D4ds_v4",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "m7i.12xlarge",
+      "azure": "Standard_D48s_v5",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m7i.16xlarge",
+      "azure": "Standard_D64s_v5",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m7i.24xlarge",
+      "azure": "Standard_D96s_v5",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m7i.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m7i.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m7i.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m7i.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "m7i.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m8g.12xlarge",
+      "azure": "Standard_D48s_v5",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m8g.16xlarge",
+      "azure": "Standard_D64s_v5",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m8g.24xlarge",
+      "azure": "Standard_D96s_v5",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m8g.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m8g.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m8g.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m8g.large",
+      "azure": "Standard_D2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "m8g.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m8gd.12xlarge",
+      "azure": "Standard_D48a_v4",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m8gd.16xlarge",
+      "azure": "Standard_D64a_v4",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m8gd.24xlarge",
+      "azure": "Standard_D96a_v4",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m8gd.2xlarge",
+      "azure": "Standard_D8ds_v4",
+      "gcp": "c3d-standard-8-lssd"
+    },
+    {
+      "aws": "m8gd.4xlarge",
+      "azure": "Standard_D16ds_v4",
+      "gcp": "c4a-standard-16-lssd"
+    },
+    {
+      "aws": "m8gd.8xlarge",
+      "azure": "Standard_D32ds_v4",
+      "gcp": "c4a-standard-32-lssd"
+    },
+    {
+      "aws": "m8gd.xlarge",
+      "azure": "Standard_D4ds_v4",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "m8i.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m8i.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m8i.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m8i.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "md-fleet.12xlarge",
+      "azure": "Standard_D48a_v4",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "md-fleet.16xlarge",
+      "azure": "Standard_D64s_v3",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "md-fleet.24xlarge",
+      "azure": "Standard_D96as_v4",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "md-fleet.2xlarge",
+      "azure": "Standard_D8ds_v4",
+      "gcp": "c3d-standard-8-lssd"
+    },
+    {
+      "aws": "md-fleet.4xlarge",
+      "azure": "Standard_D16a_v4",
+      "gcp": "c3d-standard-16-lssd"
+    },
+    {
+      "aws": "md-fleet.8xlarge",
+      "azure": "Standard_D32a_v4",
+      "gcp": "c4a-standard-32-lssd"
+    },
+    {
+      "aws": "md-fleet.xlarge",
+      "azure": "Standard_D4ds_v4",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "mg-fleet.12xlarge",
+      "azure": "Standard_D48s_v5",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "mg-fleet.16xlarge",
+      "azure": "Standard_D64s_v5",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "mg-fleet.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "mg-fleet.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "mg-fleet.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "mg-fleet.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "mgd-fleet.12xlarge",
+      "azure": "Standard_D48a_v4",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "mgd-fleet.16xlarge",
+      "azure": "Standard_D64a_v4",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "mgd-fleet.2xlarge",
+      "azure": "Standard_D8ds_v4",
+      "gcp": "c3d-standard-8-lssd"
+    },
+    {
+      "aws": "mgd-fleet.4xlarge",
+      "azure": "Standard_D16ds_v4",
+      "gcp": "c4a-standard-16-lssd"
+    },
+    {
+      "aws": "mgd-fleet.8xlarge",
+      "azure": "Standard_D32ds_v4",
+      "gcp": "c4a-standard-32-lssd"
+    },
+    {
+      "aws": "mgd-fleet.xlarge",
+      "azure": "Standard_D4ds_v4",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "r-fleet.12xlarge",
+      "azure": "Standard_E48s_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r-fleet.16xlarge",
+      "azure": "Standard_E64s_v5",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r-fleet.24xlarge",
+      "azure": "Standard_E96ds_v6",
+      "gcp": "n2d-highmem-96"
+    },
+    {
+      "aws": "r-fleet.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r-fleet.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r-fleet.8xlarge",
+      "azure": "Standard_E32s_v4",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r-fleet.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r4.16xlarge",
+      "azure": "Standard_E64s_v4",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r4.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r4.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r4.8xlarge",
+      "azure": "Standard_E32s_v4",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r4.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r5.12xlarge",
+      "azure": "Standard_E48s_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r5.16xlarge",
+      "azure": "Standard_E64s_v5",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r5.24xlarge",
+      "azure": "Standard_E96ds_v6",
+      "gcp": "n2d-highmem-96"
+    },
+    {
+      "aws": "r5.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r5.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r5.8xlarge",
+      "azure": "Standard_E32s_v4",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r5.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "r5.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r5a.12xlarge",
+      "azure": "Standard_E48s_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r5a.16xlarge",
+      "azure": "Standard_E64s_v5",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r5a.24xlarge",
+      "azure": "Standard_E96ds_v6",
+      "gcp": "n2d-highmem-96"
+    },
+    {
+      "aws": "r5a.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r5a.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r5a.8xlarge",
+      "azure": "Standard_E32s_v4",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r5a.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "r5a.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r5d.12xlarge",
+      "azure": "Standard_E48as_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r5d.16xlarge",
+      "azure": "Standard_E64as_v4",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r5d.24xlarge",
+      "azure": "Standard_E96ds_v6",
+      "gcp": "n2d-highmem-96"
+    },
+    {
+      "aws": "r5d.2xlarge",
+      "azure": "Standard_E8d_v4",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "r5d.4xlarge",
+      "azure": "Standard_E16s_v3",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "r5d.8xlarge",
+      "azure": "Standard_E32s_v3",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "r5d.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "n2-highmem-2"
+    },
+    {
+      "aws": "r5d.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "r5dn.12xlarge",
+      "azure": "Standard_E48as_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r5dn.16xlarge",
+      "azure": "Standard_E64as_v4",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r5dn.24xlarge",
+      "azure": "Standard_E96ds_v6",
+      "gcp": "n2d-highmem-96"
+    },
+    {
+      "aws": "r5dn.2xlarge",
+      "azure": "Standard_E8d_v4",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "r5dn.4xlarge",
+      "azure": "Standard_E16s_v3",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "r5dn.8xlarge",
+      "azure": "Standard_E32s_v3",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "r5dn.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "n2-highmem-2"
+    },
+    {
+      "aws": "r5dn.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "r5n.12xlarge",
+      "azure": "Standard_E48s_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r5n.16xlarge",
+      "azure": "Standard_E64s_v5",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r5n.24xlarge",
+      "azure": "Standard_E96ds_v6",
+      "gcp": "n2d-highmem-96"
+    },
+    {
+      "aws": "r5n.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r5n.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r5n.8xlarge",
+      "azure": "Standard_E32s_v4",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r5n.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "r5n.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r6g.12xlarge",
+      "azure": "Standard_E48s_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r6g.16xlarge",
+      "azure": "Standard_E64s_v5",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r6g.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r6g.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r6g.8xlarge",
+      "azure": "Standard_E32s_v4",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r6g.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "r6g.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r6gd.12xlarge",
+      "azure": "Standard_E48a_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r6gd.16xlarge",
+      "azure": "Standard_E64a_v4",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r6gd.2xlarge",
+      "azure": "Standard_E8d_v4",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "r6gd.4xlarge",
+      "azure": "Standard_E16d_v4",
+      "gcp": "c4a-highmem-16-lssd"
+    },
+    {
+      "aws": "r6gd.8xlarge",
+      "azure": "Standard_E32d_v4",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "r6gd.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "n2-highmem-2"
+    },
+    {
+      "aws": "r6gd.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "r6i.12xlarge",
+      "azure": "Standard_E48s_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r6i.16xlarge",
+      "azure": "Standard_E64s_v5",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r6i.24xlarge",
+      "azure": "Standard_E96ds_v6",
+      "gcp": "n2d-highmem-96"
+    },
+    {
+      "aws": "r6i.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r6i.32xlarge",
+      "azure": "Standard_E128ds_v6",
+      "gcp": "n2d-highcpu-128"
+    },
+    {
+      "aws": "r6i.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r6i.8xlarge",
+      "azure": "Standard_E32s_v4",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r6i.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "r6i.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r6id.12xlarge",
+      "azure": "Standard_E48a_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r6id.16xlarge",
+      "azure": "Standard_E64a_v4",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r6id.24xlarge",
+      "azure": "Standard_E96ds_v6",
+      "gcp": "n2d-highmem-96"
+    },
+    {
+      "aws": "r6id.2xlarge",
+      "azure": "Standard_E8d_v4",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "r6id.32xlarge",
+      "azure": "Standard_E128ds_v6",
+      "gcp": "n2d-standard-128"
+    },
+    {
+      "aws": "r6id.4xlarge",
+      "azure": "Standard_E16d_v4",
+      "gcp": "c4a-highmem-16-lssd"
+    },
+    {
+      "aws": "r6id.8xlarge",
+      "azure": "Standard_E32d_v4",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "r6id.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "n2-highmem-2"
+    },
+    {
+      "aws": "r6id.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "r6idn.12xlarge",
+      "azure": "Standard_E48a_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r6idn.16xlarge",
+      "azure": "Standard_E64a_v4",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r6idn.24xlarge",
+      "azure": "Standard_E96ds_v6",
+      "gcp": "n2d-highmem-96"
+    },
+    {
+      "aws": "r6idn.2xlarge",
+      "azure": "Standard_E8d_v4",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "r6idn.32xlarge",
+      "azure": "Standard_E128ds_v6",
+      "gcp": "n2d-standard-128"
+    },
+    {
+      "aws": "r6idn.4xlarge",
+      "azure": "Standard_E16d_v4",
+      "gcp": "c4a-highmem-16-lssd"
+    },
+    {
+      "aws": "r6idn.8xlarge",
+      "azure": "Standard_E32d_v4",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "r6idn.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "n2-highmem-2"
+    },
+    {
+      "aws": "r6idn.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "r6in.12xlarge",
+      "azure": "Standard_E48s_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r6in.16xlarge",
+      "azure": "Standard_E64s_v5",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r6in.24xlarge",
+      "azure": "Standard_E96ds_v6",
+      "gcp": "n2d-highmem-96"
+    },
+    {
+      "aws": "r6in.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r6in.32xlarge",
+      "azure": "Standard_E128ds_v6",
+      "gcp": "n2d-highcpu-128"
+    },
+    {
+      "aws": "r6in.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r6in.8xlarge",
+      "azure": "Standard_E32s_v4",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r6in.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "r6in.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r7a.12xlarge",
+      "azure": "Standard_E48s_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r7a.16xlarge",
+      "azure": "Standard_E64s_v5",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r7a.24xlarge",
+      "azure": "Standard_E96ds_v6",
+      "gcp": "n2d-highmem-96"
+    },
+    {
+      "aws": "r7a.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r7a.32xlarge",
+      "azure": "Standard_E128ds_v6",
+      "gcp": "n2d-highcpu-128"
+    },
+    {
+      "aws": "r7a.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r7a.8xlarge",
+      "azure": "Standard_E32s_v4",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r7a.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r7g.12xlarge",
+      "azure": "Standard_E48s_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r7g.16xlarge",
+      "azure": "Standard_E64s_v5",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r7g.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r7g.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r7g.8xlarge",
+      "azure": "Standard_E32s_v4",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r7g.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "r7g.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r7gd.12xlarge",
+      "azure": "Standard_E48a_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r7gd.16xlarge",
+      "azure": "Standard_E64a_v4",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r7gd.2xlarge",
+      "azure": "Standard_E8d_v4",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "r7gd.4xlarge",
+      "azure": "Standard_E16d_v4",
+      "gcp": "c4a-highmem-16-lssd"
+    },
+    {
+      "aws": "r7gd.8xlarge",
+      "azure": "Standard_E32d_v4",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "r7gd.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "n2-highmem-2"
+    },
+    {
+      "aws": "r7gd.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "r7i.12xlarge",
+      "azure": "Standard_E48s_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r7i.16xlarge",
+      "azure": "Standard_E64s_v5",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r7i.24xlarge",
+      "azure": "Standard_E96ds_v6",
+      "gcp": "n2d-highmem-96"
+    },
+    {
+      "aws": "r7i.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r7i.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r7i.8xlarge",
+      "azure": "Standard_E32s_v4",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r7i.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "r7i.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r7iz.12xlarge",
+      "azure": "Standard_E48s_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r7iz.16xlarge",
+      "azure": "Standard_E64s_v5",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r7iz.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r7iz.32xlarge",
+      "azure": "Standard_E128ds_v6",
+      "gcp": "n2d-highcpu-128"
+    },
+    {
+      "aws": "r7iz.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r7iz.8xlarge",
+      "azure": "Standard_E32s_v4",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r7iz.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "r7iz.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r8g.12xlarge",
+      "azure": "Standard_E48s_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r8g.16xlarge",
+      "azure": "Standard_E64s_v5",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r8g.24xlarge",
+      "azure": "Standard_E96ds_v6",
+      "gcp": "n2d-highmem-96"
+    },
+    {
+      "aws": "r8g.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r8g.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r8g.8xlarge",
+      "azure": "Standard_E32s_v4",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r8g.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "r8g.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r8gd.12xlarge",
+      "azure": "Standard_E48as_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r8gd.16xlarge",
+      "azure": "Standard_E64a_v4",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r8gd.24xlarge",
+      "azure": "Standard_E96ds_v6",
+      "gcp": "n2d-highmem-96"
+    },
+    {
+      "aws": "r8gd.2xlarge",
+      "azure": "Standard_E8d_v4",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "r8gd.4xlarge",
+      "azure": "Standard_E16d_v4",
+      "gcp": "c4a-highmem-16-lssd"
+    },
+    {
+      "aws": "r8gd.8xlarge",
+      "azure": "Standard_E32d_v4",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "r8gd.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "r8i.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r8i.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r8i.8xlarge",
+      "azure": "Standard_E32s_v4",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r8i.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "rd-fleet.12xlarge",
+      "azure": "Standard_E48as_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "rd-fleet.16xlarge",
+      "azure": "Standard_E64as_v4",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "rd-fleet.24xlarge",
+      "azure": "Standard_E96ds_v6",
+      "gcp": "n2d-highmem-96"
+    },
+    {
+      "aws": "rd-fleet.2xlarge",
+      "azure": "Standard_E8d_v4",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "rd-fleet.4xlarge",
+      "azure": "Standard_E16s_v3",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "rd-fleet.8xlarge",
+      "azure": "Standard_E32s_v3",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "rd-fleet.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "rg-fleet.12xlarge",
+      "azure": "Standard_E48s_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "rg-fleet.16xlarge",
+      "azure": "Standard_E64s_v5",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "rg-fleet.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "rg-fleet.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "rg-fleet.8xlarge",
+      "azure": "Standard_E32s_v4",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "rg-fleet.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "rgd-fleet.12xlarge",
+      "azure": "Standard_E48a_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "rgd-fleet.16xlarge",
+      "azure": "Standard_E64a_v4",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "rgd-fleet.2xlarge",
+      "azure": "Standard_E8d_v4",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "rgd-fleet.4xlarge",
+      "azure": "Standard_E16d_v4",
+      "gcp": "c4a-highmem-16-lssd"
+    },
+    {
+      "aws": "rgd-fleet.8xlarge",
+      "azure": "Standard_E32d_v4",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "rgd-fleet.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "z1d.12xlarge",
+      "azure": "Standard_E48as_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "z1d.2xlarge",
+      "azure": "Standard_E8d_v4",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "z1d.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "n2-highmem-2"
+    },
+    {
+      "aws": "z1d.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "r4.xlarge",
+      "azure": "Standard_D12_v2",
+      "gcp": "n1-highmem-4"
+    },
+    {
+      "aws": "r4.2xlarge",
+      "azure": "Standard_D13_v2",
+      "gcp": "n1-highmem-8"
+    },
+    {
+      "aws": "r4.4xlarge",
+      "azure": "Standard_D14_v2",
+      "gcp": "n1-highmem-16"
+    },
+    {
+      "aws": "m5d.4xlarge",
+      "azure": "Standard_D16_v3",
+      "gcp": "c3d-standard-16-lssd"
+    },
+    {
+      "aws": "m6gd.4xlarge",
+      "azure": "Standard_D16ads_v5",
+      "gcp": "c3d-standard-16-lssd"
+    },
+    {
+      "aws": "m4.4xlarge",
+      "azure": "Standard_D16ads_v6",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m5d.4xlarge",
+      "azure": "Standard_D16as_v4",
+      "gcp": "c3d-standard-16-lssd"
+    },
+    {
+      "aws": "m4.4xlarge",
+      "azure": "Standard_D16as_v5",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m6gd.4xlarge",
+      "azure": "Standard_D16d_v4",
+      "gcp": "c3d-standard-16-lssd"
+    },
+    {
+      "aws": "m6gd.4xlarge",
+      "azure": "Standard_D16ds_v4",
+      "gcp": "c3d-standard-16-lssd"
+    },
+    {
+      "aws": "m6gd.4xlarge",
+      "azure": "Standard_D16ds_v5",
+      "gcp": "c3d-standard-16-lssd"
+    },
+    {
+      "aws": "m4.4xlarge",
+      "azure": "Standard_D16ds_v6",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m4.4xlarge",
+      "azure": "Standard_D16pds_v6",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "c5.4xlarge",
+      "azure": "Standard_D16plds_v6",
+      "gcp": "n1-highcpu-16"
+    },
+    {
+      "aws": "c5.4xlarge",
+      "azure": "Standard_D16pls_v6",
+      "gcp": "n1-highcpu-16"
+    },
+    {
+      "aws": "m4.4xlarge",
+      "azure": "Standard_D16ps_v6",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m5d.4xlarge",
+      "azure": "Standard_D16s_v3",
+      "gcp": "c3d-standard-16-lssd"
+    },
+    {
+      "aws": "m4.4xlarge",
+      "azure": "Standard_D16s_v4",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m4.large",
+      "azure": "Standard_D2ds_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "m5d.8xlarge",
+      "azure": "Standard_D32_v3",
+      "gcp": "c4a-standard-32-lssd"
+    },
+    {
+      "aws": "m6gd.8xlarge",
+      "azure": "Standard_D32ads_v5",
+      "gcp": "c4a-standard-32-lssd"
+    },
+    {
+      "aws": "m5.8xlarge",
+      "azure": "Standard_D32ads_v6",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m5d.8xlarge",
+      "azure": "Standard_D32as_v4",
+      "gcp": "c4a-standard-32-lssd"
+    },
+    {
+      "aws": "m5.8xlarge",
+      "azure": "Standard_D32as_v5",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m6gd.8xlarge",
+      "azure": "Standard_D32d_v4",
+      "gcp": "c4a-standard-32-lssd"
+    },
+    {
+      "aws": "m6gd.8xlarge",
+      "azure": "Standard_D32ds_v5",
+      "gcp": "c4a-standard-32-lssd"
+    },
+    {
+      "aws": "m5.8xlarge",
+      "azure": "Standard_D32ds_v6",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m5.8xlarge",
+      "azure": "Standard_D32pds_v6",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "c6g.8xlarge",
+      "azure": "Standard_D32plds_v6",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "c6g.8xlarge",
+      "azure": "Standard_D32pls_v6",
+      "gcp": "n1-highcpu-32"
+    },
+    {
+      "aws": "m5.8xlarge",
+      "azure": "Standard_D32ps_v6",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m5d.8xlarge",
+      "azure": "Standard_D32s_v3",
+      "gcp": "c4a-standard-32-lssd"
+    },
+    {
+      "aws": "m5.8xlarge",
+      "azure": "Standard_D32s_v4",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "azure": "Standard_D3_v2",
+      "gcp": "n1-standard-4",
+      "aws": "m6gd.xlarge"
+    },
+    {
+      "aws": "m6gd.12xlarge",
+      "azure": "Standard_D48ads_v5",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m5.12xlarge",
+      "azure": "Standard_D48ads_v6",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m5d.12xlarge",
+      "azure": "Standard_D48as_v4",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m5.12xlarge",
+      "azure": "Standard_D48as_v5",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m6gd.12xlarge",
+      "azure": "Standard_D48d_v4",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m6gd.12xlarge",
+      "azure": "Standard_D48ds_v4",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m6gd.12xlarge",
+      "azure": "Standard_D48ds_v5",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m5.12xlarge",
+      "azure": "Standard_D48ds_v6",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m5.12xlarge",
+      "azure": "Standard_D48pds_v6",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "c5.12xlarge",
+      "azure": "Standard_D48pls_v6",
+      "gcp": "n2-highcpu-48"
+    },
+    {
+      "aws": "m5.12xlarge",
+      "azure": "Standard_D48ps_v6",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m5.12xlarge",
+      "azure": "Standard_D48s_v4",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "azure": "Standard_D4_v2",
+      "gcp": "n1-standard-8",
+      "aws": "m6gd.2xlarge"
+    },
+    {
+      "aws": "m5d.xlarge",
+      "azure": "Standard_D4a_v4",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "m5d.xlarge",
+      "azure": "Standard_D4ads_v5",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "m4.xlarge",
+      "azure": "Standard_D4ads_v6",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m4.xlarge",
+      "azure": "Standard_D4as_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m5d.xlarge",
+      "azure": "Standard_D4d_v4",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "m5d.xlarge",
+      "azure": "Standard_D4ds_v5",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "m4.xlarge",
+      "azure": "Standard_D4ds_v6",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m4.xlarge",
+      "azure": "Standard_D4pds_v6",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "c5.xlarge",
+      "azure": "Standard_D4plds_v6",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c5.xlarge",
+      "azure": "Standard_D4pls_v6",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "m4.xlarge",
+      "azure": "Standard_D4ps_v6",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m5d.xlarge",
+      "azure": "Standard_D4s_v3",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "m4.xlarge",
+      "azure": "Standard_D4s_v4",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "azure": "Standard_D5_v2",
+      "gcp": "n1-standard-16",
+      "aws": "m6gd.4xlarge"
+    },
+    {
+      "aws": "m6gd.16xlarge",
+      "azure": "Standard_D64_v3",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m6gd.16xlarge",
+      "azure": "Standard_D64ads_v5",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m4.16xlarge",
+      "azure": "Standard_D64ads_v6",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m5d.16xlarge",
+      "azure": "Standard_D64as_v4",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m4.16xlarge",
+      "azure": "Standard_D64as_v5",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m6gd.16xlarge",
+      "azure": "Standard_D64d_v4",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m6gd.16xlarge",
+      "azure": "Standard_D64ds_v4",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m6gd.16xlarge",
+      "azure": "Standard_D64ds_v5",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m4.16xlarge",
+      "azure": "Standard_D64ds_v6",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m4.16xlarge",
+      "azure": "Standard_D64pds_v6",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "c6g.16xlarge",
+      "azure": "Standard_D64plds_v6",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "c6g.16xlarge",
+      "azure": "Standard_D64pls_v6",
+      "gcp": "n1-highcpu-64"
+    },
+    {
+      "aws": "m4.16xlarge",
+      "azure": "Standard_D64ps_v6",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m4.16xlarge",
+      "azure": "Standard_D64s_v4",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m5d.2xlarge",
+      "azure": "Standard_D8_v3",
+      "gcp": "c3d-standard-8-lssd"
+    },
+    {
+      "aws": "m5d.2xlarge",
+      "azure": "Standard_D8a_v4",
+      "gcp": "c3d-standard-8-lssd"
+    },
+    {
+      "aws": "m5d.2xlarge",
+      "azure": "Standard_D8ads_v5",
+      "gcp": "c3d-standard-8-lssd"
+    },
+    {
+      "aws": "m4.2xlarge",
+      "azure": "Standard_D8ads_v6",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m5d.2xlarge",
+      "azure": "Standard_D8as_v4",
+      "gcp": "c3-standard-8-lssd"
+    },
+    {
+      "aws": "m4.2xlarge",
+      "azure": "Standard_D8as_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m5d.2xlarge",
+      "azure": "Standard_D8d_v4",
+      "gcp": "c3d-standard-8-lssd"
+    },
+    {
+      "aws": "m5d.2xlarge",
+      "azure": "Standard_D8ds_v5",
+      "gcp": "c3d-standard-8-lssd"
+    },
+    {
+      "aws": "m4.2xlarge",
+      "azure": "Standard_D8ds_v6",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m4.2xlarge",
+      "azure": "Standard_D8pds_v6",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "c5.2xlarge",
+      "azure": "Standard_D8plds_v6",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c5.2xlarge",
+      "azure": "Standard_D8pls_v6",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "m4.2xlarge",
+      "azure": "Standard_D8ps_v6",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m5d.2xlarge",
+      "azure": "Standard_D8s_v3",
+      "gcp": "c3-standard-8-lssd"
+    },
+    {
+      "aws": "m4.2xlarge",
+      "azure": "Standard_D8s_v4",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m8gd.24xlarge",
+      "azure": "Standard_D96ads_v5",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m5.24xlarge",
+      "azure": "Standard_D96ads_v6",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m5.24xlarge",
+      "azure": "Standard_D96as_v5",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m8gd.24xlarge",
+      "azure": "Standard_D96ds_v5",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m5.24xlarge",
+      "azure": "Standard_D96ds_v6",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m5.24xlarge",
+      "azure": "Standard_D96pds_v6",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "c5.24xlarge",
+      "azure": "Standard_D96pls_v6",
+      "gcp": "n1-highcpu-96"
+    },
+    {
+      "aws": "m5.24xlarge",
+      "azure": "Standard_D96ps_v6",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m6gd.4xlarge",
+      "azure": "Standard_DC16ads_v6",
+      "gcp": "c3d-standard-16-lssd"
+    },
+    {
+      "aws": "m4.4xlarge",
+      "azure": "Standard_DC16as_v5",
+      "gcp": "c3d-standard-16"
+    },
+    {
+      "aws": "m6gd.8xlarge",
+      "azure": "Standard_DC32ads_v6",
+      "gcp": "c4a-standard-32-lssd"
+    },
+    {
+      "aws": "m5.8xlarge",
+      "azure": "Standard_DC32as_v5",
+      "gcp": "c4a-standard-32"
+    },
+    {
+      "aws": "m6gd.12xlarge",
+      "azure": "Standard_DC48ads_v6",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m5d.xlarge",
+      "azure": "Standard_DC4ads_v6",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "m4.xlarge",
+      "azure": "Standard_DC4as_v5",
+      "gcp": "c3-standard-4"
+    },
+    {
+      "aws": "m6gd.16xlarge",
+      "azure": "Standard_DC64ads_v6",
+      "gcp": "n2-standard-64"
+    },
+    {
+      "aws": "m5d.2xlarge",
+      "azure": "Standard_DC8ads_v6",
+      "gcp": "c3d-standard-8-lssd"
+    },
+    {
+      "aws": "m4.2xlarge",
+      "azure": "Standard_DC8as_v5",
+      "gcp": "c3-standard-8"
+    },
+    {
+      "aws": "m8gd.24xlarge",
+      "azure": "Standard_DC96ads_v6",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "r4.xlarge",
+      "azure": "Standard_DS12_v2",
+      "gcp": "n1-highmem-4"
+    },
+    {
+      "aws": "r4.2xlarge",
+      "azure": "Standard_DS13_v2",
+      "gcp": "n1-highmem-8"
+    },
+    {
+      "aws": "r4.4xlarge",
+      "azure": "Standard_DS14_v2",
+      "gcp": "n1-highmem-16"
+    },
+    {
+      "azure": "Standard_DS3_v2",
+      "gcp": "n1-standard-4",
+      "aws": "m5d.xlarge"
+    },
+    {
+      "azure": "Standard_DS4_v2",
+      "gcp": "n1-standard-8",
+      "aws": "m5d.2xlarge"
+    },
+    {
+      "azure": "Standard_DS5_v2",
+      "gcp": "n1-standard-16",
+      "aws": "m5d.4xlarge"
+    },
+    {
+      "aws": "r5d.4xlarge",
+      "azure": "Standard_E16_v3",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "r5d.4xlarge",
+      "azure": "Standard_E16a_v4",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "r6gd.4xlarge",
+      "azure": "Standard_E16ads_v5",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "r5.4xlarge",
+      "azure": "Standard_E16ads_v6",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r5d.4xlarge",
+      "azure": "Standard_E16as_v4",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "r5.4xlarge",
+      "azure": "Standard_E16as_v5",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r6gd.4xlarge",
+      "azure": "Standard_E16d_v4",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "r6gd.4xlarge",
+      "azure": "Standard_E16ds_v4",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "r6gd.4xlarge",
+      "azure": "Standard_E16ds_v5",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "r5.4xlarge",
+      "azure": "Standard_E16ds_v6",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r5.4xlarge",
+      "azure": "Standard_E16pds_v6",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r5.4xlarge",
+      "azure": "Standard_E16ps_v6",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r5.4xlarge",
+      "azure": "Standard_E16s_v5",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "aws": "r5.large",
+      "azure": "Standard_E2ds_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "r5.large",
+      "azure": "Standard_E2pds_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "r5.large",
+      "azure": "Standard_E2ps_v6",
+      "gcp": "e2-highmem-2"
+    },
+    {
+      "aws": "r5d.8xlarge",
+      "azure": "Standard_E32_v3",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "r5d.8xlarge",
+      "azure": "Standard_E32a_v4",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "r6gd.8xlarge",
+      "azure": "Standard_E32ads_v5",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "r5.8xlarge",
+      "azure": "Standard_E32ads_v6",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r5d.8xlarge",
+      "azure": "Standard_E32as_v4",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "r5.8xlarge",
+      "azure": "Standard_E32as_v5",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r6gd.8xlarge",
+      "azure": "Standard_E32ds_v4",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "r6gd.8xlarge",
+      "azure": "Standard_E32ds_v5",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "r5.8xlarge",
+      "azure": "Standard_E32ds_v6",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r5.8xlarge",
+      "azure": "Standard_E32pds_v6",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r5.8xlarge",
+      "azure": "Standard_E32ps_v6",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r5.8xlarge",
+      "azure": "Standard_E32s_v5",
+      "gcp": "c4a-highmem-32"
+    },
+    {
+      "aws": "r6gd.12xlarge",
+      "azure": "Standard_E48ads_v5",
+      "gcp": "n2-highmem-48"
+    },
+    {
+      "aws": "r5.12xlarge",
+      "azure": "Standard_E48ads_v6",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r5.12xlarge",
+      "azure": "Standard_E48as_v5",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r6gd.12xlarge",
+      "azure": "Standard_E48d_v4",
+      "gcp": "n2-highmem-48"
+    },
+    {
+      "aws": "r6gd.12xlarge",
+      "azure": "Standard_E48ds_v4",
+      "gcp": "n2-highmem-48"
+    },
+    {
+      "aws": "r6gd.12xlarge",
+      "azure": "Standard_E48ds_v5",
+      "gcp": "n2-highmem-48"
+    },
+    {
+      "aws": "r5.12xlarge",
+      "azure": "Standard_E48ds_v6",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r5.12xlarge",
+      "azure": "Standard_E48pds_v6",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r5.12xlarge",
+      "azure": "Standard_E48ps_v6",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r5.12xlarge",
+      "azure": "Standard_E48s_v5",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r5d.xlarge",
+      "azure": "Standard_E4a_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "r5d.xlarge",
+      "azure": "Standard_E4ads_v5",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "r5.xlarge",
+      "azure": "Standard_E4ads_v6",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r5d.xlarge",
+      "azure": "Standard_E4as_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "r5.xlarge",
+      "azure": "Standard_E4as_v5",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r5d.xlarge",
+      "azure": "Standard_E4ds_v4",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "r5d.xlarge",
+      "azure": "Standard_E4ds_v5",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "r5.xlarge",
+      "azure": "Standard_E4ds_v6",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r5.xlarge",
+      "azure": "Standard_E4pds_v6",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r5.xlarge",
+      "azure": "Standard_E4ps_v6",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "aws": "r5.xlarge",
+      "azure": "Standard_E4s_v5",
+      "gcp": "c3-highmem-4"
+    },
+    {
+      "azure": "Standard_E64_v3",
+      "gcp": "n1-highmem-64",
+      "aws": "r6gd.16xlarge"
+    },
+    {
+      "aws": "r6gd.16xlarge",
+      "azure": "Standard_E64ads_v5",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r5.16xlarge",
+      "azure": "Standard_E64ads_v6",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r5.16xlarge",
+      "azure": "Standard_E64as_v5",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r6gd.16xlarge",
+      "azure": "Standard_E64d_v4",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r6gd.16xlarge",
+      "azure": "Standard_E64ds_v4",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r6gd.16xlarge",
+      "azure": "Standard_E64ds_v5",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r5.16xlarge",
+      "azure": "Standard_E64ds_v6",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r5.16xlarge",
+      "azure": "Standard_E64pds_v6",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r5.16xlarge",
+      "azure": "Standard_E64ps_v6",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "azure": "Standard_E64s_v3",
+      "gcp": "n1-highmem-64",
+      "aws": "r5d.16xlarge"
+    },
+    {
+      "aws": "r5.16xlarge",
+      "azure": "Standard_E64s_v4",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r5d.2xlarge",
+      "azure": "Standard_E8_v3",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "r5d.2xlarge",
+      "azure": "Standard_E8a_v4",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "r5d.2xlarge",
+      "azure": "Standard_E8ads_v5",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "r5.2xlarge",
+      "azure": "Standard_E8ads_v6",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r5d.2xlarge",
+      "azure": "Standard_E8as_v4",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "r5.2xlarge",
+      "azure": "Standard_E8as_v5",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r5d.2xlarge",
+      "azure": "Standard_E8ds_v4",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "r5d.2xlarge",
+      "azure": "Standard_E8ds_v5",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "r5.2xlarge",
+      "azure": "Standard_E8ds_v6",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r5.2xlarge",
+      "azure": "Standard_E8pds_v6",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r5.2xlarge",
+      "azure": "Standard_E8ps_v6",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "aws": "r5d.2xlarge",
+      "azure": "Standard_E8s_v3",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "r5.2xlarge",
+      "azure": "Standard_E8s_v5",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "azure": "Standard_E96a_v4",
+      "gcp": "n1-highmem-96",
+      "aws": "r8gd.24xlarge"
+    },
+    {
+      "azure": "Standard_E96ads_v5",
+      "gcp": "n1-highmem-96",
+      "aws": "r8gd.24xlarge"
+    },
+    {
+      "azure": "Standard_E96ads_v6",
+      "gcp": "n1-highmem-96",
+      "aws": "r5.24xlarge"
+    },
+    {
+      "azure": "Standard_E96as_v4",
+      "gcp": "n1-highmem-96",
+      "aws": "r6id.24xlarge"
+    },
+    {
+      "azure": "Standard_E96as_v5",
+      "gcp": "n1-highmem-96",
+      "aws": "r5.24xlarge"
+    },
+    {
+      "azure": "Standard_E96ds_v5",
+      "gcp": "n1-highmem-96",
+      "aws": "r8gd.24xlarge"
+    },
+    {
+      "azure": "Standard_E96pds_v6",
+      "gcp": "n1-highmem-96",
+      "aws": "r5.24xlarge"
+    },
+    {
+      "azure": "Standard_E96ps_v6",
+      "gcp": "n1-highmem-96",
+      "aws": "r5.24xlarge"
+    },
+    {
+      "azure": "Standard_E96s_v5",
+      "gcp": "n1-highmem-96",
+      "aws": "r5.24xlarge"
+    },
+    {
+      "aws": "r6gd.4xlarge",
+      "azure": "Standard_EC16ads_v5",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "r6gd.4xlarge",
+      "azure": "Standard_EC16ads_v6",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "r5.4xlarge",
+      "azure": "Standard_EC16as_v5",
+      "gcp": "c3d-highmem-16"
+    },
+    {
+      "azure": "Standard_EC32ads_v5",
+      "gcp": "n1-highmem-32",
+      "aws": "r6gd.8xlarge"
+    },
+    {
+      "aws": "r6gd.8xlarge",
+      "azure": "Standard_EC32ads_v6",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "azure": "Standard_EC32as_v5",
+      "gcp": "n1-highmem-32",
+      "aws": "r4.8xlarge"
+    },
+    {
+      "aws": "r6gd.12xlarge",
+      "azure": "Standard_EC48ads_v6",
+      "gcp": "n2-highmem-48"
+    },
+    {
+      "aws": "r5d.xlarge",
+      "azure": "Standard_EC4ads_v6",
+      "gcp": "c4a-highmem-4-lssd"
+    },
+    {
+      "aws": "r6gd.16xlarge",
+      "azure": "Standard_EC64ads_v6",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r5d.2xlarge",
+      "azure": "Standard_EC8ads_v5",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "r5d.2xlarge",
+      "azure": "Standard_EC8ads_v6",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "r5.2xlarge",
+      "azure": "Standard_EC8as_v5",
+      "gcp": "c3-highmem-8"
+    },
+    {
+      "azure": "Standard_EC96ads_v6",
+      "gcp": "n1-highmem-96",
+      "aws": "r8gd.24xlarge"
+    },
+    {
+      "aws": "c5d.4xlarge",
+      "azure": "Standard_F16s",
+      "gcp": "c2-standard-16"
+    },
+    {
+      "aws": "c5d.4xlarge",
+      "azure": "Standard_F16s_v2",
+      "gcp": "c2-standard-16"
+    },
+    {
+      "aws": "c5d.xlarge",
+      "azure": "Standard_F4s",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c5d.xlarge",
+      "azure": "Standard_F4s_v2",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "c5d.2xlarge",
+      "azure": "Standard_F8s",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "c5d.2xlarge",
+      "azure": "Standard_F8s_v2",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "i3.4xlarge",
+      "azure": "Standard_H16",
+      "gcp": "n1-highmem-16"
+    },
+    {
+      "aws": "i2.2xlarge",
+      "azure": "Standard_H8",
+      "gcp": "n1-highmem-8"
+    },
+    {
+      "aws": "i4i.4xlarge",
+      "azure": "Standard_L16as_v3",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "i4i.4xlarge",
+      "azure": "Standard_L16s_v3",
+      "gcp": "c3d-highmem-16-lssd"
+    },
+    {
+      "aws": "i4i.8xlarge",
+      "azure": "Standard_L32as_v3",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "i4i.8xlarge",
+      "azure": "Standard_L32s_v2",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "i4i.8xlarge",
+      "azure": "Standard_L32s_v3",
+      "gcp": "c4a-highmem-32-lssd"
+    },
+    {
+      "aws": "i3en.12xlarge",
+      "azure": "Standard_L48as_v3",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "i4i.16xlarge",
+      "azure": "Standard_L64as_v3",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "i4i.16xlarge",
+      "azure": "Standard_L64s_v3",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "azure": "Standard_L80as_v3",
+      "gcp": "n2-highmem-80"
+    },
+    {
+      "azure": "Standard_L80s_v2",
+      "gcp": "n2-highmem-80"
+    },
+    {
+      "azure": "Standard_L80s_v3",
+      "gcp": "n2-highmem-80"
+    },
+    {
+      "aws": "i4i.2xlarge",
+      "azure": "Standard_L8as_v3",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "i4i.2xlarge",
+      "azure": "Standard_L8s_v3",
+      "gcp": "c3d-highmem-8-lssd"
+    },
+    {
+      "aws": "m6gd.4xlarge",
+      "azure": "Standard_D16s_v3",
+      "gcp": "c2-standard-16"
+    },
+    {
+      "aws": "m5d.xlarge",
+      "azure": "Standard_D4s_v3",
+      "gcp": "c2-standard-4"
+    },
+    {
+      "aws": "m6gd.2xlarge",
+      "azure": "Standard_D8s_v3",
+      "gcp": "c2-standard-8"
+    },
+    {
+      "aws": "m6gd.xlarge",
+      "azure": "Standard_D4s_v3",
+      "gcp": "c3-standard-4-lssd"
+    },
+    {
+      "aws": "m6gd.2xlarge",
+      "azure": "Standard_D8s_v3",
+      "gcp": "c3-standard-8-lssd"
+    },
+    {
+      "aws": "r5.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c3d-highmem-4"
+    },
+    {
+      "aws": "r5.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c3d-highmem-8"
+    },
+    {
+      "aws": "m4.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c3d-standard-4"
+    },
+    {
+      "aws": "m4.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c3d-standard-8"
+    },
+    {
+      "aws": "m4.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c4-standard-16"
+    },
+    {
+      "aws": "m5.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "c4-standard-32"
+    },
+    {
+      "aws": "m4.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c4-standard-4"
+    },
+    {
+      "aws": "m4.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c4-standard-8"
+    },
+    {
+      "aws": "r5.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "c4a-highmem-16"
+    },
+    {
+      "aws": "r6gd.4xlarge",
+      "azure": "Standard_E16_v3",
+      "gcp": "c4a-highmem-16-lssd"
+    },
+    {
+      "aws": "r5.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "c4a-highmem-4"
+    },
+    {
+      "aws": "r5d.12xlarge",
+      "azure": "Standard_E48d_v4",
+      "gcp": "c4a-highmem-48-lssd"
+    },
+    {
+      "aws": "r5d.16xlarge",
+      "azure": "Standard_E64a_v4",
+      "gcp": "c4a-highmem-64-lssd"
+    },
+    {
+      "aws": "r5.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "c4a-highmem-8"
+    },
+    {
+      "aws": "r6gd.2xlarge",
+      "azure": "Standard_E8_v3",
+      "gcp": "c4a-highmem-8-lssd"
+    },
+    {
+      "aws": "m4.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c4a-standard-16"
+    },
+    {
+      "aws": "m6gd.4xlarge",
+      "azure": "Standard_D16s_v3",
+      "gcp": "c4a-standard-16-lssd"
+    },
+    {
+      "aws": "m4.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c4a-standard-4"
+    },
+    {
+      "aws": "m6gd.xlarge",
+      "azure": "Standard_D4s_v3",
+      "gcp": "c4a-standard-4-lssd"
+    },
+    {
+      "aws": "m4.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c4a-standard-8"
+    },
+    {
+      "aws": "m6gd.2xlarge",
+      "azure": "Standard_D8s_v3",
+      "gcp": "c4a-standard-8-lssd"
+    },
+    {
+      "aws": "m4.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "c4d-standard-16"
+    },
+    {
+      "aws": "m5.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "c4d-standard-32"
+    },
+    {
+      "aws": "m4.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "c4d-standard-4"
+    },
+    {
+      "aws": "m4.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "c4d-standard-8"
+    },
+    {
+      "aws": "r5.4xlarge",
+      "azure": "Standard_E16s_v4",
+      "gcp": "e2-highmem-16"
+    },
+    {
+      "aws": "r5.xlarge",
+      "azure": "Standard_E4s_v4",
+      "gcp": "e2-highmem-4"
+    },
+    {
+      "aws": "r5.2xlarge",
+      "azure": "Standard_E8s_v4",
+      "gcp": "e2-highmem-8"
+    },
+    {
+      "aws": "m4.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "e2-standard-16"
+    },
+    {
+      "aws": "m5.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "e2-standard-32"
+    },
+    {
+      "aws": "m4.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "e2-standard-4"
+    },
+    {
+      "aws": "m4.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "e2-standard-8"
+    },
+    {
+      "azure": "Standard_D14_v2",
+      "gcp": "n1-highmem-16",
+      "aws": "r4.4xlarge"
+    },
+    {
+      "azure": "Standard_D12_v2",
+      "gcp": "n1-highmem-4",
+      "aws": "r4.xlarge"
+    },
+    {
+      "azure": "Standard_D13_v2",
+      "gcp": "n1-highmem-8",
+      "aws": "r4.2xlarge"
+    },
+    {
+      "aws": "m6gd.4xlarge",
+      "azure": "Standard_D5_v2",
+      "gcp": "n1-standard-16"
+    },
+    {
+      "aws": "m6gd.8xlarge",
+      "azure": "Standard_D32ds_v4",
+      "gcp": "n1-standard-32"
+    },
+    {
+      "aws": "m6gd.xlarge",
+      "azure": "Standard_D3_v2",
+      "gcp": "n1-standard-4"
+    },
+    {
+      "aws": "m5d.16xlarge",
+      "azure": "Standard_D64s_v3",
+      "gcp": "n1-standard-64"
+    },
+    {
+      "aws": "m6gd.2xlarge",
+      "azure": "Standard_D4_v2",
+      "gcp": "n1-standard-8"
+    },
+    {
+      "aws": "m5d.24xlarge",
+      "azure": "Standard_D96ds_v5",
+      "gcp": "n1-standard-96"
+    },
+    {
+      "aws": "r6gd.4xlarge",
+      "azure": "Standard_E16_v3",
+      "gcp": "n2-highmem-16"
+    },
+    {
+      "aws": "r6gd.8xlarge",
+      "azure": "Standard_E32_v3",
+      "gcp": "n2-highmem-32"
+    },
+    {
+      "aws": "r6gd.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "n2-highmem-4"
+    },
+    {
+      "aws": "r5d.12xlarge",
+      "azure": "Standard_E48d_v4",
+      "gcp": "n2-highmem-48"
+    },
+    {
+      "aws": "r5d.16xlarge",
+      "azure": "Standard_E64a_v4",
+      "gcp": "n2-highmem-64"
+    },
+    {
+      "aws": "r6gd.2xlarge",
+      "azure": "Standard_E8_v3",
+      "gcp": "n2-highmem-8"
+    },
+    {
+      "aws": "m6gd.4xlarge",
+      "azure": "Standard_D16s_v3",
+      "gcp": "n2-standard-16"
+    },
+    {
+      "aws": "m6gd.8xlarge",
+      "azure": "Standard_D32s_v3",
+      "gcp": "n2-standard-32"
+    },
+    {
+      "aws": "m6gd.xlarge",
+      "azure": "Standard_D4s_v3",
+      "gcp": "n2-standard-4"
+    },
+    {
+      "aws": "m5d.12xlarge",
+      "azure": "Standard_D48ds_v4",
+      "gcp": "n2-standard-48"
+    },
+    {
+      "aws": "m6gd.2xlarge",
+      "azure": "Standard_D8s_v3",
+      "gcp": "n2-standard-8"
+    },
+    {
+      "aws": "r6gd.4xlarge",
+      "azure": "Standard_E16_v3",
+      "gcp": "n2d-highmem-16"
+    },
+    {
+      "aws": "r5d.large",
+      "azure": "Standard_E2ads_v6",
+      "gcp": "n2d-highmem-2"
+    },
+    {
+      "aws": "r6gd.8xlarge",
+      "azure": "Standard_E32_v3",
+      "gcp": "n2d-highmem-32"
+    },
+    {
+      "aws": "r6gd.xlarge",
+      "azure": "Standard_E4d_v4",
+      "gcp": "n2d-highmem-4"
+    },
+    {
+      "aws": "r5d.12xlarge",
+      "azure": "Standard_E48d_v4",
+      "gcp": "n2d-highmem-48"
+    },
+    {
+      "aws": "r5d.16xlarge",
+      "azure": "Standard_E64a_v4",
+      "gcp": "n2d-highmem-64"
+    },
+    {
+      "aws": "r6gd.2xlarge",
+      "azure": "Standard_E8_v3",
+      "gcp": "n2d-highmem-8"
+    },
+    {
+      "azure": "Standard_L80s_v2",
+      "gcp": "n2d-highmem-80"
+    },
+    {
+      "aws": "m6gd.4xlarge",
+      "azure": "Standard_D16s_v3",
+      "gcp": "n2d-standard-16"
+    },
+    {
+      "aws": "m6gd.8xlarge",
+      "azure": "Standard_D32s_v3",
+      "gcp": "n2d-standard-32"
+    },
+    {
+      "aws": "m6gd.xlarge",
+      "azure": "Standard_D4s_v3",
+      "gcp": "n2d-standard-4"
+    },
+    {
+      "aws": "m5d.12xlarge",
+      "azure": "Standard_D48ds_v4",
+      "gcp": "n2d-standard-48"
+    },
+    {
+      "aws": "m5d.16xlarge",
+      "azure": "Standard_D64s_v3",
+      "gcp": "n2d-standard-64"
+    },
+    {
+      "aws": "m6gd.2xlarge",
+      "azure": "Standard_D8s_v3",
+      "gcp": "n2d-standard-8"
+    },
+    {
+      "aws": "m5d.24xlarge",
+      "azure": "Standard_D96ds_v5",
+      "gcp": "n2d-standard-96"
+    },
+    {
+      "aws": "m4.4xlarge",
+      "azure": "Standard_D16s_v5",
+      "gcp": "n4-standard-16"
+    },
+    {
+      "aws": "m5.8xlarge",
+      "azure": "Standard_D32s_v5",
+      "gcp": "n4-standard-32"
+    },
+    {
+      "aws": "m4.xlarge",
+      "azure": "Standard_D4s_v5",
+      "gcp": "n4-standard-4"
+    },
+    {
+      "aws": "m4.2xlarge",
+      "azure": "Standard_D8s_v5",
+      "gcp": "n4-standard-8"
+    }
+  ]
+}



Test patch:
diff --git a/catalog/resource_catalog_test.go b/catalog/resource_catalog_test.go
index b82f3944..4c8d3d4c 100644
--- a/catalog/resource_catalog_test.go
+++ b/catalog/resource_catalog_test.go
@@ -601,11 +601,13 @@ func TestCatalogCreateDeltaSharing(t *testing.T) {
 				ProviderName: "foo",
 				ShareName:    "bar",
 			}).Return(&catalog.CatalogInfo{
-				Name:         "a",
-				Comment:      "b",
-				Properties:   map[string]string{"c": "d"},
-				ProviderName: "foo",
-				ShareName:    "bar",
+				Name:                         "a",
+				Comment:                      "b",
+				Properties:                   map[string]string{"c": "d"},
+				ProviderName:                 "foo",
+				ShareName:                    "bar",
+				CatalogType:                  "DELTASHARING_CATALOG",
+				EnablePredictiveOptimization: "INHERIT",
 			}, nil)
 			e.GetByName(mock.Anything, "a").Return(&catalog.CatalogInfo{
 				Name:         "a",
@@ -626,7 +628,14 @@ func TestCatalogCreateDeltaSharing(t *testing.T) {
 		provider_name = "foo"
 		share_name = "bar"
 		`,
-	}.ApplyNoError(t)
+	}.ApplyAndExpectData(t, map[string]any{
+		"id":                             "a",
+		"name":                           "a",
+		"comment":                        "b",
+		"provider_name":                  "foo",
+		"share_name":                     "bar",
+		"enable_predictive_optimization": "",
+	})
 }
 
 func TestCatalogCreateForeign(t *testing.T) {
@@ -833,6 +842,7 @@ func TestCatalogSuppressCaseSensitivity(t *testing.T) {
 			"securable_type":                 {Old: "", New: "", NewComputed: true, NewRemoved: false, RequiresNew: false, Sensitive: false},
 			"catalog_type":                   {Old: "", New: "", NewComputed: true, NewRemoved: false, RequiresNew: false, Sensitive: false},
 			"storage_location":               {Old: "", New: "", NewComputed: true, NewRemoved: false, RequiresNew: false, Sensitive: false},
+			"provisioning_info.#":            {Old: "", New: "", NewComputed: true, NewRemoved: false, RequiresNew: false, Sensitive: false},
 			"effective_predictive_optimization_flag.#": {Old: "", New: "", NewComputed: true, NewRemoved: false, RequiresNew: false, Sensitive: false},
 			"full_name": {Old: "", New: "", NewComputed: true, NewRemoved: false, RequiresNew: false, Sensitive: false},
 		},
diff --git a/exporter/cloud_utils_test.go b/exporter/cloud_utils_test.go
new file mode 100644
index 00000000..126919f1
--- /dev/null
+++ b/exporter/cloud_utils_test.go
@@ -0,0 +1,725 @@
+package exporter
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/databricks/databricks-sdk-go/client"
+	"github.com/databricks/databricks-sdk-go/config"
+	"github.com/databricks/terraform-provider-databricks/common"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetSourceCloud(t *testing.T) {
+	tests := []struct {
+		name     string
+		host     string
+		expected string
+	}{
+		{
+			name:     "AWS workspace",
+			host:     "https://test.cloud.databricks.com",
+			expected: "aws",
+		},
+		{
+			name:     "Azure workspace",
+			host:     "https://adb-123.azuredatabricks.net",
+			expected: "azure",
+		},
+		{
+			name:     "GCP workspace",
+			host:     "https://test.gcp.databricks.com",
+			expected: "gcp",
+		},
+		{
+			name:     "AWS accounts",
+			host:     "https://accounts.cloud.databricks.com",
+			expected: "aws",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			client := &common.DatabricksClient{
+				DatabricksClient: &client.DatabricksClient{
+					Config: &config.Config{
+						Host: tt.host,
+					},
+				},
+			}
+			ic := &importContext{Client: client}
+			result := ic.getSourceCloud()
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestConvertAvailability(t *testing.T) {
+	tests := []struct {
+		name         string
+		availability string
+		sourceCloud  string
+		targetCloud  string
+		expected     string
+	}{
+		{
+			name:         "AWS SPOT to Azure",
+			availability: "SPOT",
+			sourceCloud:  "aws",
+			targetCloud:  "azure",
+			expected:     "SPOT_AZURE",
+		},
+		{
+			name:         "AWS ON_DEMAND to GCP",
+			availability: "ON_DEMAND",
+			sourceCloud:  "aws",
+			targetCloud:  "gcp",
+			expected:     "ON_DEMAND_GCP",
+		},
+		{
+			name:         "Azure SPOT_WITH_FALLBACK_AZURE to AWS",
+			availability: "SPOT_WITH_FALLBACK_AZURE",
+			sourceCloud:  "azure",
+			targetCloud:  "aws",
+			expected:     "SPOT_WITH_FALLBACK",
+		},
+		{
+			name:         "GCP PREEMPTIBLE_GCP to Azure",
+			availability: "PREEMPTIBLE_GCP",
+			sourceCloud:  "gcp",
+			targetCloud:  "azure",
+			expected:     "SPOT_AZURE",
+		},
+		{
+			name:         "Same cloud no change",
+			availability: "SPOT",
+			sourceCloud:  "aws",
+			targetCloud:  "aws",
+			expected:     "SPOT",
+		},
+		{
+			name:         "Unknown availability unchanged",
+			availability: "UNKNOWN",
+			sourceCloud:  "aws",
+			targetCloud:  "azure",
+			expected:     "UNKNOWN",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := convertAvailability(tt.availability, tt.sourceCloud, tt.targetCloud)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestIsCompatibleAttribute(t *testing.T) {
+	tests := []struct {
+		name        string
+		attrName    string
+		sourceCloud string
+		targetCloud string
+		attrValue   interface{}
+		expected    bool
+	}{
+		{
+			name:        "availability is always compatible",
+			attrName:    "availability",
+			sourceCloud: "aws",
+			targetCloud: "azure",
+			attrValue:   "SPOT",
+			expected:    true,
+		},
+		{
+			name:        "first_on_demand is always compatible",
+			attrName:    "first_on_demand",
+			sourceCloud: "aws",
+			targetCloud: "gcp",
+			attrValue:   1,
+			expected:    true,
+		},
+		{
+			name:        "zone_id auto is compatible between AWS and GCP",
+			attrName:    "zone_id",
+			sourceCloud: "aws",
+			targetCloud: "gcp",
+			attrValue:   "auto",
+			expected:    true,
+		},
+		{
+			name:        "zone_id AUTO is compatible (case insensitive)",
+			attrName:    "zone_id",
+			sourceCloud: "aws",
+			targetCloud: "gcp",
+			attrValue:   "AUTO",
+			expected:    true,
+		},
+		{
+			name:        "zone_id specific value not compatible",
+			attrName:    "zone_id",
+			sourceCloud: "aws",
+			targetCloud: "gcp",
+			attrValue:   "us-west-2a",
+			expected:    false,
+		},
+		{
+			name:        "ebs_volume_count compatible with local_ssd_count when GENERAL_PURPOSE_SSD",
+			attrName:    "ebs_volume_count",
+			sourceCloud: "aws",
+			targetCloud: "gcp",
+			attrValue:   2,
+			expected:    true,
+		},
+		{
+			name:        "instance_profile_arn not compatible",
+			attrName:    "instance_profile_arn",
+			sourceCloud: "aws",
+			targetCloud: "azure",
+			attrValue:   "arn:aws:iam::123:instance-profile/test",
+			expected:    false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// For ebs_volume_count test, we need to pass additional context
+			additionalData := map[string]interface{}{}
+			if tt.attrName == "ebs_volume_count" {
+				additionalData["ebs_volume_type"] = "GENERAL_PURPOSE_SSD"
+			}
+			result := isCompatibleAttribute(tt.attrName, tt.attrValue, tt.sourceCloud, tt.targetCloud, additionalData)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestConvertCloudAttributesBlock(t *testing.T) {
+	tests := []struct {
+		name         string
+		sourceCloud  string
+		targetCloud  string
+		sourceAttrs  map[string]interface{}
+		expectedType string
+		expectedLen  int
+	}{
+		{
+			name:        "AWS to Azure conversion",
+			sourceCloud: "aws",
+			targetCloud: "azure",
+			sourceAttrs: map[string]interface{}{
+				"availability":         "SPOT",
+				"first_on_demand":      1,
+				"zone_id":              "us-west-2a",                             // not compatible
+				"instance_profile_arn": "arn:aws:iam::123:instance-profile/test", // not compatible
+			},
+			expectedType: "azure_attributes",
+			expectedLen:  2, // only availability and first_on_demand
+		},
+		{
+			name:        "AWS to GCP with auto zone",
+			sourceCloud: "aws",
+			targetCloud: "gcp",
+			sourceAttrs: map[string]interface{}{
+				"availability":     "ON_DEMAND",
+				"first_on_demand":  1,
+				"zone_id":          "auto",
+				"ebs_volume_count": 2,
+				"ebs_volume_type":  "GENERAL_PURPOSE_SSD",
+			},
+			expectedType: "gcp_attributes",
+			expectedLen:  4, // availability, first_on_demand, zone_id, local_ssd_count
+		},
+		{
+			name:        "Same cloud returns nil",
+			sourceCloud: "aws",
+			targetCloud: "aws",
+			sourceAttrs: map[string]interface{}{
+				"availability": "SPOT",
+			},
+			expectedType: "",
+			expectedLen:  0,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := convertCloudAttributesBlock(tt.sourceAttrs, tt.sourceCloud, tt.targetCloud)
+			if tt.expectedType == "" {
+				assert.Nil(t, result)
+			} else {
+				assert.NotNil(t, result)
+				assert.Equal(t, tt.expectedLen, len(result))
+
+				// Verify specific conversions
+				if tt.name == "AWS to Azure conversion" {
+					assert.Equal(t, "SPOT_AZURE", result["availability"])
+				}
+				if tt.name == "AWS to GCP with auto zone" {
+					assert.Equal(t, "ON_DEMAND_GCP", result["availability"])
+					assert.Contains(t, result, "local_ssd_count")
+					assert.NotContains(t, result, "ebs_volume_count")
+				}
+			}
+		})
+	}
+}
+
+func TestConvertTopLevelNodeTypes(t *testing.T) {
+	tests := []struct {
+		name        string
+		nodeType    string
+		driverType  string
+		sourceCloud string
+		targetCloud string
+		expectNode  string
+		expectDrv   string
+	}{
+		{
+			name:        "AWS to Azure conversion",
+			nodeType:    "i3.xlarge",
+			driverType:  "i3.2xlarge",
+			sourceCloud: "aws",
+			targetCloud: "azure",
+			expectNode:  "Standard_F4s",
+			expectDrv:   "Standard_F8s",
+		},
+		{
+			name:        "Same cloud unchanged",
+			nodeType:    "i3.xlarge",
+			driverType:  "i3.2xlarge",
+			sourceCloud: "aws",
+			targetCloud: "aws",
+			expectNode:  "i3.xlarge",
+			expectDrv:   "i3.2xlarge",
+		},
+		{
+			name:        "Unmapped type unchanged",
+			nodeType:    "unknown-type",
+			driverType:  "i3.xlarge",
+			sourceCloud: "aws",
+			targetCloud: "azure",
+			expectNode:  "unknown-type",
+			expectDrv:   "Standard_F4s",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mappings := &nodeTypeMappings{
+				Version: "1.0",
+				Mappings: []nodeTypeMapping{
+					{
+						Azure: "Standard_F4s",
+						AWS:   "i3.xlarge",
+						GCP:   "n1-standard-4",
+					},
+					{
+						Azure: "Standard_F8s",
+						AWS:   "i3.2xlarge",
+						GCP:   "n1-standard-8",
+					},
+				},
+			}
+
+			client := &common.DatabricksClient{
+				DatabricksClient: &client.DatabricksClient{
+					Config: &config.Config{
+						Host: "https://test.cloud.databricks.com",
+					},
+				},
+			}
+			ic := &importContext{
+				Client:           client,
+				targetCloud:      tt.targetCloud,
+				nodeTypeMappings: mappings,
+			}
+
+			// Create a mock wrapper
+			data := map[string]interface{}{
+				"node_type_id":        tt.nodeType,
+				"driver_node_type_id": tt.driverType,
+			}
+			wrapper := &mockWrapper{data: data}
+
+			converted := ic.convertTopLevelNodeTypes(wrapper, tt.sourceCloud, tt.targetCloud)
+
+			if tt.sourceCloud == tt.targetCloud {
+				assert.False(t, converted, "Should not convert for same cloud")
+			} else if tt.expectNode != tt.nodeType || tt.expectDrv != tt.driverType {
+				assert.True(t, converted, "Should convert when types change")
+			}
+
+			assert.Equal(t, tt.expectNode, data["node_type_id"])
+			assert.Equal(t, tt.expectDrv, data["driver_node_type_id"])
+		})
+	}
+}
+
+// mockWrapper is a simple mock implementation for testing
+type mockWrapper struct {
+	data map[string]interface{}
+	id   string
+}
+
+func (m *mockWrapper) GetOk(key string) (interface{}, bool) {
+	val, ok := m.data[key]
+	return val, ok
+}
+
+func (m *mockWrapper) Get(key string) interface{} {
+	return m.data[key]
+}
+
+func (m *mockWrapper) Set(key string, value interface{}) error {
+	m.data[key] = value
+	return nil
+}
+
+func (m *mockWrapper) SetId(id string) {
+	m.id = id
+}
+
+func (m *mockWrapper) Id() string {
+	if m.id != "" {
+		return m.id
+	}
+	return "test-resource"
+}
+
+func (m *mockWrapper) Schema() map[string]*SchemaWrapper {
+	return nil
+}
+
+func (m *mockWrapper) GetSchema() SchemaWrapper {
+	return nil
+}
+
+func (m *mockWrapper) IsPluginFramework() bool {
+	return false
+}
+
+func (m *mockWrapper) GetTypedStruct(ctx context.Context, target interface{}) error {
+	return fmt.Errorf("not implemented for mock")
+}
+
+func TestConvertCloudAttributesInWrapper(t *testing.T) {
+	tests := []struct {
+		name                string
+		sourceAttrs         map[string]interface{}
+		sourceCloud         string
+		targetCloud         string
+		expectConverted     bool
+		expectSourceCleared bool
+		validateTarget      func(t *testing.T, result map[string]interface{})
+	}{
+		{
+			name: "AWS to Azure with compatible attrs",
+			sourceAttrs: map[string]interface{}{
+				"availability":    "SPOT",
+				"first_on_demand": 1,
+				"zone_id":         "auto",
+			},
+			sourceCloud:         "aws",
+			targetCloud:         "azure",
+			expectConverted:     true,
+			expectSourceCleared: true,
+			validateTarget: func(t *testing.T, result map[string]interface{}) {
+				assert.Equal(t, "SPOT_AZURE", result["availability"])
+				assert.Equal(t, 1, result["first_on_demand"])
+				// zone_id not compatible between AWS and Azure
+				assert.NotContains(t, result, "zone_id")
+			},
+		},
+		{
+			name: "AWS to Azure with no compatible attrs",
+			sourceAttrs: map[string]interface{}{
+				"instance_profile_arn": "arn:aws:iam::123:instance-profile/test",
+				"zone_id":              "us-west-2a",
+			},
+			sourceCloud:         "aws",
+			targetCloud:         "azure",
+			expectConverted:     false,
+			expectSourceCleared: true, // Clear even if nothing converts
+			validateTarget: func(t *testing.T, result map[string]interface{}) {
+				assert.Nil(t, result, "Should be nil when no compatible attributes")
+			},
+		},
+		{
+			name: "AWS to GCP with ebs_volume conversion",
+			sourceAttrs: map[string]interface{}{
+				"availability":     "ON_DEMAND",
+				"first_on_demand":  1,
+				"zone_id":          "auto",
+				"ebs_volume_count": 2,
+				"ebs_volume_type":  "GENERAL_PURPOSE_SSD",
+			},
+			sourceCloud:         "aws",
+			targetCloud:         "gcp",
+			expectConverted:     true,
+			expectSourceCleared: true,
+			validateTarget: func(t *testing.T, result map[string]interface{}) {
+				assert.Equal(t, "ON_DEMAND_GCP", result["availability"])
+				assert.Equal(t, "auto", result["zone_id"])
+				assert.Equal(t, 2, result["local_ssd_count"])
+				assert.NotContains(t, result, "ebs_volume_count")
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := convertCloudAttributesBlock(tt.sourceAttrs, tt.sourceCloud, tt.targetCloud)
+
+			if tt.expectConverted {
+				assert.NotNil(t, result)
+			}
+
+			if tt.validateTarget != nil {
+				tt.validateTarget(t, result)
+			}
+		})
+	}
+}
+
+func TestConvertInstancePoolDiskSpec(t *testing.T) {
+	tests := []struct {
+		name         string
+		sourceCloud  string
+		targetCloud  string
+		diskSpec     []interface{}
+		expectChange bool
+		validate     func(t *testing.T, wrapper *mockWrapper)
+	}{
+		{
+			name:        "AWS to Azure - GENERAL_PURPOSE_SSD to PREMIUM_LRS",
+			sourceCloud: "aws",
+			targetCloud: "azure",
+			diskSpec: []interface{}{
+				map[string]interface{}{
+					"disk_count": 2,
+					"disk_size":  100,
+					"disk_type": []interface{}{
+						map[string]interface{}{
+							"ebs_volume_type": "GENERAL_PURPOSE_SSD",
+						},
+					},
+				},
+			},
+			expectChange: true,
+			validate: func(t *testing.T, wrapper *mockWrapper) {
+				diskSpec := wrapper.data["disk_spec"].([]interface{})
+				assert.Len(t, diskSpec, 1)
+				diskSpecMap := diskSpec[0].(map[string]interface{})
+
+				diskType := diskSpecMap["disk_type"].([]interface{})
+				assert.Len(t, diskType, 1)
+				diskTypeMap := diskType[0].(map[string]interface{})
+
+				assert.Equal(t, "PREMIUM_LRS", diskTypeMap["azure_disk_volume_type"])
+				assert.NotContains(t, diskTypeMap, "ebs_volume_type")
+			},
+		},
+		{
+			name:        "AWS to Azure - THROUGHPUT_OPTIMIZED_HDD to STANDARD_LRS",
+			sourceCloud: "aws",
+			targetCloud: "azure",
+			diskSpec: []interface{}{
+				map[string]interface{}{
+					"disk_count": 1,
+					"disk_type": []interface{}{
+						map[string]interface{}{
+							"ebs_volume_type": "THROUGHPUT_OPTIMIZED_HDD",
+						},
+					},
+				},
+			},
+			expectChange: true,
+			validate: func(t *testing.T, wrapper *mockWrapper) {
+				diskSpec := wrapper.data["disk_spec"].([]interface{})
+				diskSpecMap := diskSpec[0].(map[string]interface{})
+				diskType := diskSpecMap["disk_type"].([]interface{})
+				diskTypeMap := diskType[0].(map[string]interface{})
+
+				assert.Equal(t, "STANDARD_LRS", diskTypeMap["azure_disk_volume_type"])
+				assert.NotContains(t, diskTypeMap, "ebs_volume_type")
+			},
+		},
+		{
+			name:        "Azure to AWS - PREMIUM_LRS to GENERAL_PURPOSE_SSD",
+			sourceCloud: "azure",
+			targetCloud: "aws",
+			diskSpec: []interface{}{
+				map[string]interface{}{
+					"disk_count": 2,
+					"disk_type": []interface{}{
+						map[string]interface{}{
+							"azure_disk_volume_type": "PREMIUM_LRS",
+						},
+					},
+				},
+			},
+			expectChange: true,
+			validate: func(t *testing.T, wrapper *mockWrapper) {
+				diskSpec := wrapper.data["disk_spec"].([]interface{})
+				diskSpecMap := diskSpec[0].(map[string]interface{})
+				diskType := diskSpecMap["disk_type"].([]interface{})
+				diskTypeMap := diskType[0].(map[string]interface{})
+
+				assert.Equal(t, "GENERAL_PURPOSE_SSD", diskTypeMap["ebs_volume_type"])
+				assert.NotContains(t, diskTypeMap, "azure_disk_volume_type")
+			},
+		},
+		{
+			name:        "Azure to AWS - STANDARD_LRS to THROUGHPUT_OPTIMIZED_HDD",
+			sourceCloud: "azure",
+			targetCloud: "aws",
+			diskSpec: []interface{}{
+				map[string]interface{}{
+					"disk_count": 1,
+					"disk_type": []interface{}{
+						map[string]interface{}{
+							"azure_disk_volume_type": "STANDARD_LRS",
+						},
+					},
+				},
+			},
+			expectChange: true,
+			validate: func(t *testing.T, wrapper *mockWrapper) {
+				diskSpec := wrapper.data["disk_spec"].([]interface{})
+				diskSpecMap := diskSpec[0].(map[string]interface{})
+				diskType := diskSpecMap["disk_type"].([]interface{})
+				diskTypeMap := diskType[0].(map[string]interface{})
+
+				assert.Equal(t, "THROUGHPUT_OPTIMIZED_HDD", diskTypeMap["ebs_volume_type"])
+				assert.NotContains(t, diskTypeMap, "azure_disk_volume_type")
+			},
+		},
+		{
+			name:        "AWS to GCP - disk_type removed",
+			sourceCloud: "aws",
+			targetCloud: "gcp",
+			diskSpec: []interface{}{
+				map[string]interface{}{
+					"disk_count": 2,
+					"disk_type": []interface{}{
+						map[string]interface{}{
+							"ebs_volume_type": "GENERAL_PURPOSE_SSD",
+						},
+					},
+				},
+			},
+			expectChange: true,
+			validate: func(t *testing.T, wrapper *mockWrapper) {
+				diskSpec := wrapper.data["disk_spec"].([]interface{})
+				diskSpecMap := diskSpec[0].(map[string]interface{})
+
+				// disk_type should be removed for GCP
+				assert.NotContains(t, diskSpecMap, "disk_type")
+				// disk_count should remain
+				assert.Equal(t, 2, diskSpecMap["disk_count"])
+			},
+		},
+		{
+			name:        "Azure to GCP - disk_type removed",
+			sourceCloud: "azure",
+			targetCloud: "gcp",
+			diskSpec: []interface{}{
+				map[string]interface{}{
+					"disk_count": 1,
+					"disk_type": []interface{}{
+						map[string]interface{}{
+							"azure_disk_volume_type": "PREMIUM_LRS",
+						},
+					},
+				},
+			},
+			expectChange: true,
+			validate: func(t *testing.T, wrapper *mockWrapper) {
+				diskSpec := wrapper.data["disk_spec"].([]interface{})
+				diskSpecMap := diskSpec[0].(map[string]interface{})
+
+				assert.NotContains(t, diskSpecMap, "disk_type")
+				assert.Equal(t, 1, diskSpecMap["disk_count"])
+			},
+		},
+		{
+			name:        "GCP to AWS - no disk_type to convert",
+			sourceCloud: "gcp",
+			targetCloud: "aws",
+			diskSpec: []interface{}{
+				map[string]interface{}{
+					"disk_count": 2,
+					// No disk_type on GCP
+				},
+			},
+			expectChange: false,
+			validate: func(t *testing.T, wrapper *mockWrapper) {
+				diskSpec := wrapper.data["disk_spec"].([]interface{})
+				diskSpecMap := diskSpec[0].(map[string]interface{})
+
+				// Should remain unchanged
+				assert.Equal(t, 2, diskSpecMap["disk_count"])
+				assert.NotContains(t, diskSpecMap, "disk_type")
+			},
+		},
+		{
+			name:        "Same cloud - no conversion",
+			sourceCloud: "aws",
+			targetCloud: "aws",
+			diskSpec: []interface{}{
+				map[string]interface{}{
+					"disk_count": 2,
+					"disk_type": []interface{}{
+						map[string]interface{}{
+							"ebs_volume_type": "GENERAL_PURPOSE_SSD",
+						},
+					},
+				},
+			},
+			expectChange: false,
+			validate: func(t *testing.T, wrapper *mockWrapper) {
+				diskSpec := wrapper.data["disk_spec"].([]interface{})
+				diskSpecMap := diskSpec[0].(map[string]interface{})
+				diskType := diskSpecMap["disk_type"].([]interface{})
+				diskTypeMap := diskType[0].(map[string]interface{})
+
+				// Should remain unchanged
+				assert.Equal(t, "GENERAL_PURPOSE_SSD", diskTypeMap["ebs_volume_type"])
+			},
+		},
+		{
+			name:         "No disk_spec - no conversion",
+			sourceCloud:  "aws",
+			targetCloud:  "azure",
+			diskSpec:     nil,
+			expectChange: false,
+			validate: func(t *testing.T, wrapper *mockWrapper) {
+				assert.Nil(t, wrapper.data["disk_spec"])
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			wrapper := &mockWrapper{
+				data: make(map[string]interface{}),
+				id:   "test-pool-123",
+			}
+
+			if tt.diskSpec != nil {
+				wrapper.data["disk_spec"] = tt.diskSpec
+			}
+
+			ic := &importContext{}
+			result := ic.convertInstancePoolDiskSpec(wrapper, tt.sourceCloud, tt.targetCloud)
+
+			assert.Equal(t, tt.expectChange, result)
+
+			if tt.validate != nil {
+				tt.validate(t, wrapper)
+			}
+		})
+	}
+}
diff --git a/exporter/node_type_mapping_test.go b/exporter/node_type_mapping_test.go
new file mode 100644
index 00000000..e5fbfb5b
--- /dev/null
+++ b/exporter/node_type_mapping_test.go
@@ -0,0 +1,199 @@
+package exporter
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestLoadNodeTypeMappings(t *testing.T) {
+	tests := []struct {
+		name        string
+		content     string
+		expectError bool
+		validate    func(t *testing.T, mappings *nodeTypeMappings)
+	}{
+		{
+			name: "Valid mapping file",
+			content: `{
+				"version": "1.0",
+				"mappings": [
+					{
+						"azure": "Standard_F4s",
+						"aws": "i3.xlarge",
+						"gcp": "n1-standard-4"
+					},
+					{
+						"azure": "Standard_F8s",
+						"aws": "i3.2xlarge",
+						"gcp": "n1-standard-8"
+					}
+				]
+			}`,
+			expectError: false,
+			validate: func(t *testing.T, mappings *nodeTypeMappings) {
+				assert.Equal(t, "1.0", mappings.Version)
+				assert.Len(t, mappings.Mappings, 2)
+				assert.Equal(t, "Standard_F4s", mappings.Mappings[0].Azure)
+				assert.Equal(t, "i3.xlarge", mappings.Mappings[0].AWS)
+				assert.Equal(t, "n1-standard-4", mappings.Mappings[0].GCP)
+			},
+		},
+		{
+			name: "Empty file",
+			content: `{
+				"version": "1.0",
+				"mappings": []
+			}`,
+			expectError: false,
+			validate: func(t *testing.T, mappings *nodeTypeMappings) {
+				assert.Equal(t, "1.0", mappings.Version)
+				assert.Len(t, mappings.Mappings, 0)
+			},
+		},
+		{
+			name:        "Invalid JSON",
+			content:     `{invalid json}`,
+			expectError: true,
+		},
+		{
+			name: "Missing version",
+			content: `{
+				"mappings": [
+					{"azure": "Standard_F4s", "aws": "i3.xlarge"}
+				]
+			}`,
+			expectError: false,
+			validate: func(t *testing.T, mappings *nodeTypeMappings) {
+				assert.Empty(t, mappings.Version)
+				assert.Len(t, mappings.Mappings, 1)
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create temp file
+			tmpDir := t.TempDir()
+			tmpFile := filepath.Join(tmpDir, "mappings.json")
+			err := os.WriteFile(tmpFile, []byte(tt.content), 0644)
+			require.NoError(t, err)
+
+			// Load mappings
+			mappings, err := loadNodeTypeMappings(tmpFile)
+
+			if tt.expectError {
+				assert.Error(t, err)
+				assert.Nil(t, mappings)
+			} else {
+				assert.NoError(t, err)
+				require.NotNil(t, mappings)
+				if tt.validate != nil {
+					tt.validate(t, mappings)
+				}
+			}
+		})
+	}
+}
+
+func TestLoadNodeTypeMappingsNonExistentFile(t *testing.T) {
+	mappings, err := loadNodeTypeMappings("/nonexistent/file.json")
+	assert.Error(t, err)
+	assert.Nil(t, mappings)
+}
+
+func TestConvertNodeType(t *testing.T) {
+	mappings := &nodeTypeMappings{
+		Version: "1.0",
+		Mappings: []nodeTypeMapping{
+			{
+				Azure: "Standard_F4s",
+				AWS:   "i3.xlarge",
+				GCP:   "n1-standard-4",
+			},
+			{
+				Azure: "Standard_F8s",
+				AWS:   "i3.2xlarge",
+				GCP:   "n1-standard-8",
+			},
+			{
+				Azure: "Standard_D4s_v3",
+				AWS:   "m5.xlarge",
+				// No GCP mapping
+			},
+		},
+	}
+
+	tests := []struct {
+		name        string
+		nodeType    string
+		sourceCloud string
+		targetCloud string
+		expected    string
+	}{
+		{
+			name:        "AWS to Azure",
+			nodeType:    "i3.xlarge",
+			sourceCloud: "aws",
+			targetCloud: "azure",
+			expected:    "Standard_F4s",
+		},
+		{
+			name:        "Azure to GCP",
+			nodeType:    "Standard_F4s",
+			sourceCloud: "azure",
+			targetCloud: "gcp",
+			expected:    "n1-standard-4",
+		},
+		{
+			name:        "GCP to AWS",
+			nodeType:    "n1-standard-8",
+			sourceCloud: "gcp",
+			targetCloud: "aws",
+			expected:    "i3.2xlarge",
+		},
+		{
+			name:        "Same cloud unchanged",
+			nodeType:    "i3.xlarge",
+			sourceCloud: "aws",
+			targetCloud: "aws",
+			expected:    "i3.xlarge",
+		},
+		{
+			name:        "Unmapped type unchanged",
+			nodeType:    "some-unknown-type",
+			sourceCloud: "aws",
+			targetCloud: "azure",
+			expected:    "some-unknown-type",
+		},
+		{
+			name:        "Target cloud missing in mapping",
+			nodeType:    "Standard_D4s_v3",
+			sourceCloud: "azure",
+			targetCloud: "gcp",
+			expected:    "Standard_D4s_v3",
+		},
+		{
+			name:        "Case sensitivity",
+			nodeType:    "I3.XLARGE",
+			sourceCloud: "aws",
+			targetCloud: "azure",
+			expected:    "I3.XLARGE", // No match due to case
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := convertNodeType(tt.nodeType, tt.sourceCloud, tt.targetCloud, mappings)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func TestConvertNodeTypeNilMappings(t *testing.T) {
+	result := convertNodeType("i3.xlarge", "aws", "azure", nil)
+	assert.Equal(t, "i3.xlarge", result, "Should return original when mappings is nil")
+}