oci.CloudBridge.Asset

import * as pulumi from "@pulumi/pulumi";
import * as oci from "@pulumi/oci";

const testAsset = new oci.cloudbridge.Asset("testAsset", {
    assetType: _var.asset_asset_type,
    compartmentId: _var.compartment_id,
    externalAssetKey: _var.asset_external_asset_key,
    inventoryId: oci_cloud_bridge_inventory.test_inventory.id,
    sourceKey: _var.asset_source_key,
    assetSourceIds: _var.asset_asset_source_ids,
    compute: {
        connectedNetworks: _var.asset_compute_connected_networks,
        coresCount: _var.asset_compute_cores_count,
        cpuModel: _var.asset_compute_cpu_model,
        description: _var.asset_compute_description,
        disks: [{
            bootOrder: _var.asset_compute_disks_boot_order,
            location: _var.asset_compute_disks_location,
            name: _var.asset_compute_disks_name,
            persistentMode: _var.asset_compute_disks_persistent_mode,
            sizeInMbs: _var.asset_compute_disks_size_in_mbs,
            uuid: _var.asset_compute_disks_uuid,
            uuidLun: _var.asset_compute_disks_uuid_lun,
        }],
        disksCount: _var.asset_compute_disks_count,
        dnsName: _var.asset_compute_dns_name,
        firmware: _var.asset_compute_firmware,
        gpuDevices: [{
            coresCount: _var.asset_compute_gpu_devices_cores_count,
            description: _var.asset_compute_gpu_devices_description,
            manufacturer: _var.asset_compute_gpu_devices_manufacturer,
            memoryInMbs: _var.asset_compute_gpu_devices_memory_in_mbs,
            name: _var.asset_compute_gpu_devices_name,
        }],
        gpuDevicesCount: _var.asset_compute_gpu_devices_count,
        guestState: _var.asset_compute_guest_state,
        hardwareVersion: _var.asset_compute_hardware_version,
        hostName: _var.asset_compute_host_name,
        isPmemEnabled: _var.asset_compute_is_pmem_enabled,
        isTpmEnabled: _var.asset_compute_is_tpm_enabled,
        latencySensitivity: _var.asset_compute_latency_sensitivity,
        memoryInMbs: _var.asset_compute_memory_in_mbs,
        nics: [{
            ipAddresses: _var.asset_compute_nics_ip_addresses,
            label: _var.asset_compute_nics_label,
            macAddress: _var.asset_compute_nics_mac_address,
            macAddressType: _var.asset_compute_nics_mac_address_type,
            networkName: _var.asset_compute_nics_network_name,
            switchName: _var.asset_compute_nics_switch_name,
        }],
        nicsCount: _var.asset_compute_nics_count,
        nvdimmController: {
            busNumber: _var.asset_compute_nvdimm_controller_bus_number,
            label: _var.asset_compute_nvdimm_controller_label,
        },
        nvdimms: [{
            controllerKey: _var.asset_compute_nvdimms_controller_key,
            label: _var.asset_compute_nvdimms_label,
            unitNumber: _var.asset_compute_nvdimms_unit_number,
        }],
        operatingSystem: _var.asset_compute_operating_system,
        operatingSystemVersion: _var.asset_compute_operating_system_version,
        pmemInMbs: _var.asset_compute_pmem_in_mbs,
        powerState: _var.asset_compute_power_state,
        primaryIp: _var.asset_compute_primary_ip,
        scsiController: {
            label: _var.asset_compute_scsi_controller_label,
            sharedBus: _var.asset_compute_scsi_controller_shared_bus,
            unitNumber: _var.asset_compute_scsi_controller_unit_number,
        },
        storageProvisionedInMbs: _var.asset_compute_storage_provisioned_in_mbs,
        threadsPerCoreCount: _var.asset_compute_threads_per_core_count,
    },
    definedTags: {
        "Operations.CostCenter": "42",
    },
    displayName: _var.asset_display_name,
    freeformTags: {
        Department: "Finance",
    },
    vm: {
        hypervisorHost: _var.asset_vm_hypervisor_host,
        hypervisorVendor: _var.asset_vm_hypervisor_vendor,
        hypervisorVersion: _var.asset_vm_hypervisor_version,
    },
    vmwareVcenter: {
        dataCenter: _var.asset_vmware_vcenter_data_center,
        vcenterKey: _var.asset_vmware_vcenter_vcenter_key,
        vcenterVersion: _var.asset_vmware_vcenter_vcenter_version,
    },
    vmwareVm: {
        cluster: _var.asset_vmware_vm_cluster,
        customerFields: _var.asset_vmware_vm_customer_fields,
        customerTags: [{
            description: _var.asset_vmware_vm_customer_tags_description,
            name: _var.asset_vmware_vm_customer_tags_name,
        }],
        faultToleranceBandwidth: _var.asset_vmware_vm_fault_tolerance_bandwidth,
        faultToleranceSecondaryLatency: _var.asset_vmware_vm_fault_tolerance_secondary_latency,
        faultToleranceState: _var.asset_vmware_vm_fault_tolerance_state,
        instanceUuid: _var.asset_vmware_vm_instance_uuid,
        isDisksCbtEnabled: _var.asset_vmware_vm_is_disks_cbt_enabled,
        isDisksUuidEnabled: _var.asset_vmware_vm_is_disks_uuid_enabled,
        path: _var.asset_vmware_vm_path,
        vmwareToolsStatus: _var.asset_vmware_vm_vmware_tools_status,
    },
});

import pulumi
import pulumi_oci as oci

test_asset = oci.cloud_bridge.Asset("testAsset",
    asset_type=var["asset_asset_type"],
    compartment_id=var["compartment_id"],
    external_asset_key=var["asset_external_asset_key"],
    inventory_id=oci_cloud_bridge_inventory["test_inventory"]["id"],
    source_key=var["asset_source_key"],
    asset_source_ids=var["asset_asset_source_ids"],
    compute=oci.cloud_bridge.AssetComputeArgs(
        connected_networks=var["asset_compute_connected_networks"],
        cores_count=var["asset_compute_cores_count"],
        cpu_model=var["asset_compute_cpu_model"],
        description=var["asset_compute_description"],
        disks=[oci.cloud_bridge.AssetComputeDiskArgs(
            boot_order=var["asset_compute_disks_boot_order"],
            location=var["asset_compute_disks_location"],
            name=var["asset_compute_disks_name"],
            persistent_mode=var["asset_compute_disks_persistent_mode"],
            size_in_mbs=var["asset_compute_disks_size_in_mbs"],
            uuid=var["asset_compute_disks_uuid"],
            uuid_lun=var["asset_compute_disks_uuid_lun"],
        )],
        disks_count=var["asset_compute_disks_count"],
        dns_name=var["asset_compute_dns_name"],
        firmware=var["asset_compute_firmware"],
        gpu_devices=[oci.cloud_bridge.AssetComputeGpuDeviceArgs(
            cores_count=var["asset_compute_gpu_devices_cores_count"],
            description=var["asset_compute_gpu_devices_description"],
            manufacturer=var["asset_compute_gpu_devices_manufacturer"],
            memory_in_mbs=var["asset_compute_gpu_devices_memory_in_mbs"],
            name=var["asset_compute_gpu_devices_name"],
        )],
        gpu_devices_count=var["asset_compute_gpu_devices_count"],
        guest_state=var["asset_compute_guest_state"],
        hardware_version=var["asset_compute_hardware_version"],
        host_name=var["asset_compute_host_name"],
        is_pmem_enabled=var["asset_compute_is_pmem_enabled"],
        is_tpm_enabled=var["asset_compute_is_tpm_enabled"],
        latency_sensitivity=var["asset_compute_latency_sensitivity"],
        memory_in_mbs=var["asset_compute_memory_in_mbs"],
        nics=[oci.cloud_bridge.AssetComputeNicArgs(
            ip_addresses=var["asset_compute_nics_ip_addresses"],
            label=var["asset_compute_nics_label"],
            mac_address=var["asset_compute_nics_mac_address"],
            mac_address_type=var["asset_compute_nics_mac_address_type"],
            network_name=var["asset_compute_nics_network_name"],
            switch_name=var["asset_compute_nics_switch_name"],
        )],
        nics_count=var["asset_compute_nics_count"],
        nvdimm_controller=oci.cloud_bridge.AssetComputeNvdimmControllerArgs(
            bus_number=var["asset_compute_nvdimm_controller_bus_number"],
            label=var["asset_compute_nvdimm_controller_label"],
        ),
        nvdimms=[oci.cloud_bridge.AssetComputeNvdimmArgs(
            controller_key=var["asset_compute_nvdimms_controller_key"],
            label=var["asset_compute_nvdimms_label"],
            unit_number=var["asset_compute_nvdimms_unit_number"],
        )],
        operating_system=var["asset_compute_operating_system"],
        operating_system_version=var["asset_compute_operating_system_version"],
        pmem_in_mbs=var["asset_compute_pmem_in_mbs"],
        power_state=var["asset_compute_power_state"],
        primary_ip=var["asset_compute_primary_ip"],
        scsi_controller=oci.cloud_bridge.AssetComputeScsiControllerArgs(
            label=var["asset_compute_scsi_controller_label"],
            shared_bus=var["asset_compute_scsi_controller_shared_bus"],
            unit_number=var["asset_compute_scsi_controller_unit_number"],
        ),
        storage_provisioned_in_mbs=var["asset_compute_storage_provisioned_in_mbs"],
        threads_per_core_count=var["asset_compute_threads_per_core_count"],
    ),
    defined_tags={
        "Operations.CostCenter": "42",
    },
    display_name=var["asset_display_name"],
    freeform_tags={
        "Department": "Finance",
    },
    vm=oci.cloud_bridge.AssetVmArgs(
        hypervisor_host=var["asset_vm_hypervisor_host"],
        hypervisor_vendor=var["asset_vm_hypervisor_vendor"],
        hypervisor_version=var["asset_vm_hypervisor_version"],
    ),
    vmware_vcenter=oci.cloud_bridge.AssetVmwareVcenterArgs(
        data_center=var["asset_vmware_vcenter_data_center"],
        vcenter_key=var["asset_vmware_vcenter_vcenter_key"],
        vcenter_version=var["asset_vmware_vcenter_vcenter_version"],
    ),
    vmware_vm=oci.cloud_bridge.AssetVmwareVmArgs(
        cluster=var["asset_vmware_vm_cluster"],
        customer_fields=var["asset_vmware_vm_customer_fields"],
        customer_tags=[oci.cloud_bridge.AssetVmwareVmCustomerTagArgs(
            description=var["asset_vmware_vm_customer_tags_description"],
            name=var["asset_vmware_vm_customer_tags_name"],
        )],
        fault_tolerance_bandwidth=var["asset_vmware_vm_fault_tolerance_bandwidth"],
        fault_tolerance_secondary_latency=var["asset_vmware_vm_fault_tolerance_secondary_latency"],
        fault_tolerance_state=var["asset_vmware_vm_fault_tolerance_state"],
        instance_uuid=var["asset_vmware_vm_instance_uuid"],
        is_disks_cbt_enabled=var["asset_vmware_vm_is_disks_cbt_enabled"],
        is_disks_uuid_enabled=var["asset_vmware_vm_is_disks_uuid_enabled"],
        path=var["asset_vmware_vm_path"],
        vmware_tools_status=var["asset_vmware_vm_vmware_tools_status"],
    ))

package main

import (
	"github.com/pulumi/pulumi-oci/sdk/go/oci/CloudBridge"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := CloudBridge.NewAsset(ctx, "testAsset", &CloudBridge.AssetArgs{
			AssetType:        pulumi.Any(_var.Asset_asset_type),
			CompartmentId:    pulumi.Any(_var.Compartment_id),
			ExternalAssetKey: pulumi.Any(_var.Asset_external_asset_key),
			InventoryId:      pulumi.Any(oci_cloud_bridge_inventory.Test_inventory.Id),
			SourceKey:        pulumi.Any(_var.Asset_source_key),
			AssetSourceIds:   pulumi.Any(_var.Asset_asset_source_ids),
			Compute: &cloudbridge.AssetComputeArgs{
				ConnectedNetworks: pulumi.Any(_var.Asset_compute_connected_networks),
				CoresCount:        pulumi.Any(_var.Asset_compute_cores_count),
				CpuModel:          pulumi.Any(_var.Asset_compute_cpu_model),
				Description:       pulumi.Any(_var.Asset_compute_description),
				Disks: cloudbridge.AssetComputeDiskArray{
					&cloudbridge.AssetComputeDiskArgs{
						BootOrder:      pulumi.Any(_var.Asset_compute_disks_boot_order),
						Location:       pulumi.Any(_var.Asset_compute_disks_location),
						Name:           pulumi.Any(_var.Asset_compute_disks_name),
						PersistentMode: pulumi.Any(_var.Asset_compute_disks_persistent_mode),
						SizeInMbs:      pulumi.Any(_var.Asset_compute_disks_size_in_mbs),
						Uuid:           pulumi.Any(_var.Asset_compute_disks_uuid),
						UuidLun:        pulumi.Any(_var.Asset_compute_disks_uuid_lun),
					},
				},
				DisksCount: pulumi.Any(_var.Asset_compute_disks_count),
				DnsName:    pulumi.Any(_var.Asset_compute_dns_name),
				Firmware:   pulumi.Any(_var.Asset_compute_firmware),
				GpuDevices: cloudbridge.AssetComputeGpuDeviceArray{
					&cloudbridge.AssetComputeGpuDeviceArgs{
						CoresCount:   pulumi.Any(_var.Asset_compute_gpu_devices_cores_count),
						Description:  pulumi.Any(_var.Asset_compute_gpu_devices_description),
						Manufacturer: pulumi.Any(_var.Asset_compute_gpu_devices_manufacturer),
						MemoryInMbs:  pulumi.Any(_var.Asset_compute_gpu_devices_memory_in_mbs),
						Name:         pulumi.Any(_var.Asset_compute_gpu_devices_name),
					},
				},
				GpuDevicesCount:    pulumi.Any(_var.Asset_compute_gpu_devices_count),
				GuestState:         pulumi.Any(_var.Asset_compute_guest_state),
				HardwareVersion:    pulumi.Any(_var.Asset_compute_hardware_version),
				HostName:           pulumi.Any(_var.Asset_compute_host_name),
				IsPmemEnabled:      pulumi.Any(_var.Asset_compute_is_pmem_enabled),
				IsTpmEnabled:       pulumi.Any(_var.Asset_compute_is_tpm_enabled),
				LatencySensitivity: pulumi.Any(_var.Asset_compute_latency_sensitivity),
				MemoryInMbs:        pulumi.Any(_var.Asset_compute_memory_in_mbs),
				Nics: cloudbridge.AssetComputeNicArray{
					&cloudbridge.AssetComputeNicArgs{
						IpAddresses:    pulumi.Any(_var.Asset_compute_nics_ip_addresses),
						Label:          pulumi.Any(_var.Asset_compute_nics_label),
						MacAddress:     pulumi.Any(_var.Asset_compute_nics_mac_address),
						MacAddressType: pulumi.Any(_var.Asset_compute_nics_mac_address_type),
						NetworkName:    pulumi.Any(_var.Asset_compute_nics_network_name),
						SwitchName:     pulumi.Any(_var.Asset_compute_nics_switch_name),
					},
				},
				NicsCount: pulumi.Any(_var.Asset_compute_nics_count),
				NvdimmController: &cloudbridge.AssetComputeNvdimmControllerArgs{
					BusNumber: pulumi.Any(_var.Asset_compute_nvdimm_controller_bus_number),
					Label:     pulumi.Any(_var.Asset_compute_nvdimm_controller_label),
				},
				Nvdimms: cloudbridge.AssetComputeNvdimmArray{
					&cloudbridge.AssetComputeNvdimmArgs{
						ControllerKey: pulumi.Any(_var.Asset_compute_nvdimms_controller_key),
						Label:         pulumi.Any(_var.Asset_compute_nvdimms_label),
						UnitNumber:    pulumi.Any(_var.Asset_compute_nvdimms_unit_number),
					},
				},
				OperatingSystem:        pulumi.Any(_var.Asset_compute_operating_system),
				OperatingSystemVersion: pulumi.Any(_var.Asset_compute_operating_system_version),
				PmemInMbs:              pulumi.Any(_var.Asset_compute_pmem_in_mbs),
				PowerState:             pulumi.Any(_var.Asset_compute_power_state),
				PrimaryIp:              pulumi.Any(_var.Asset_compute_primary_ip),
				ScsiController: &cloudbridge.AssetComputeScsiControllerArgs{
					Label:      pulumi.Any(_var.Asset_compute_scsi_controller_label),
					SharedBus:  pulumi.Any(_var.Asset_compute_scsi_controller_shared_bus),
					UnitNumber: pulumi.Any(_var.Asset_compute_scsi_controller_unit_number),
				},
				StorageProvisionedInMbs: pulumi.Any(_var.Asset_compute_storage_provisioned_in_mbs),
				ThreadsPerCoreCount:     pulumi.Any(_var.Asset_compute_threads_per_core_count),
			},
			DefinedTags: pulumi.Map{
				"Operations.CostCenter": pulumi.Any("42"),
			},
			DisplayName: pulumi.Any(_var.Asset_display_name),
			FreeformTags: pulumi.Map{
				"Department": pulumi.Any("Finance"),
			},
			Vm: &cloudbridge.AssetVmArgs{
				HypervisorHost:    pulumi.Any(_var.Asset_vm_hypervisor_host),
				HypervisorVendor:  pulumi.Any(_var.Asset_vm_hypervisor_vendor),
				HypervisorVersion: pulumi.Any(_var.Asset_vm_hypervisor_version),
			},
			VmwareVcenter: &cloudbridge.AssetVmwareVcenterArgs{
				DataCenter:     pulumi.Any(_var.Asset_vmware_vcenter_data_center),
				VcenterKey:     pulumi.Any(_var.Asset_vmware_vcenter_vcenter_key),
				VcenterVersion: pulumi.Any(_var.Asset_vmware_vcenter_vcenter_version),
			},
			VmwareVm: &cloudbridge.AssetVmwareVmArgs{
				Cluster:        pulumi.Any(_var.Asset_vmware_vm_cluster),
				CustomerFields: pulumi.Any(_var.Asset_vmware_vm_customer_fields),
				CustomerTags: cloudbridge.AssetVmwareVmCustomerTagArray{
					&cloudbridge.AssetVmwareVmCustomerTagArgs{
						Description: pulumi.Any(_var.Asset_vmware_vm_customer_tags_description),
						Name:        pulumi.Any(_var.Asset_vmware_vm_customer_tags_name),
					},
				},
				FaultToleranceBandwidth:        pulumi.Any(_var.Asset_vmware_vm_fault_tolerance_bandwidth),
				FaultToleranceSecondaryLatency: pulumi.Any(_var.Asset_vmware_vm_fault_tolerance_secondary_latency),
				FaultToleranceState:            pulumi.Any(_var.Asset_vmware_vm_fault_tolerance_state),
				InstanceUuid:                   pulumi.Any(_var.Asset_vmware_vm_instance_uuid),
				IsDisksCbtEnabled:              pulumi.Any(_var.Asset_vmware_vm_is_disks_cbt_enabled),
				IsDisksUuidEnabled:             pulumi.Any(_var.Asset_vmware_vm_is_disks_uuid_enabled),
				Path:                           pulumi.Any(_var.Asset_vmware_vm_path),
				VmwareToolsStatus:              pulumi.Any(_var.Asset_vmware_vm_vmware_tools_status),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Oci = Pulumi.Oci;

return await Deployment.RunAsync(() => 
{
    var testAsset = new Oci.CloudBridge.Asset("testAsset", new()
    {
        AssetType = @var.Asset_asset_type,
        CompartmentId = @var.Compartment_id,
        ExternalAssetKey = @var.Asset_external_asset_key,
        InventoryId = oci_cloud_bridge_inventory.Test_inventory.Id,
        SourceKey = @var.Asset_source_key,
        AssetSourceIds = @var.Asset_asset_source_ids,
        Compute = new Oci.CloudBridge.Inputs.AssetComputeArgs
        {
            ConnectedNetworks = @var.Asset_compute_connected_networks,
            CoresCount = @var.Asset_compute_cores_count,
            CpuModel = @var.Asset_compute_cpu_model,
            Description = @var.Asset_compute_description,
            Disks = new[]
            {
                new Oci.CloudBridge.Inputs.AssetComputeDiskArgs
                {
                    BootOrder = @var.Asset_compute_disks_boot_order,
                    Location = @var.Asset_compute_disks_location,
                    Name = @var.Asset_compute_disks_name,
                    PersistentMode = @var.Asset_compute_disks_persistent_mode,
                    SizeInMbs = @var.Asset_compute_disks_size_in_mbs,
                    Uuid = @var.Asset_compute_disks_uuid,
                    UuidLun = @var.Asset_compute_disks_uuid_lun,
                },
            },
            DisksCount = @var.Asset_compute_disks_count,
            DnsName = @var.Asset_compute_dns_name,
            Firmware = @var.Asset_compute_firmware,
            GpuDevices = new[]
            {
                new Oci.CloudBridge.Inputs.AssetComputeGpuDeviceArgs
                {
                    CoresCount = @var.Asset_compute_gpu_devices_cores_count,
                    Description = @var.Asset_compute_gpu_devices_description,
                    Manufacturer = @var.Asset_compute_gpu_devices_manufacturer,
                    MemoryInMbs = @var.Asset_compute_gpu_devices_memory_in_mbs,
                    Name = @var.Asset_compute_gpu_devices_name,
                },
            },
            GpuDevicesCount = @var.Asset_compute_gpu_devices_count,
            GuestState = @var.Asset_compute_guest_state,
            HardwareVersion = @var.Asset_compute_hardware_version,
            HostName = @var.Asset_compute_host_name,
            IsPmemEnabled = @var.Asset_compute_is_pmem_enabled,
            IsTpmEnabled = @var.Asset_compute_is_tpm_enabled,
            LatencySensitivity = @var.Asset_compute_latency_sensitivity,
            MemoryInMbs = @var.Asset_compute_memory_in_mbs,
            Nics = new[]
            {
                new Oci.CloudBridge.Inputs.AssetComputeNicArgs
                {
                    IpAddresses = @var.Asset_compute_nics_ip_addresses,
                    Label = @var.Asset_compute_nics_label,
                    MacAddress = @var.Asset_compute_nics_mac_address,
                    MacAddressType = @var.Asset_compute_nics_mac_address_type,
                    NetworkName = @var.Asset_compute_nics_network_name,
                    SwitchName = @var.Asset_compute_nics_switch_name,
                },
            },
            NicsCount = @var.Asset_compute_nics_count,
            NvdimmController = new Oci.CloudBridge.Inputs.AssetComputeNvdimmControllerArgs
            {
                BusNumber = @var.Asset_compute_nvdimm_controller_bus_number,
                Label = @var.Asset_compute_nvdimm_controller_label,
            },
            Nvdimms = new[]
            {
                new Oci.CloudBridge.Inputs.AssetComputeNvdimmArgs
                {
                    ControllerKey = @var.Asset_compute_nvdimms_controller_key,
                    Label = @var.Asset_compute_nvdimms_label,
                    UnitNumber = @var.Asset_compute_nvdimms_unit_number,
                },
            },
            OperatingSystem = @var.Asset_compute_operating_system,
            OperatingSystemVersion = @var.Asset_compute_operating_system_version,
            PmemInMbs = @var.Asset_compute_pmem_in_mbs,
            PowerState = @var.Asset_compute_power_state,
            PrimaryIp = @var.Asset_compute_primary_ip,
            ScsiController = new Oci.CloudBridge.Inputs.AssetComputeScsiControllerArgs
            {
                Label = @var.Asset_compute_scsi_controller_label,
                SharedBus = @var.Asset_compute_scsi_controller_shared_bus,
                UnitNumber = @var.Asset_compute_scsi_controller_unit_number,
            },
            StorageProvisionedInMbs = @var.Asset_compute_storage_provisioned_in_mbs,
            ThreadsPerCoreCount = @var.Asset_compute_threads_per_core_count,
        },
        DefinedTags = 
        {
            { "Operations.CostCenter", "42" },
        },
        DisplayName = @var.Asset_display_name,
        FreeformTags = 
        {
            { "Department", "Finance" },
        },
        Vm = new Oci.CloudBridge.Inputs.AssetVmArgs
        {
            HypervisorHost = @var.Asset_vm_hypervisor_host,
            HypervisorVendor = @var.Asset_vm_hypervisor_vendor,
            HypervisorVersion = @var.Asset_vm_hypervisor_version,
        },
        VmwareVcenter = new Oci.CloudBridge.Inputs.AssetVmwareVcenterArgs
        {
            DataCenter = @var.Asset_vmware_vcenter_data_center,
            VcenterKey = @var.Asset_vmware_vcenter_vcenter_key,
            VcenterVersion = @var.Asset_vmware_vcenter_vcenter_version,
        },
        VmwareVm = new Oci.CloudBridge.Inputs.AssetVmwareVmArgs
        {
            Cluster = @var.Asset_vmware_vm_cluster,
            CustomerFields = @var.Asset_vmware_vm_customer_fields,
            CustomerTags = new[]
            {
                new Oci.CloudBridge.Inputs.AssetVmwareVmCustomerTagArgs
                {
                    Description = @var.Asset_vmware_vm_customer_tags_description,
                    Name = @var.Asset_vmware_vm_customer_tags_name,
                },
            },
            FaultToleranceBandwidth = @var.Asset_vmware_vm_fault_tolerance_bandwidth,
            FaultToleranceSecondaryLatency = @var.Asset_vmware_vm_fault_tolerance_secondary_latency,
            FaultToleranceState = @var.Asset_vmware_vm_fault_tolerance_state,
            InstanceUuid = @var.Asset_vmware_vm_instance_uuid,
            IsDisksCbtEnabled = @var.Asset_vmware_vm_is_disks_cbt_enabled,
            IsDisksUuidEnabled = @var.Asset_vmware_vm_is_disks_uuid_enabled,
            Path = @var.Asset_vmware_vm_path,
            VmwareToolsStatus = @var.Asset_vmware_vm_vmware_tools_status,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.oci.CloudBridge.Asset;
import com.pulumi.oci.CloudBridge.AssetArgs;
import com.pulumi.oci.CloudBridge.inputs.AssetComputeArgs;
import com.pulumi.oci.CloudBridge.inputs.AssetComputeNvdimmControllerArgs;
import com.pulumi.oci.CloudBridge.inputs.AssetComputeScsiControllerArgs;
import com.pulumi.oci.CloudBridge.inputs.AssetVmArgs;
import com.pulumi.oci.CloudBridge.inputs.AssetVmwareVcenterArgs;
import com.pulumi.oci.CloudBridge.inputs.AssetVmwareVmArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var testAsset = new Asset("testAsset", AssetArgs.builder()        
            .assetType(var_.asset_asset_type())
            .compartmentId(var_.compartment_id())
            .externalAssetKey(var_.asset_external_asset_key())
            .inventoryId(oci_cloud_bridge_inventory.test_inventory().id())
            .sourceKey(var_.asset_source_key())
            .assetSourceIds(var_.asset_asset_source_ids())
            .compute(AssetComputeArgs.builder()
                .connectedNetworks(var_.asset_compute_connected_networks())
                .coresCount(var_.asset_compute_cores_count())
                .cpuModel(var_.asset_compute_cpu_model())
                .description(var_.asset_compute_description())
                .disks(AssetComputeDiskArgs.builder()
                    .bootOrder(var_.asset_compute_disks_boot_order())
                    .location(var_.asset_compute_disks_location())
                    .name(var_.asset_compute_disks_name())
                    .persistentMode(var_.asset_compute_disks_persistent_mode())
                    .sizeInMbs(var_.asset_compute_disks_size_in_mbs())
                    .uuid(var_.asset_compute_disks_uuid())
                    .uuidLun(var_.asset_compute_disks_uuid_lun())
                    .build())
                .disksCount(var_.asset_compute_disks_count())
                .dnsName(var_.asset_compute_dns_name())
                .firmware(var_.asset_compute_firmware())
                .gpuDevices(AssetComputeGpuDeviceArgs.builder()
                    .coresCount(var_.asset_compute_gpu_devices_cores_count())
                    .description(var_.asset_compute_gpu_devices_description())
                    .manufacturer(var_.asset_compute_gpu_devices_manufacturer())
                    .memoryInMbs(var_.asset_compute_gpu_devices_memory_in_mbs())
                    .name(var_.asset_compute_gpu_devices_name())
                    .build())
                .gpuDevicesCount(var_.asset_compute_gpu_devices_count())
                .guestState(var_.asset_compute_guest_state())
                .hardwareVersion(var_.asset_compute_hardware_version())
                .hostName(var_.asset_compute_host_name())
                .isPmemEnabled(var_.asset_compute_is_pmem_enabled())
                .isTpmEnabled(var_.asset_compute_is_tpm_enabled())
                .latencySensitivity(var_.asset_compute_latency_sensitivity())
                .memoryInMbs(var_.asset_compute_memory_in_mbs())
                .nics(AssetComputeNicArgs.builder()
                    .ipAddresses(var_.asset_compute_nics_ip_addresses())
                    .label(var_.asset_compute_nics_label())
                    .macAddress(var_.asset_compute_nics_mac_address())
                    .macAddressType(var_.asset_compute_nics_mac_address_type())
                    .networkName(var_.asset_compute_nics_network_name())
                    .switchName(var_.asset_compute_nics_switch_name())
                    .build())
                .nicsCount(var_.asset_compute_nics_count())
                .nvdimmController(AssetComputeNvdimmControllerArgs.builder()
                    .busNumber(var_.asset_compute_nvdimm_controller_bus_number())
                    .label(var_.asset_compute_nvdimm_controller_label())
                    .build())
                .nvdimms(AssetComputeNvdimmArgs.builder()
                    .controllerKey(var_.asset_compute_nvdimms_controller_key())
                    .label(var_.asset_compute_nvdimms_label())
                    .unitNumber(var_.asset_compute_nvdimms_unit_number())
                    .build())
                .operatingSystem(var_.asset_compute_operating_system())
                .operatingSystemVersion(var_.asset_compute_operating_system_version())
                .pmemInMbs(var_.asset_compute_pmem_in_mbs())
                .powerState(var_.asset_compute_power_state())
                .primaryIp(var_.asset_compute_primary_ip())
                .scsiController(AssetComputeScsiControllerArgs.builder()
                    .label(var_.asset_compute_scsi_controller_label())
                    .sharedBus(var_.asset_compute_scsi_controller_shared_bus())
                    .unitNumber(var_.asset_compute_scsi_controller_unit_number())
                    .build())
                .storageProvisionedInMbs(var_.asset_compute_storage_provisioned_in_mbs())
                .threadsPerCoreCount(var_.asset_compute_threads_per_core_count())
                .build())
            .definedTags(Map.of("Operations.CostCenter", "42"))
            .displayName(var_.asset_display_name())
            .freeformTags(Map.of("Department", "Finance"))
            .vm(AssetVmArgs.builder()
                .hypervisorHost(var_.asset_vm_hypervisor_host())
                .hypervisorVendor(var_.asset_vm_hypervisor_vendor())
                .hypervisorVersion(var_.asset_vm_hypervisor_version())
                .build())
            .vmwareVcenter(AssetVmwareVcenterArgs.builder()
                .dataCenter(var_.asset_vmware_vcenter_data_center())
                .vcenterKey(var_.asset_vmware_vcenter_vcenter_key())
                .vcenterVersion(var_.asset_vmware_vcenter_vcenter_version())
                .build())
            .vmwareVm(AssetVmwareVmArgs.builder()
                .cluster(var_.asset_vmware_vm_cluster())
                .customerFields(var_.asset_vmware_vm_customer_fields())
                .customerTags(AssetVmwareVmCustomerTagArgs.builder()
                    .description(var_.asset_vmware_vm_customer_tags_description())
                    .name(var_.asset_vmware_vm_customer_tags_name())
                    .build())
                .faultToleranceBandwidth(var_.asset_vmware_vm_fault_tolerance_bandwidth())
                .faultToleranceSecondaryLatency(var_.asset_vmware_vm_fault_tolerance_secondary_latency())
                .faultToleranceState(var_.asset_vmware_vm_fault_tolerance_state())
                .instanceUuid(var_.asset_vmware_vm_instance_uuid())
                .isDisksCbtEnabled(var_.asset_vmware_vm_is_disks_cbt_enabled())
                .isDisksUuidEnabled(var_.asset_vmware_vm_is_disks_uuid_enabled())
                .path(var_.asset_vmware_vm_path())
                .vmwareToolsStatus(var_.asset_vmware_vm_vmware_tools_status())
                .build())
            .build());

    }
}

resources:
  testAsset:
    type: oci:CloudBridge:Asset
    properties:
      #Required
      assetType: ${var.asset_asset_type}
      compartmentId: ${var.compartment_id}
      externalAssetKey: ${var.asset_external_asset_key}
      inventoryId: ${oci_cloud_bridge_inventory.test_inventory.id}
      sourceKey: ${var.asset_source_key}
      #Optional
      assetSourceIds: ${var.asset_asset_source_ids}
      compute:
        connectedNetworks: ${var.asset_compute_connected_networks}
        coresCount: ${var.asset_compute_cores_count}
        cpuModel: ${var.asset_compute_cpu_model}
        description: ${var.asset_compute_description}
        disks:
          - bootOrder: ${var.asset_compute_disks_boot_order}
            location: ${var.asset_compute_disks_location}
            name: ${var.asset_compute_disks_name}
            persistentMode: ${var.asset_compute_disks_persistent_mode}
            sizeInMbs: ${var.asset_compute_disks_size_in_mbs}
            uuid: ${var.asset_compute_disks_uuid}
            uuidLun: ${var.asset_compute_disks_uuid_lun}
        disksCount: ${var.asset_compute_disks_count}
        dnsName: ${var.asset_compute_dns_name}
        firmware: ${var.asset_compute_firmware}
        gpuDevices:
          - coresCount: ${var.asset_compute_gpu_devices_cores_count}
            description: ${var.asset_compute_gpu_devices_description}
            manufacturer: ${var.asset_compute_gpu_devices_manufacturer}
            memoryInMbs: ${var.asset_compute_gpu_devices_memory_in_mbs}
            name: ${var.asset_compute_gpu_devices_name}
        gpuDevicesCount: ${var.asset_compute_gpu_devices_count}
        guestState: ${var.asset_compute_guest_state}
        hardwareVersion: ${var.asset_compute_hardware_version}
        hostName: ${var.asset_compute_host_name}
        isPmemEnabled: ${var.asset_compute_is_pmem_enabled}
        isTpmEnabled: ${var.asset_compute_is_tpm_enabled}
        latencySensitivity: ${var.asset_compute_latency_sensitivity}
        memoryInMbs: ${var.asset_compute_memory_in_mbs}
        nics:
          - ipAddresses: ${var.asset_compute_nics_ip_addresses}
            label: ${var.asset_compute_nics_label}
            macAddress: ${var.asset_compute_nics_mac_address}
            macAddressType: ${var.asset_compute_nics_mac_address_type}
            networkName: ${var.asset_compute_nics_network_name}
            switchName: ${var.asset_compute_nics_switch_name}
        nicsCount: ${var.asset_compute_nics_count}
        nvdimmController:
          busNumber: ${var.asset_compute_nvdimm_controller_bus_number}
          label: ${var.asset_compute_nvdimm_controller_label}
        nvdimms:
          - controllerKey: ${var.asset_compute_nvdimms_controller_key}
            label: ${var.asset_compute_nvdimms_label}
            unitNumber: ${var.asset_compute_nvdimms_unit_number}
        operatingSystem: ${var.asset_compute_operating_system}
        operatingSystemVersion: ${var.asset_compute_operating_system_version}
        pmemInMbs: ${var.asset_compute_pmem_in_mbs}
        powerState: ${var.asset_compute_power_state}
        primaryIp: ${var.asset_compute_primary_ip}
        scsiController:
          label: ${var.asset_compute_scsi_controller_label}
          sharedBus: ${var.asset_compute_scsi_controller_shared_bus}
          unitNumber: ${var.asset_compute_scsi_controller_unit_number}
        storageProvisionedInMbs: ${var.asset_compute_storage_provisioned_in_mbs}
        threadsPerCoreCount: ${var.asset_compute_threads_per_core_count}
      definedTags:
        Operations.CostCenter: '42'
      displayName: ${var.asset_display_name}
      freeformTags:
        Department: Finance
      vm:
        hypervisorHost: ${var.asset_vm_hypervisor_host}
        hypervisorVendor: ${var.asset_vm_hypervisor_vendor}
        hypervisorVersion: ${var.asset_vm_hypervisor_version}
      vmwareVcenter:
        dataCenter: ${var.asset_vmware_vcenter_data_center}
        vcenterKey: ${var.asset_vmware_vcenter_vcenter_key}
        vcenterVersion: ${var.asset_vmware_vcenter_vcenter_version}
      vmwareVm:
        cluster: ${var.asset_vmware_vm_cluster}
        customerFields: ${var.asset_vmware_vm_customer_fields}
        customerTags:
          - description: ${var.asset_vmware_vm_customer_tags_description}
            name: ${var.asset_vmware_vm_customer_tags_name}
        faultToleranceBandwidth: ${var.asset_vmware_vm_fault_tolerance_bandwidth}
        faultToleranceSecondaryLatency: ${var.asset_vmware_vm_fault_tolerance_secondary_latency}
        faultToleranceState: ${var.asset_vmware_vm_fault_tolerance_state}
        instanceUuid: ${var.asset_vmware_vm_instance_uuid}
        isDisksCbtEnabled: ${var.asset_vmware_vm_is_disks_cbt_enabled}
        isDisksUuidEnabled: ${var.asset_vmware_vm_is_disks_uuid_enabled}
        path: ${var.asset_vmware_vm_path}
        vmwareToolsStatus: ${var.asset_vmware_vm_vmware_tools_status}

var assetResource = new Oci.CloudBridge.Asset("assetResource", new()
{
    SourceKey = "string",
    AssetType = "string",
    CompartmentId = "string",
    ExternalAssetKey = "string",
    InventoryId = "string",
    Compute = new Oci.CloudBridge.Inputs.AssetComputeArgs
    {
        ConnectedNetworks = 0,
        CoresCount = 0,
        CpuModel = "string",
        Description = "string",
        Disks = new[]
        {
            new Oci.CloudBridge.Inputs.AssetComputeDiskArgs
            {
                BootOrder = 0,
                Location = "string",
                Name = "string",
                PersistentMode = "string",
                SizeInMbs = "string",
                Uuid = "string",
                UuidLun = "string",
            },
        },
        DisksCount = 0,
        DnsName = "string",
        Firmware = "string",
        GpuDevices = new[]
        {
            new Oci.CloudBridge.Inputs.AssetComputeGpuDeviceArgs
            {
                CoresCount = 0,
                Description = "string",
                Manufacturer = "string",
                MemoryInMbs = "string",
                Name = "string",
            },
        },
        GpuDevicesCount = 0,
        GuestState = "string",
        HardwareVersion = "string",
        HostName = "string",
        IsPmemEnabled = false,
        IsTpmEnabled = false,
        LatencySensitivity = "string",
        MemoryInMbs = "string",
        Nics = new[]
        {
            new Oci.CloudBridge.Inputs.AssetComputeNicArgs
            {
                IpAddresses = new[]
                {
                    "string",
                },
                Label = "string",
                MacAddress = "string",
                MacAddressType = "string",
                NetworkName = "string",
                SwitchName = "string",
            },
        },
        NicsCount = 0,
        NvdimmController = new Oci.CloudBridge.Inputs.AssetComputeNvdimmControllerArgs
        {
            BusNumber = 0,
            Label = "string",
        },
        Nvdimms = new[]
        {
            new Oci.CloudBridge.Inputs.AssetComputeNvdimmArgs
            {
                ControllerKey = 0,
                Label = "string",
                UnitNumber = 0,
            },
        },
        OperatingSystem = "string",
        OperatingSystemVersion = "string",
        PmemInMbs = "string",
        PowerState = "string",
        PrimaryIp = "string",
        ScsiController = new Oci.CloudBridge.Inputs.AssetComputeScsiControllerArgs
        {
            Label = "string",
            SharedBus = "string",
            UnitNumber = 0,
        },
        StorageProvisionedInMbs = "string",
        ThreadsPerCoreCount = 0,
    },
    DefinedTags = 
    {
        { "string", "any" },
    },
    DisplayName = "string",
    FreeformTags = 
    {
        { "string", "any" },
    },
    AssetSourceIds = new[]
    {
        "string",
    },
    Vm = new Oci.CloudBridge.Inputs.AssetVmArgs
    {
        HypervisorHost = "string",
        HypervisorVendor = "string",
        HypervisorVersion = "string",
    },
    VmwareVcenter = new Oci.CloudBridge.Inputs.AssetVmwareVcenterArgs
    {
        DataCenter = "string",
        VcenterKey = "string",
        VcenterVersion = "string",
    },
    VmwareVm = new Oci.CloudBridge.Inputs.AssetVmwareVmArgs
    {
        Cluster = "string",
        CustomerFields = new[]
        {
            "string",
        },
        CustomerTags = new[]
        {
            new Oci.CloudBridge.Inputs.AssetVmwareVmCustomerTagArgs
            {
                Description = "string",
                Name = "string",
            },
        },
        FaultToleranceBandwidth = 0,
        FaultToleranceSecondaryLatency = 0,
        FaultToleranceState = "string",
        InstanceUuid = "string",
        IsDisksCbtEnabled = false,
        IsDisksUuidEnabled = false,
        Path = "string",
        VmwareToolsStatus = "string",
    },
});

example, err := CloudBridge.NewAsset(ctx, "assetResource", &CloudBridge.AssetArgs{
	SourceKey:        pulumi.String("string"),
	AssetType:        pulumi.String("string"),
	CompartmentId:    pulumi.String("string"),
	ExternalAssetKey: pulumi.String("string"),
	InventoryId:      pulumi.String("string"),
	Compute: &cloudbridge.AssetComputeArgs{
		ConnectedNetworks: pulumi.Int(0),
		CoresCount:        pulumi.Int(0),
		CpuModel:          pulumi.String("string"),
		Description:       pulumi.String("string"),
		Disks: cloudbridge.AssetComputeDiskArray{
			&cloudbridge.AssetComputeDiskArgs{
				BootOrder:      pulumi.Int(0),
				Location:       pulumi.String("string"),
				Name:           pulumi.String("string"),
				PersistentMode: pulumi.String("string"),
				SizeInMbs:      pulumi.String("string"),
				Uuid:           pulumi.String("string"),
				UuidLun:        pulumi.String("string"),
			},
		},
		DisksCount: pulumi.Int(0),
		DnsName:    pulumi.String("string"),
		Firmware:   pulumi.String("string"),
		GpuDevices: cloudbridge.AssetComputeGpuDeviceArray{
			&cloudbridge.AssetComputeGpuDeviceArgs{
				CoresCount:   pulumi.Int(0),
				Description:  pulumi.String("string"),
				Manufacturer: pulumi.String("string"),
				MemoryInMbs:  pulumi.String("string"),
				Name:         pulumi.String("string"),
			},
		},
		GpuDevicesCount:    pulumi.Int(0),
		GuestState:         pulumi.String("string"),
		HardwareVersion:    pulumi.String("string"),
		HostName:           pulumi.String("string"),
		IsPmemEnabled:      pulumi.Bool(false),
		IsTpmEnabled:       pulumi.Bool(false),
		LatencySensitivity: pulumi.String("string"),
		MemoryInMbs:        pulumi.String("string"),
		Nics: cloudbridge.AssetComputeNicArray{
			&cloudbridge.AssetComputeNicArgs{
				IpAddresses: pulumi.StringArray{
					pulumi.String("string"),
				},
				Label:          pulumi.String("string"),
				MacAddress:     pulumi.String("string"),
				MacAddressType: pulumi.String("string"),
				NetworkName:    pulumi.String("string"),
				SwitchName:     pulumi.String("string"),
			},
		},
		NicsCount: pulumi.Int(0),
		NvdimmController: &cloudbridge.AssetComputeNvdimmControllerArgs{
			BusNumber: pulumi.Int(0),
			Label:     pulumi.String("string"),
		},
		Nvdimms: cloudbridge.AssetComputeNvdimmArray{
			&cloudbridge.AssetComputeNvdimmArgs{
				ControllerKey: pulumi.Int(0),
				Label:         pulumi.String("string"),
				UnitNumber:    pulumi.Int(0),
			},
		},
		OperatingSystem:        pulumi.String("string"),
		OperatingSystemVersion: pulumi.String("string"),
		PmemInMbs:              pulumi.String("string"),
		PowerState:             pulumi.String("string"),
		PrimaryIp:              pulumi.String("string"),
		ScsiController: &cloudbridge.AssetComputeScsiControllerArgs{
			Label:      pulumi.String("string"),
			SharedBus:  pulumi.String("string"),
			UnitNumber: pulumi.Int(0),
		},
		StorageProvisionedInMbs: pulumi.String("string"),
		ThreadsPerCoreCount:     pulumi.Int(0),
	},
	DefinedTags: pulumi.Map{
		"string": pulumi.Any("any"),
	},
	DisplayName: pulumi.String("string"),
	FreeformTags: pulumi.Map{
		"string": pulumi.Any("any"),
	},
	AssetSourceIds: pulumi.StringArray{
		pulumi.String("string"),
	},
	Vm: &cloudbridge.AssetVmArgs{
		HypervisorHost:    pulumi.String("string"),
		HypervisorVendor:  pulumi.String("string"),
		HypervisorVersion: pulumi.String("string"),
	},
	VmwareVcenter: &cloudbridge.AssetVmwareVcenterArgs{
		DataCenter:     pulumi.String("string"),
		VcenterKey:     pulumi.String("string"),
		VcenterVersion: pulumi.String("string"),
	},
	VmwareVm: &cloudbridge.AssetVmwareVmArgs{
		Cluster: pulumi.String("string"),
		CustomerFields: pulumi.StringArray{
			pulumi.String("string"),
		},
		CustomerTags: cloudbridge.AssetVmwareVmCustomerTagArray{
			&cloudbridge.AssetVmwareVmCustomerTagArgs{
				Description: pulumi.String("string"),
				Name:        pulumi.String("string"),
			},
		},
		FaultToleranceBandwidth:        pulumi.Int(0),
		FaultToleranceSecondaryLatency: pulumi.Int(0),
		FaultToleranceState:            pulumi.String("string"),
		InstanceUuid:                   pulumi.String("string"),
		IsDisksCbtEnabled:              pulumi.Bool(false),
		IsDisksUuidEnabled:             pulumi.Bool(false),
		Path:                           pulumi.String("string"),
		VmwareToolsStatus:              pulumi.String("string"),
	},
})

var assetResource = new Asset("assetResource", AssetArgs.builder()        
    .sourceKey("string")
    .assetType("string")
    .compartmentId("string")
    .externalAssetKey("string")
    .inventoryId("string")
    .compute(AssetComputeArgs.builder()
        .connectedNetworks(0)
        .coresCount(0)
        .cpuModel("string")
        .description("string")
        .disks(AssetComputeDiskArgs.builder()
            .bootOrder(0)
            .location("string")
            .name("string")
            .persistentMode("string")
            .sizeInMbs("string")
            .uuid("string")
            .uuidLun("string")
            .build())
        .disksCount(0)
        .dnsName("string")
        .firmware("string")
        .gpuDevices(AssetComputeGpuDeviceArgs.builder()
            .coresCount(0)
            .description("string")
            .manufacturer("string")
            .memoryInMbs("string")
            .name("string")
            .build())
        .gpuDevicesCount(0)
        .guestState("string")
        .hardwareVersion("string")
        .hostName("string")
        .isPmemEnabled(false)
        .isTpmEnabled(false)
        .latencySensitivity("string")
        .memoryInMbs("string")
        .nics(AssetComputeNicArgs.builder()
            .ipAddresses("string")
            .label("string")
            .macAddress("string")
            .macAddressType("string")
            .networkName("string")
            .switchName("string")
            .build())
        .nicsCount(0)
        .nvdimmController(AssetComputeNvdimmControllerArgs.builder()
            .busNumber(0)
            .label("string")
            .build())
        .nvdimms(AssetComputeNvdimmArgs.builder()
            .controllerKey(0)
            .label("string")
            .unitNumber(0)
            .build())
        .operatingSystem("string")
        .operatingSystemVersion("string")
        .pmemInMbs("string")
        .powerState("string")
        .primaryIp("string")
        .scsiController(AssetComputeScsiControllerArgs.builder()
            .label("string")
            .sharedBus("string")
            .unitNumber(0)
            .build())
        .storageProvisionedInMbs("string")
        .threadsPerCoreCount(0)
        .build())
    .definedTags(Map.of("string", "any"))
    .displayName("string")
    .freeformTags(Map.of("string", "any"))
    .assetSourceIds("string")
    .vm(AssetVmArgs.builder()
        .hypervisorHost("string")
        .hypervisorVendor("string")
        .hypervisorVersion("string")
        .build())
    .vmwareVcenter(AssetVmwareVcenterArgs.builder()
        .dataCenter("string")
        .vcenterKey("string")
        .vcenterVersion("string")
        .build())
    .vmwareVm(AssetVmwareVmArgs.builder()
        .cluster("string")
        .customerFields("string")
        .customerTags(AssetVmwareVmCustomerTagArgs.builder()
            .description("string")
            .name("string")
            .build())
        .faultToleranceBandwidth(0)
        .faultToleranceSecondaryLatency(0)
        .faultToleranceState("string")
        .instanceUuid("string")
        .isDisksCbtEnabled(false)
        .isDisksUuidEnabled(false)
        .path("string")
        .vmwareToolsStatus("string")
        .build())
    .build());