pulumi-vsphere 4.10.0a1710245029__py3-none-any.whl → 4.13.0a1736836157__py3-none-any.whl

pulumi_vsphere/_inputs.py

@@ -4,53 +4,234 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
 
 __all__ = [
+    'ComputeClusterHostImageArgs',
+    'ComputeClusterHostImageArgsDict',
+    'ComputeClusterHostImageComponentArgs',
+    'ComputeClusterHostImageComponentArgsDict',
     'ComputeClusterVsanDiskGroupArgs',
+    'ComputeClusterVsanDiskGroupArgsDict',
     'ComputeClusterVsanFaultDomainArgs',
+    'ComputeClusterVsanFaultDomainArgsDict',
     'ComputeClusterVsanFaultDomainFaultDomainArgs',
+    'ComputeClusterVsanFaultDomainFaultDomainArgsDict',
     'ComputeClusterVsanStretchedClusterArgs',
+    'ComputeClusterVsanStretchedClusterArgsDict',
     'ContentLibraryPublicationArgs',
+    'ContentLibraryPublicationArgsDict',
     'ContentLibrarySubscriptionArgs',
+    'ContentLibrarySubscriptionArgsDict',
     'DistributedPortGroupVlanRangeArgs',
+    'DistributedPortGroupVlanRangeArgsDict',
     'DistributedVirtualSwitchHostArgs',
+    'DistributedVirtualSwitchHostArgsDict',
     'DistributedVirtualSwitchPvlanMappingArgs',
+    'DistributedVirtualSwitchPvlanMappingArgsDict',
     'DistributedVirtualSwitchVlanRangeArgs',
+    'DistributedVirtualSwitchVlanRangeArgsDict',
     'EntityPermissionsPermissionArgs',
+    'EntityPermissionsPermissionArgsDict',
     'GuestOsCustomizationSpecArgs',
+    'GuestOsCustomizationSpecArgsDict',
     'GuestOsCustomizationSpecLinuxOptionsArgs',
+    'GuestOsCustomizationSpecLinuxOptionsArgsDict',
     'GuestOsCustomizationSpecNetworkInterfaceArgs',
+    'GuestOsCustomizationSpecNetworkInterfaceArgsDict',
     'GuestOsCustomizationSpecWindowsOptionsArgs',
+    'GuestOsCustomizationSpecWindowsOptionsArgsDict',
     'HostPortGroupPortArgs',
+    'HostPortGroupPortArgsDict',
+    'HostServiceArgs',
+    'HostServiceArgsDict',
+    'HostServiceNtpdArgs',
+    'HostServiceNtpdArgsDict',
+    'OfflineSoftwareDepotComponentArgs',
+    'OfflineSoftwareDepotComponentArgsDict',
+    'SupervisorEgressCidrArgs',
+    'SupervisorEgressCidrArgsDict',
+    'SupervisorIngressCidrArgs',
+    'SupervisorIngressCidrArgsDict',
+    'SupervisorManagementNetworkArgs',
+    'SupervisorManagementNetworkArgsDict',
+    'SupervisorNamespaceArgs',
+    'SupervisorNamespaceArgsDict',
+    'SupervisorPodCidrArgs',
+    'SupervisorPodCidrArgsDict',
+    'SupervisorServiceCidrArgs',
+    'SupervisorServiceCidrArgsDict',
     'VirtualMachineCdromArgs',
+    'VirtualMachineCdromArgsDict',
     'VirtualMachineCloneArgs',
+    'VirtualMachineCloneArgsDict',
     'VirtualMachineCloneCustomizationSpecArgs',
+    'VirtualMachineCloneCustomizationSpecArgsDict',
     'VirtualMachineCloneCustomizeArgs',
+    'VirtualMachineCloneCustomizeArgsDict',
     'VirtualMachineCloneCustomizeLinuxOptionsArgs',
+    'VirtualMachineCloneCustomizeLinuxOptionsArgsDict',
     'VirtualMachineCloneCustomizeNetworkInterfaceArgs',
+    'VirtualMachineCloneCustomizeNetworkInterfaceArgsDict',
     'VirtualMachineCloneCustomizeWindowsOptionsArgs',
+    'VirtualMachineCloneCustomizeWindowsOptionsArgsDict',
     'VirtualMachineDiskArgs',
+    'VirtualMachineDiskArgsDict',
     'VirtualMachineNetworkInterfaceArgs',
+    'VirtualMachineNetworkInterfaceArgsDict',
     'VirtualMachineOvfDeployArgs',
+    'VirtualMachineOvfDeployArgsDict',
     'VirtualMachineVappArgs',
+    'VirtualMachineVappArgsDict',
+    'VirtualMachineVtpmArgs',
+    'VirtualMachineVtpmArgsDict',
     'VmStoragePolicyTagRuleArgs',
+    'VmStoragePolicyTagRuleArgsDict',
     'VnicIpv4Args',
+    'VnicIpv4ArgsDict',
     'VnicIpv6Args',
+    'VnicIpv6ArgsDict',
+    'GetNetworkFilterArgs',
+    'GetNetworkFilterArgsDict',
     'GetVirtualMachineVappArgs',
+    'GetVirtualMachineVappArgsDict',
 ]
 
+MYPY = False
+
+if not MYPY:
+    class ComputeClusterHostImageArgsDict(TypedDict):
+        components: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeClusterHostImageComponentArgsDict']]]]
+        """
+        List of custom components.
+        """
+        esx_version: NotRequired[pulumi.Input[str]]
+        """
+        The ESXi version which the image is based on.
+        """
+elif False:
+    ComputeClusterHostImageArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ComputeClusterHostImageArgs:
+    def __init__(__self__, *,
+                 components: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeClusterHostImageComponentArgs']]]] = None,
+                 esx_version: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input['ComputeClusterHostImageComponentArgs']]] components: List of custom components.
+        :param pulumi.Input[str] esx_version: The ESXi version which the image is based on.
+        """
+        if components is not None:
+            pulumi.set(__self__, "components", components)
+        if esx_version is not None:
+            pulumi.set(__self__, "esx_version", esx_version)
+
+    @property
+    @pulumi.getter
+    def components(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeClusterHostImageComponentArgs']]]]:
+        """
+        List of custom components.
+        """
+        return pulumi.get(self, "components")
+
+    @components.setter
+    def components(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeClusterHostImageComponentArgs']]]]):
+        pulumi.set(self, "components", value)
+
+    @property
+    @pulumi.getter(name="esxVersion")
+    def esx_version(self) -> Optional[pulumi.Input[str]]:
+        """
+        The ESXi version which the image is based on.
+        """
+        return pulumi.get(self, "esx_version")
+
+    @esx_version.setter
+    def esx_version(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "esx_version", value)
+
+
+if not MYPY:
+    class ComputeClusterHostImageComponentArgsDict(TypedDict):
+        key: NotRequired[pulumi.Input[str]]
+        """
+        The identifier for the component.
+        """
+        version: NotRequired[pulumi.Input[str]]
+        """
+        The version to use.
+        """
+elif False:
+    ComputeClusterHostImageComponentArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ComputeClusterHostImageComponentArgs:
+    def __init__(__self__, *,
+                 key: Optional[pulumi.Input[str]] = None,
+                 version: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] key: The identifier for the component.
+        :param pulumi.Input[str] version: The version to use.
+        """
+        if key is not None:
+            pulumi.set(__self__, "key", key)
+        if version is not None:
+            pulumi.set(__self__, "version", version)
+
+    @property
+    @pulumi.getter
+    def key(self) -> Optional[pulumi.Input[str]]:
+        """
+        The identifier for the component.
+        """
+        return pulumi.get(self, "key")
+
+    @key.setter
+    def key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "key", value)
+
+    @property
+    @pulumi.getter
+    def version(self) -> Optional[pulumi.Input[str]]:
+        """
+        The version to use.
+        """
+        return pulumi.get(self, "version")
+
+    @version.setter
+    def version(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "version", value)
+
+
+if not MYPY:
+    class ComputeClusterVsanDiskGroupArgsDict(TypedDict):
+        cache: NotRequired[pulumi.Input[str]]
+        """
+        Cache disk.
+        """
+        storages: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of storage disks.
+        """
+elif False:
+    ComputeClusterVsanDiskGroupArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ComputeClusterVsanDiskGroupArgs:
     def __init__(__self__, *,
                  cache: Optional[pulumi.Input[str]] = None,
                  storages: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
         """
-        :param pulumi.Input[str] cache: The canonical name of the disk to use for vSAN cache.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] storages: An array of disk canonical names for vSAN storage.
+        :param pulumi.Input[str] cache: Cache disk.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] storages: List of storage disks.
         """
         if cache is not None:
             pulumi.set(__self__, "cache", cache)
@@ -61,7 +242,7 @@ class ComputeClusterVsanDiskGroupArgs:
     @pulumi.getter
     def cache(self) -> Optional[pulumi.Input[str]]:
         """
-        The canonical name of the disk to use for vSAN cache.
+        Cache disk.
         """
         return pulumi.get(self, "cache")
 
@@ -73,7 +254,7 @@ class ComputeClusterVsanDiskGroupArgs:
     @pulumi.getter
     def storages(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
         """
-        An array of disk canonical names for vSAN storage.
+        List of storage disks.
         """
         return pulumi.get(self, "storages")
 
@@ -82,6 +263,15 @@ class ComputeClusterVsanDiskGroupArgs:
         pulumi.set(self, "storages", value)
 
 
+if not MYPY:
+    class ComputeClusterVsanFaultDomainArgsDict(TypedDict):
+        fault_domains: NotRequired[pulumi.Input[Sequence[pulumi.Input['ComputeClusterVsanFaultDomainFaultDomainArgsDict']]]]
+        """
+        The configuration for single fault domain.
+        """
+elif False:
+    ComputeClusterVsanFaultDomainArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ComputeClusterVsanFaultDomainArgs:
     def __init__(__self__, *,
@@ -105,6 +295,19 @@ class ComputeClusterVsanFaultDomainArgs:
         pulumi.set(self, "fault_domains", value)
 
 
+if not MYPY:
+    class ComputeClusterVsanFaultDomainFaultDomainArgsDict(TypedDict):
+        host_ids: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        The managed object IDs of the hosts to put in the fault domain.
+        """
+        name: pulumi.Input[str]
+        """
+        The name of the cluster.
+        """
+elif False:
+    ComputeClusterVsanFaultDomainFaultDomainArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ComputeClusterVsanFaultDomainFaultDomainArgs:
     def __init__(__self__, *,
@@ -142,6 +345,31 @@ class ComputeClusterVsanFaultDomainFaultDomainArgs:
         pulumi.set(self, "name", value)
 
 
+if not MYPY:
+    class ComputeClusterVsanStretchedClusterArgsDict(TypedDict):
+        preferred_fault_domain_host_ids: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        The managed object IDs of the hosts to put in the first fault domain.
+        """
+        secondary_fault_domain_host_ids: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        The managed object IDs of the hosts to put in the second fault domain.
+        """
+        witness_node: pulumi.Input[str]
+        """
+        The managed object IDs of the host selected as witness node when enable stretched cluster.
+        """
+        preferred_fault_domain_name: NotRequired[pulumi.Input[str]]
+        """
+        The name of prepferred fault domain.
+        """
+        secondary_fault_domain_name: NotRequired[pulumi.Input[str]]
+        """
+        The name of secondary fault domain.
+        """
+elif False:
+    ComputeClusterVsanStretchedClusterArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ComputeClusterVsanStretchedClusterArgs:
     def __init__(__self__, *,
@@ -154,56 +382,8 @@ class ComputeClusterVsanStretchedClusterArgs:
         :param pulumi.Input[Sequence[pulumi.Input[str]]] preferred_fault_domain_host_ids: The managed object IDs of the hosts to put in the first fault domain.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] secondary_fault_domain_host_ids: The managed object IDs of the hosts to put in the second fault domain.
         :param pulumi.Input[str] witness_node: The managed object IDs of the host selected as witness node when enable stretched cluster.
-        :param pulumi.Input[str] preferred_fault_domain_name: The name of first fault domain. Default is `Preferred`.
-        :param pulumi.Input[str] secondary_fault_domain_name: The name of second fault domain. Default is `Secondary`.
-               
-               > **NOTE:** You must disable vSphere HA before you enable vSAN on the cluster.
-               You can enable or re-enable vSphere HA after vSAN is configured.
-               
-               <!--Start PulumiCodeChooser -->
-               ```python
-               import pulumi
-               import pulumi_vsphere as vsphere
-               
-               compute_cluster = vsphere.ComputeCluster("computeCluster",
-                   datacenter_id=data["vsphere_datacenter"]["datacenter"]["id"],
-                   host_system_ids=[[__item["id"] for __item in data["vsphere_host"]["host"]]],
-                   drs_enabled=True,
-                   drs_automation_level="fullyAutomated",
-                   ha_enabled=False,
-                   vsan_enabled=True,
-                   vsan_esa_enabled=True,
-                   vsan_dedup_enabled=True,
-                   vsan_compression_enabled=True,
-                   vsan_performance_enabled=True,
-                   vsan_verbose_mode_enabled=True,
-                   vsan_network_diagnostic_mode_enabled=True,
-                   vsan_unmap_enabled=True,
-                   vsan_dit_encryption_enabled=True,
-                   vsan_dit_rekey_interval=1800,
-                   vsan_disk_groups=[vsphere.ComputeClusterVsanDiskGroupArgs(
-                       cache=data["vsphere_vmfs_disks"]["cache_disks"],
-                       storages=data["vsphere_vmfs_disks"]["storage_disks"],
-                   )],
-                   vsan_fault_domains=[vsphere.ComputeClusterVsanFaultDomainArgs(
-                       fault_domains=[
-                           vsphere.ComputeClusterVsanFaultDomainFaultDomainArgs(
-                               name="fd1",
-                               host_ids=[[__item["id"] for __item in data["vsphere_host"]["faultdomain1_hosts"]]],
-                           ),
-                           vsphere.ComputeClusterVsanFaultDomainFaultDomainArgs(
-                               name="fd2",
-                               host_ids=[[__item["id"] for __item in data["vsphere_host"]["faultdomain2_hosts"]]],
-                           ),
-                       ],
-                   )],
-                   vsan_stretched_cluster=vsphere.ComputeClusterVsanStretchedClusterArgs(
-                       preferred_fault_domain_host_ids=[[__item["id"] for __item in data["vsphere_host"]["preferred_fault_domain_host"]]],
-                       secondary_fault_domain_host_ids=[[__item["id"] for __item in data["vsphere_host"]["secondary_fault_domain_host"]]],
-                       witness_node=data["vsphere_host"]["witness_host"]["id"],
-                   ))
-               ```
-               <!--End PulumiCodeChooser -->
+        :param pulumi.Input[str] preferred_fault_domain_name: The name of prepferred fault domain.
+        :param pulumi.Input[str] secondary_fault_domain_name: The name of secondary fault domain.
         """
         pulumi.set(__self__, "preferred_fault_domain_host_ids", preferred_fault_domain_host_ids)
         pulumi.set(__self__, "secondary_fault_domain_host_ids", secondary_fault_domain_host_ids)
@@ -253,7 +433,7 @@ class ComputeClusterVsanStretchedClusterArgs:
     @pulumi.getter(name="preferredFaultDomainName")
     def preferred_fault_domain_name(self) -> Optional[pulumi.Input[str]]:
         """
-        The name of first fault domain. Default is `Preferred`.
+        The name of prepferred fault domain.
         """
         return pulumi.get(self, "preferred_fault_domain_name")
 
@@ -265,55 +445,7 @@ class ComputeClusterVsanStretchedClusterArgs:
     @pulumi.getter(name="secondaryFaultDomainName")
     def secondary_fault_domain_name(self) -> Optional[pulumi.Input[str]]:
         """
-        The name of second fault domain. Default is `Secondary`.
-
-        > **NOTE:** You must disable vSphere HA before you enable vSAN on the cluster.
-        You can enable or re-enable vSphere HA after vSAN is configured.
-
-        <!--Start PulumiCodeChooser -->
-        ```python
-        import pulumi
-        import pulumi_vsphere as vsphere
-
-        compute_cluster = vsphere.ComputeCluster("computeCluster",
-            datacenter_id=data["vsphere_datacenter"]["datacenter"]["id"],
-            host_system_ids=[[__item["id"] for __item in data["vsphere_host"]["host"]]],
-            drs_enabled=True,
-            drs_automation_level="fullyAutomated",
-            ha_enabled=False,
-            vsan_enabled=True,
-            vsan_esa_enabled=True,
-            vsan_dedup_enabled=True,
-            vsan_compression_enabled=True,
-            vsan_performance_enabled=True,
-            vsan_verbose_mode_enabled=True,
-            vsan_network_diagnostic_mode_enabled=True,
-            vsan_unmap_enabled=True,
-            vsan_dit_encryption_enabled=True,
-            vsan_dit_rekey_interval=1800,
-            vsan_disk_groups=[vsphere.ComputeClusterVsanDiskGroupArgs(
-                cache=data["vsphere_vmfs_disks"]["cache_disks"],
-                storages=data["vsphere_vmfs_disks"]["storage_disks"],
-            )],
-            vsan_fault_domains=[vsphere.ComputeClusterVsanFaultDomainArgs(
-                fault_domains=[
-                    vsphere.ComputeClusterVsanFaultDomainFaultDomainArgs(
-                        name="fd1",
-                        host_ids=[[__item["id"] for __item in data["vsphere_host"]["faultdomain1_hosts"]]],
-                    ),
-                    vsphere.ComputeClusterVsanFaultDomainFaultDomainArgs(
-                        name="fd2",
-                        host_ids=[[__item["id"] for __item in data["vsphere_host"]["faultdomain2_hosts"]]],
-                    ),
-                ],
-            )],
-            vsan_stretched_cluster=vsphere.ComputeClusterVsanStretchedClusterArgs(
-                preferred_fault_domain_host_ids=[[__item["id"] for __item in data["vsphere_host"]["preferred_fault_domain_host"]]],
-                secondary_fault_domain_host_ids=[[__item["id"] for __item in data["vsphere_host"]["secondary_fault_domain_host"]]],
-                witness_node=data["vsphere_host"]["witness_host"]["id"],
-            ))
-        ```
-        <!--End PulumiCodeChooser -->
+        The name of secondary fault domain.
         """
         return pulumi.get(self, "secondary_fault_domain_name")
 
@@ -322,6 +454,31 @@ class ComputeClusterVsanStretchedClusterArgs:
         pulumi.set(self, "secondary_fault_domain_name", value)
 
 
+if not MYPY:
+    class ContentLibraryPublicationArgsDict(TypedDict):
+        authentication_method: NotRequired[pulumi.Input[str]]
+        """
+        Method to authenticate users. Must be `NONE` or `BASIC`.
+        """
+        password: NotRequired[pulumi.Input[str]]
+        """
+        Password used by subscribers to authenticate.
+        """
+        publish_url: NotRequired[pulumi.Input[str]]
+        """
+        The URL of the published content library.
+        """
+        published: NotRequired[pulumi.Input[bool]]
+        """
+        Publish the content library. Default `false`.
+        """
+        username: NotRequired[pulumi.Input[str]]
+        """
+        Username used by subscribers to authenticate. Currently can only be `vcsp`.
+        """
+elif False:
+    ContentLibraryPublicationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ContentLibraryPublicationArgs:
     def __init__(__self__, *,
@@ -331,11 +488,11 @@ class ContentLibraryPublicationArgs:
                  published: Optional[pulumi.Input[bool]] = None,
                  username: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[str] authentication_method: Authentication method to connect ro a published content library. Must be `NONE` or `BASIC`.
-        :param pulumi.Input[str] password: Password used for authentication.
+        :param pulumi.Input[str] authentication_method: Method to authenticate users. Must be `NONE` or `BASIC`.
+        :param pulumi.Input[str] password: Password used by subscribers to authenticate.
         :param pulumi.Input[str] publish_url: The URL of the published content library.
         :param pulumi.Input[bool] published: Publish the content library. Default `false`.
-        :param pulumi.Input[str] username: Username used for authentication.
+        :param pulumi.Input[str] username: Username used by subscribers to authenticate. Currently can only be `vcsp`.
         """
         if authentication_method is not None:
             pulumi.set(__self__, "authentication_method", authentication_method)
@@ -352,7 +509,7 @@ class ContentLibraryPublicationArgs:
     @pulumi.getter(name="authenticationMethod")
     def authentication_method(self) -> Optional[pulumi.Input[str]]:
         """
-        Authentication method to connect ro a published content library. Must be `NONE` or `BASIC`.
+        Method to authenticate users. Must be `NONE` or `BASIC`.
         """
         return pulumi.get(self, "authentication_method")
 
@@ -364,7 +521,7 @@ class ContentLibraryPublicationArgs:
     @pulumi.getter
     def password(self) -> Optional[pulumi.Input[str]]:
         """
-        Password used for authentication.
+        Password used by subscribers to authenticate.
         """
         return pulumi.get(self, "password")
 
@@ -400,7 +557,7 @@ class ContentLibraryPublicationArgs:
     @pulumi.getter
     def username(self) -> Optional[pulumi.Input[str]]:
         """
-        Username used for authentication.
+        Username used by subscribers to authenticate. Currently can only be `vcsp`.
         """
         return pulumi.get(self, "username")
 
@@ -409,6 +566,35 @@ class ContentLibraryPublicationArgs:
         pulumi.set(self, "username", value)
 
 
+if not MYPY:
+    class ContentLibrarySubscriptionArgsDict(TypedDict):
+        authentication_method: NotRequired[pulumi.Input[str]]
+        """
+        Authentication method to connect ro a published content library. Must be `NONE` or `BASIC`.
+        """
+        automatic_sync: NotRequired[pulumi.Input[bool]]
+        """
+        Enable automatic synchronization with the published library. Default `false`.
+        """
+        on_demand: NotRequired[pulumi.Input[bool]]
+        """
+        Download the library from a content only when needed. Default `true`.
+        """
+        password: NotRequired[pulumi.Input[str]]
+        """
+        Password used for authentication.
+        """
+        subscription_url: NotRequired[pulumi.Input[str]]
+        """
+        URL of the published content library.
+        """
+        username: NotRequired[pulumi.Input[str]]
+        """
+        Username used for authentication.
+        """
+elif False:
+    ContentLibrarySubscriptionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class ContentLibrarySubscriptionArgs:
     def __init__(__self__, *,
@@ -512,6 +698,19 @@ class ContentLibrarySubscriptionArgs:
         pulumi.set(self, "username", value)
 
 
+if not MYPY:
+    class DistributedPortGroupVlanRangeArgsDict(TypedDict):
+        max_vlan: pulumi.Input[int]
+        """
+        The minimum VLAN to use in the range.
+        """
+        min_vlan: pulumi.Input[int]
+        """
+        The minimum VLAN to use in the range.
+        """
+elif False:
+    DistributedPortGroupVlanRangeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DistributedPortGroupVlanRangeArgs:
     def __init__(__self__, *,
@@ -549,16 +748,27 @@ class DistributedPortGroupVlanRangeArgs:
         pulumi.set(self, "min_vlan", value)
 
 
+if not MYPY:
+    class DistributedVirtualSwitchHostArgsDict(TypedDict):
+        host_system_id: pulumi.Input[str]
+        """
+        The managed object ID of the host this specification applies to.
+        """
+        devices: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Name of the physical NIC to be added to the proxy switch.
+        """
+elif False:
+    DistributedVirtualSwitchHostArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DistributedVirtualSwitchHostArgs:
     def __init__(__self__, *,
                  host_system_id: pulumi.Input[str],
                  devices: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
         """
-        :param pulumi.Input[str] host_system_id: The host system ID of the host to add to the
-               VDS.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] devices: The list of NIC devices to map to uplinks on the VDS,
-               added in order they are specified.
+        :param pulumi.Input[str] host_system_id: The managed object ID of the host this specification applies to.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] devices: Name of the physical NIC to be added to the proxy switch.
         """
         pulumi.set(__self__, "host_system_id", host_system_id)
         if devices is not None:
@@ -568,8 +778,7 @@ class DistributedVirtualSwitchHostArgs:
     @pulumi.getter(name="hostSystemId")
     def host_system_id(self) -> pulumi.Input[str]:
         """
-        The host system ID of the host to add to the
-        VDS.
+        The managed object ID of the host this specification applies to.
         """
         return pulumi.get(self, "host_system_id")
 
@@ -581,8 +790,7 @@ class DistributedVirtualSwitchHostArgs:
     @pulumi.getter
     def devices(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
         """
-        The list of NIC devices to map to uplinks on the VDS,
-        added in order they are specified.
+        Name of the physical NIC to be added to the proxy switch.
         """
         return pulumi.get(self, "devices")
 
@@ -591,6 +799,23 @@ class DistributedVirtualSwitchHostArgs:
         pulumi.set(self, "devices", value)
 
 
+if not MYPY:
+    class DistributedVirtualSwitchPvlanMappingArgsDict(TypedDict):
+        primary_vlan_id: pulumi.Input[int]
+        """
+        The primary VLAN ID. The VLAN IDs of 0 and 4095 are reserved and cannot be used in this property.
+        """
+        pvlan_type: pulumi.Input[str]
+        """
+        The private VLAN type. Valid values are promiscuous, community and isolated.
+        """
+        secondary_vlan_id: pulumi.Input[int]
+        """
+        The secondary VLAN ID. The VLAN IDs of 0 and 4095 are reserved and cannot be used in this property.
+        """
+elif False:
+    DistributedVirtualSwitchPvlanMappingArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DistributedVirtualSwitchPvlanMappingArgs:
     def __init__(__self__, *,
@@ -598,12 +823,9 @@ class DistributedVirtualSwitchPvlanMappingArgs:
                  pvlan_type: pulumi.Input[str],
                  secondary_vlan_id: pulumi.Input[int]):
         """
-        :param pulumi.Input[int] primary_vlan_id: The primary VLAN ID. The VLAN IDs of 0 and
-               4095 are reserved and cannot be used in this property.
-        :param pulumi.Input[str] pvlan_type: The private VLAN type. Valid values are
-               promiscuous, community and isolated.
-        :param pulumi.Input[int] secondary_vlan_id: The secondary VLAN ID. The VLAN IDs of 0
-               and 4095 are reserved and cannot be used in this property.
+        :param pulumi.Input[int] primary_vlan_id: The primary VLAN ID. The VLAN IDs of 0 and 4095 are reserved and cannot be used in this property.
+        :param pulumi.Input[str] pvlan_type: The private VLAN type. Valid values are promiscuous, community and isolated.
+        :param pulumi.Input[int] secondary_vlan_id: The secondary VLAN ID. The VLAN IDs of 0 and 4095 are reserved and cannot be used in this property.
         """
         pulumi.set(__self__, "primary_vlan_id", primary_vlan_id)
         pulumi.set(__self__, "pvlan_type", pvlan_type)
@@ -613,8 +835,7 @@ class DistributedVirtualSwitchPvlanMappingArgs:
     @pulumi.getter(name="primaryVlanId")
     def primary_vlan_id(self) -> pulumi.Input[int]:
         """
-        The primary VLAN ID. The VLAN IDs of 0 and
-        4095 are reserved and cannot be used in this property.
+        The primary VLAN ID. The VLAN IDs of 0 and 4095 are reserved and cannot be used in this property.
         """
         return pulumi.get(self, "primary_vlan_id")
 
@@ -626,8 +847,7 @@ class DistributedVirtualSwitchPvlanMappingArgs:
     @pulumi.getter(name="pvlanType")
     def pvlan_type(self) -> pulumi.Input[str]:
         """
-        The private VLAN type. Valid values are
-        promiscuous, community and isolated.
+        The private VLAN type. Valid values are promiscuous, community and isolated.
         """
         return pulumi.get(self, "pvlan_type")
 
@@ -639,8 +859,7 @@ class DistributedVirtualSwitchPvlanMappingArgs:
     @pulumi.getter(name="secondaryVlanId")
     def secondary_vlan_id(self) -> pulumi.Input[int]:
         """
-        The secondary VLAN ID. The VLAN IDs of 0
-        and 4095 are reserved and cannot be used in this property.
+        The secondary VLAN ID. The VLAN IDs of 0 and 4095 are reserved and cannot be used in this property.
         """
         return pulumi.get(self, "secondary_vlan_id")
 
@@ -649,6 +868,19 @@ class DistributedVirtualSwitchPvlanMappingArgs:
         pulumi.set(self, "secondary_vlan_id", value)
 
 
+if not MYPY:
+    class DistributedVirtualSwitchVlanRangeArgsDict(TypedDict):
+        max_vlan: pulumi.Input[int]
+        """
+        The minimum VLAN to use in the range.
+        """
+        min_vlan: pulumi.Input[int]
+        """
+        The minimum VLAN to use in the range.
+        """
+elif False:
+    DistributedVirtualSwitchVlanRangeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class DistributedVirtualSwitchVlanRangeArgs:
     def __init__(__self__, *,
@@ -686,6 +918,30 @@ class DistributedVirtualSwitchVlanRangeArgs:
         pulumi.set(self, "min_vlan", value)
 
 
+if not MYPY:
+    class EntityPermissionsPermissionArgsDict(TypedDict):
+        is_group: pulumi.Input[bool]
+        """
+        Whether `user_or_group` field refers to a user or a
+        group. True for a group and false for a user.
+        """
+        propagate: pulumi.Input[bool]
+        """
+        Whether or not this permission propagates down the
+        hierarchy to sub-entities.
+        """
+        role_id: pulumi.Input[str]
+        """
+        The role id of the role to be given to the user on
+        the specified entity.
+        """
+        user_or_group: pulumi.Input[str]
+        """
+        The user/group getting the permission.
+        """
+elif False:
+    EntityPermissionsPermissionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class EntityPermissionsPermissionArgs:
     def __init__(__self__, *,
@@ -694,9 +950,12 @@ class EntityPermissionsPermissionArgs:
                  role_id: pulumi.Input[str],
                  user_or_group: pulumi.Input[str]):
         """
-        :param pulumi.Input[bool] is_group: Whether user_or_group field refers to a user or a group. True for a group and false for a user.
-        :param pulumi.Input[bool] propagate: Whether or not this permission propagates down the hierarchy to sub-entities.
-        :param pulumi.Input[str] role_id: The role id of the role to be given to the user on the specified entity.
+        :param pulumi.Input[bool] is_group: Whether `user_or_group` field refers to a user or a
+               group. True for a group and false for a user.
+        :param pulumi.Input[bool] propagate: Whether or not this permission propagates down the
+               hierarchy to sub-entities.
+        :param pulumi.Input[str] role_id: The role id of the role to be given to the user on
+               the specified entity.
         :param pulumi.Input[str] user_or_group: The user/group getting the permission.
         """
         pulumi.set(__self__, "is_group", is_group)
@@ -708,7 +967,8 @@ class EntityPermissionsPermissionArgs:
     @pulumi.getter(name="isGroup")
     def is_group(self) -> pulumi.Input[bool]:
         """
-        Whether user_or_group field refers to a user or a group. True for a group and false for a user.
+        Whether `user_or_group` field refers to a user or a
+        group. True for a group and false for a user.
         """
         return pulumi.get(self, "is_group")
 
@@ -720,7 +980,8 @@ class EntityPermissionsPermissionArgs:
     @pulumi.getter
     def propagate(self) -> pulumi.Input[bool]:
         """
-        Whether or not this permission propagates down the hierarchy to sub-entities.
+        Whether or not this permission propagates down the
+        hierarchy to sub-entities.
         """
         return pulumi.get(self, "propagate")
 
@@ -732,7 +993,8 @@ class EntityPermissionsPermissionArgs:
     @pulumi.getter(name="roleId")
     def role_id(self) -> pulumi.Input[str]:
         """
-        The role id of the role to be given to the user on the specified entity.
+        The role id of the role to be given to the user on
+        the specified entity.
         """
         return pulumi.get(self, "role_id")
 
@@ -753,6 +1015,43 @@ class EntityPermissionsPermissionArgs:
         pulumi.set(self, "user_or_group", value)
 
 
+if not MYPY:
+    class GuestOsCustomizationSpecArgsDict(TypedDict):
+        dns_server_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The list of DNS servers for a virtual network adapter with a static IP address.
+        """
+        dns_suffix_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        A list of DNS search domains to add to the DNS configuration on the virtual machine.
+        """
+        ipv4_gateway: NotRequired[pulumi.Input[str]]
+        """
+        The IPv4 default gateway when using network_interface customization on the virtual machine. This address must be local to a static IPv4 address configured in an interface sub-resource.
+        """
+        ipv6_gateway: NotRequired[pulumi.Input[str]]
+        """
+        The IPv6 default gateway when using network_interface customization on the virtual machine. This address must be local to a static IPv4 address configured in an interface sub-resource.
+        """
+        linux_options: NotRequired[pulumi.Input['GuestOsCustomizationSpecLinuxOptionsArgsDict']]
+        """
+        A list of configuration options specific to Linux virtual machines.
+        """
+        network_interfaces: NotRequired[pulumi.Input[Sequence[pulumi.Input['GuestOsCustomizationSpecNetworkInterfaceArgsDict']]]]
+        """
+        A specification of network interface configuration options.
+        """
+        windows_options: NotRequired[pulumi.Input['GuestOsCustomizationSpecWindowsOptionsArgsDict']]
+        """
+        A list of configuration options specific to Windows virtual machines.
+        """
+        windows_sysprep_text: NotRequired[pulumi.Input[str]]
+        """
+        Use this option to specify a windows sysprep file directly.
+        """
+elif False:
+    GuestOsCustomizationSpecArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GuestOsCustomizationSpecArgs:
     def __init__(__self__, *,
@@ -888,6 +1187,31 @@ class GuestOsCustomizationSpecArgs:
         pulumi.set(self, "windows_sysprep_text", value)
 
 
+if not MYPY:
+    class GuestOsCustomizationSpecLinuxOptionsArgsDict(TypedDict):
+        domain: pulumi.Input[str]
+        """
+        The domain name for this virtual machine.
+        """
+        host_name: pulumi.Input[str]
+        """
+        The hostname for this virtual machine.
+        """
+        hw_clock_utc: NotRequired[pulumi.Input[bool]]
+        """
+        Specifies whether or not the hardware clock should be in UTC or not.
+        """
+        script_text: NotRequired[pulumi.Input[str]]
+        """
+        The customization script to run before and or after guest customization
+        """
+        time_zone: NotRequired[pulumi.Input[str]]
+        """
+        Customize the time zone on the VM. This should be a time zone-style entry, like America/Los_Angeles.
+        """
+elif False:
+    GuestOsCustomizationSpecLinuxOptionsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GuestOsCustomizationSpecLinuxOptionsArgs:
     def __init__(__self__, *,
@@ -973,6 +1297,35 @@ class GuestOsCustomizationSpecLinuxOptionsArgs:
         pulumi.set(self, "time_zone", value)
 
 
+if not MYPY:
+    class GuestOsCustomizationSpecNetworkInterfaceArgsDict(TypedDict):
+        dns_domain: NotRequired[pulumi.Input[str]]
+        """
+        A DNS search domain to add to the DNS configuration on the virtual machine.
+        """
+        dns_server_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Network-interface specific DNS settings for Windows operating systems. Ignored on Linux.
+        """
+        ipv4_address: NotRequired[pulumi.Input[str]]
+        """
+        The IPv4 address assigned to this network adapter. If left blank, DHCP is used.
+        """
+        ipv4_netmask: NotRequired[pulumi.Input[int]]
+        """
+        The IPv4 CIDR netmask for the supplied IP address. Ignored if DHCP is selected.
+        """
+        ipv6_address: NotRequired[pulumi.Input[str]]
+        """
+        The IPv6 address assigned to this network adapter. If left blank, default auto-configuration is used.
+        """
+        ipv6_netmask: NotRequired[pulumi.Input[int]]
+        """
+        The IPv6 CIDR netmask for the supplied IP address. Ignored if auto-configuration is selected.
+        """
+elif False:
+    GuestOsCustomizationSpecNetworkInterfaceArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GuestOsCustomizationSpecNetworkInterfaceArgs:
     def __init__(__self__, *,
@@ -1076,48 +1429,113 @@ class GuestOsCustomizationSpecNetworkInterfaceArgs:
         pulumi.set(self, "ipv6_netmask", value)
 
 
-@pulumi.input_type
-class GuestOsCustomizationSpecWindowsOptionsArgs:
-    def __init__(__self__, *,
-                 computer_name: pulumi.Input[str],
-                 admin_password: Optional[pulumi.Input[str]] = None,
-                 auto_logon: Optional[pulumi.Input[bool]] = None,
-                 auto_logon_count: Optional[pulumi.Input[int]] = None,
-                 domain_admin_password: Optional[pulumi.Input[str]] = None,
-                 domain_admin_user: Optional[pulumi.Input[str]] = None,
-                 full_name: Optional[pulumi.Input[str]] = None,
-                 join_domain: Optional[pulumi.Input[str]] = None,
-                 organization_name: Optional[pulumi.Input[str]] = None,
-                 product_key: Optional[pulumi.Input[str]] = None,
-                 run_once_command_lists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-                 time_zone: Optional[pulumi.Input[int]] = None,
-                 workgroup: Optional[pulumi.Input[str]] = None):
+if not MYPY:
+    class GuestOsCustomizationSpecWindowsOptionsArgsDict(TypedDict):
+        computer_name: pulumi.Input[str]
         """
-        :param pulumi.Input[str] computer_name: The host name for this virtual machine.
-        :param pulumi.Input[str] admin_password: The new administrator password for this virtual machine.
-        :param pulumi.Input[bool] auto_logon: Specifies whether or not the VM automatically logs on as Administrator.
-        :param pulumi.Input[int] auto_logon_count: Specifies how many times the VM should auto-logon the Administrator account when auto_logon is true.
-        :param pulumi.Input[str] domain_admin_password: The password of the domain administrator used to join this virtual machine to the domain.
-        :param pulumi.Input[str] domain_admin_user: The user account of the domain administrator used to join this virtual machine to the domain.
-        :param pulumi.Input[str] full_name: The full name of the user of this virtual machine.
-        :param pulumi.Input[str] join_domain: The domain that the virtual machine should join.
-        :param pulumi.Input[str] organization_name: The organization name this virtual machine is being installed for.
-        :param pulumi.Input[str] product_key: The product key for this virtual machine.
-        :param pulumi.Input[Sequence[pulumi.Input[str]]] run_once_command_lists: A list of commands to run at first user logon, after guest customization.
-        :param pulumi.Input[int] time_zone: The new time zone for the virtual machine. This is a sysprep-dictated timezone code.
-        :param pulumi.Input[str] workgroup: The workgroup for this virtual machine if not joining a domain.
+        The host name for this virtual machine.
         """
-        pulumi.set(__self__, "computer_name", computer_name)
-        if admin_password is not None:
-            pulumi.set(__self__, "admin_password", admin_password)
-        if auto_logon is not None:
-            pulumi.set(__self__, "auto_logon", auto_logon)
+        admin_password: NotRequired[pulumi.Input[str]]
+        """
+        The new administrator password for this virtual machine.
+        """
+        auto_logon: NotRequired[pulumi.Input[bool]]
+        """
+        Specifies whether or not the VM automatically logs on as Administrator.
+        """
+        auto_logon_count: NotRequired[pulumi.Input[int]]
+        """
+        Specifies how many times the VM should auto-logon the Administrator account when auto_logon is true.
+        """
+        domain_admin_password: NotRequired[pulumi.Input[str]]
+        """
+        The password of the domain administrator used to join this virtual machine to the domain.
+        """
+        domain_admin_user: NotRequired[pulumi.Input[str]]
+        """
+        The user account of the domain administrator used to join this virtual machine to the domain.
+        """
+        domain_ou: NotRequired[pulumi.Input[str]]
+        """
+        The MachineObjectOU which specifies the full LDAP path name of the OU to which the virtual machine belongs.
+        """
+        full_name: NotRequired[pulumi.Input[str]]
+        """
+        The full name of the user of this virtual machine.
+        """
+        join_domain: NotRequired[pulumi.Input[str]]
+        """
+        The domain that the virtual machine should join.
+        """
+        organization_name: NotRequired[pulumi.Input[str]]
+        """
+        The organization name this virtual machine is being installed for.
+        """
+        product_key: NotRequired[pulumi.Input[str]]
+        """
+        The product key for this virtual machine.
+        """
+        run_once_command_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        A list of commands to run at first user logon, after guest customization.
+        """
+        time_zone: NotRequired[pulumi.Input[int]]
+        """
+        The new time zone for the virtual machine. This is a sysprep-dictated timezone code.
+        """
+        workgroup: NotRequired[pulumi.Input[str]]
+        """
+        The workgroup for this virtual machine if not joining a domain.
+        """
+elif False:
+    GuestOsCustomizationSpecWindowsOptionsArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GuestOsCustomizationSpecWindowsOptionsArgs:
+    def __init__(__self__, *,
+                 computer_name: pulumi.Input[str],
+                 admin_password: Optional[pulumi.Input[str]] = None,
+                 auto_logon: Optional[pulumi.Input[bool]] = None,
+                 auto_logon_count: Optional[pulumi.Input[int]] = None,
+                 domain_admin_password: Optional[pulumi.Input[str]] = None,
+                 domain_admin_user: Optional[pulumi.Input[str]] = None,
+                 domain_ou: Optional[pulumi.Input[str]] = None,
+                 full_name: Optional[pulumi.Input[str]] = None,
+                 join_domain: Optional[pulumi.Input[str]] = None,
+                 organization_name: Optional[pulumi.Input[str]] = None,
+                 product_key: Optional[pulumi.Input[str]] = None,
+                 run_once_command_lists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 time_zone: Optional[pulumi.Input[int]] = None,
+                 workgroup: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] computer_name: The host name for this virtual machine.
+        :param pulumi.Input[str] admin_password: The new administrator password for this virtual machine.
+        :param pulumi.Input[bool] auto_logon: Specifies whether or not the VM automatically logs on as Administrator.
+        :param pulumi.Input[int] auto_logon_count: Specifies how many times the VM should auto-logon the Administrator account when auto_logon is true.
+        :param pulumi.Input[str] domain_admin_password: The password of the domain administrator used to join this virtual machine to the domain.
+        :param pulumi.Input[str] domain_admin_user: The user account of the domain administrator used to join this virtual machine to the domain.
+        :param pulumi.Input[str] domain_ou: The MachineObjectOU which specifies the full LDAP path name of the OU to which the virtual machine belongs.
+        :param pulumi.Input[str] full_name: The full name of the user of this virtual machine.
+        :param pulumi.Input[str] join_domain: The domain that the virtual machine should join.
+        :param pulumi.Input[str] organization_name: The organization name this virtual machine is being installed for.
+        :param pulumi.Input[str] product_key: The product key for this virtual machine.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] run_once_command_lists: A list of commands to run at first user logon, after guest customization.
+        :param pulumi.Input[int] time_zone: The new time zone for the virtual machine. This is a sysprep-dictated timezone code.
+        :param pulumi.Input[str] workgroup: The workgroup for this virtual machine if not joining a domain.
+        """
+        pulumi.set(__self__, "computer_name", computer_name)
+        if admin_password is not None:
+            pulumi.set(__self__, "admin_password", admin_password)
+        if auto_logon is not None:
+            pulumi.set(__self__, "auto_logon", auto_logon)
         if auto_logon_count is not None:
             pulumi.set(__self__, "auto_logon_count", auto_logon_count)
         if domain_admin_password is not None:
             pulumi.set(__self__, "domain_admin_password", domain_admin_password)
         if domain_admin_user is not None:
             pulumi.set(__self__, "domain_admin_user", domain_admin_user)
+        if domain_ou is not None:
+            pulumi.set(__self__, "domain_ou", domain_ou)
         if full_name is not None:
             pulumi.set(__self__, "full_name", full_name)
         if join_domain is not None:
@@ -1205,6 +1623,18 @@ class GuestOsCustomizationSpecWindowsOptionsArgs:
     def domain_admin_user(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "domain_admin_user", value)
 
+    @property
+    @pulumi.getter(name="domainOu")
+    def domain_ou(self) -> Optional[pulumi.Input[str]]:
+        """
+        The MachineObjectOU which specifies the full LDAP path name of the OU to which the virtual machine belongs.
+        """
+        return pulumi.get(self, "domain_ou")
+
+    @domain_ou.setter
+    def domain_ou(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "domain_ou", value)
+
     @property
     @pulumi.getter(name="fullName")
     def full_name(self) -> Optional[pulumi.Input[str]]:
@@ -1290,6 +1720,23 @@ class GuestOsCustomizationSpecWindowsOptionsArgs:
         pulumi.set(self, "workgroup", value)
 
 
+if not MYPY:
+    class HostPortGroupPortArgsDict(TypedDict):
+        key: NotRequired[pulumi.Input[str]]
+        """
+        The key for this port group as returned from the vSphere API.
+        """
+        mac_addresses: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The MAC addresses of the network service of the virtual machine connected on this port.
+        """
+        type: NotRequired[pulumi.Input[str]]
+        """
+        Type type of the entity connected on this port. Possible values are host (VMKkernel), systemManagement (service console), virtualMachine, or unknown.
+        """
+elif False:
+    HostPortGroupPortArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class HostPortGroupPortArgs:
     def __init__(__self__, *,
@@ -1345,6 +1792,584 @@ class HostPortGroupPortArgs:
         pulumi.set(self, "type", value)
 
 
+if not MYPY:
+    class HostServiceArgsDict(TypedDict):
+        ntpd: NotRequired[pulumi.Input['HostServiceNtpdArgsDict']]
+        """
+        service has three settings, `enabled` sets service to running or not running, `policy` sets service based on setting of `on` which sets service to "Start and stop with host", `off` which sets service to "Start and stop manually", `automatic` which sets service to "Start and stop with port usage".
+
+        > **NOTE:** `services` only supports ntpd service today.
+        """
+elif False:
+    HostServiceArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class HostServiceArgs:
+    def __init__(__self__, *,
+                 ntpd: Optional[pulumi.Input['HostServiceNtpdArgs']] = None):
+        """
+        :param pulumi.Input['HostServiceNtpdArgs'] ntpd: service has three settings, `enabled` sets service to running or not running, `policy` sets service based on setting of `on` which sets service to "Start and stop with host", `off` which sets service to "Start and stop manually", `automatic` which sets service to "Start and stop with port usage".
+               
+               > **NOTE:** `services` only supports ntpd service today.
+        """
+        if ntpd is not None:
+            pulumi.set(__self__, "ntpd", ntpd)
+
+    @property
+    @pulumi.getter
+    def ntpd(self) -> Optional[pulumi.Input['HostServiceNtpdArgs']]:
+        """
+        service has three settings, `enabled` sets service to running or not running, `policy` sets service based on setting of `on` which sets service to "Start and stop with host", `off` which sets service to "Start and stop manually", `automatic` which sets service to "Start and stop with port usage".
+
+        > **NOTE:** `services` only supports ntpd service today.
+        """
+        return pulumi.get(self, "ntpd")
+
+    @ntpd.setter
+    def ntpd(self, value: Optional[pulumi.Input['HostServiceNtpdArgs']]):
+        pulumi.set(self, "ntpd", value)
+
+
+if not MYPY:
+    class HostServiceNtpdArgsDict(TypedDict):
+        enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Whether the NTP service is enabled. Default is false.
+        """
+        ntp_servers: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        policy: NotRequired[pulumi.Input[str]]
+        """
+        The policy for the NTP service. Valid values are 'Start and stop with host', 'Start and stop manually', 'Start and stop with port usage'.
+        """
+elif False:
+    HostServiceNtpdArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class HostServiceNtpdArgs:
+    def __init__(__self__, *,
+                 enabled: Optional[pulumi.Input[bool]] = None,
+                 ntp_servers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 policy: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[bool] enabled: Whether the NTP service is enabled. Default is false.
+        :param pulumi.Input[str] policy: The policy for the NTP service. Valid values are 'Start and stop with host', 'Start and stop manually', 'Start and stop with port usage'.
+        """
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+        if ntp_servers is not None:
+            pulumi.set(__self__, "ntp_servers", ntp_servers)
+        if policy is not None:
+            pulumi.set(__self__, "policy", policy)
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether the NTP service is enabled. Default is false.
+        """
+        return pulumi.get(self, "enabled")
+
+    @enabled.setter
+    def enabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "enabled", value)
+
+    @property
+    @pulumi.getter(name="ntpServers")
+    def ntp_servers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        return pulumi.get(self, "ntp_servers")
+
+    @ntp_servers.setter
+    def ntp_servers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "ntp_servers", value)
+
+    @property
+    @pulumi.getter
+    def policy(self) -> Optional[pulumi.Input[str]]:
+        """
+        The policy for the NTP service. Valid values are 'Start and stop with host', 'Start and stop manually', 'Start and stop with port usage'.
+        """
+        return pulumi.get(self, "policy")
+
+    @policy.setter
+    def policy(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "policy", value)
+
+
+if not MYPY:
+    class OfflineSoftwareDepotComponentArgsDict(TypedDict):
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        The name of the component. Useful for easier identification.
+        """
+        key: NotRequired[pulumi.Input[str]]
+        """
+        The identifier of the component.
+        """
+        versions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The list of available versions of the component.
+        """
+elif False:
+    OfflineSoftwareDepotComponentArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class OfflineSoftwareDepotComponentArgs:
+    def __init__(__self__, *,
+                 display_name: Optional[pulumi.Input[str]] = None,
+                 key: Optional[pulumi.Input[str]] = None,
+                 versions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[str] display_name: The name of the component. Useful for easier identification.
+        :param pulumi.Input[str] key: The identifier of the component.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] versions: The list of available versions of the component.
+        """
+        if display_name is not None:
+            pulumi.set(__self__, "display_name", display_name)
+        if key is not None:
+            pulumi.set(__self__, "key", key)
+        if versions is not None:
+            pulumi.set(__self__, "versions", versions)
+
+    @property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        The name of the component. Useful for easier identification.
+        """
+        return pulumi.get(self, "display_name")
+
+    @display_name.setter
+    def display_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "display_name", value)
+
+    @property
+    @pulumi.getter
+    def key(self) -> Optional[pulumi.Input[str]]:
+        """
+        The identifier of the component.
+        """
+        return pulumi.get(self, "key")
+
+    @key.setter
+    def key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "key", value)
+
+    @property
+    @pulumi.getter
+    def versions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        The list of available versions of the component.
+        """
+        return pulumi.get(self, "versions")
+
+    @versions.setter
+    def versions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "versions", value)
+
+
+if not MYPY:
+    class SupervisorEgressCidrArgsDict(TypedDict):
+        address: pulumi.Input[str]
+        """
+        Network address.
+        """
+        prefix: pulumi.Input[int]
+        """
+        Subnet prefix.
+        """
+elif False:
+    SupervisorEgressCidrArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SupervisorEgressCidrArgs:
+    def __init__(__self__, *,
+                 address: pulumi.Input[str],
+                 prefix: pulumi.Input[int]):
+        """
+        :param pulumi.Input[str] address: Network address.
+        :param pulumi.Input[int] prefix: Subnet prefix.
+        """
+        pulumi.set(__self__, "address", address)
+        pulumi.set(__self__, "prefix", prefix)
+
+    @property
+    @pulumi.getter
+    def address(self) -> pulumi.Input[str]:
+        """
+        Network address.
+        """
+        return pulumi.get(self, "address")
+
+    @address.setter
+    def address(self, value: pulumi.Input[str]):
+        pulumi.set(self, "address", value)
+
+    @property
+    @pulumi.getter
+    def prefix(self) -> pulumi.Input[int]:
+        """
+        Subnet prefix.
+        """
+        return pulumi.get(self, "prefix")
+
+    @prefix.setter
+    def prefix(self, value: pulumi.Input[int]):
+        pulumi.set(self, "prefix", value)
+
+
+if not MYPY:
+    class SupervisorIngressCidrArgsDict(TypedDict):
+        address: pulumi.Input[str]
+        """
+        Network address.
+        """
+        prefix: pulumi.Input[int]
+        """
+        Subnet prefix.
+        """
+elif False:
+    SupervisorIngressCidrArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SupervisorIngressCidrArgs:
+    def __init__(__self__, *,
+                 address: pulumi.Input[str],
+                 prefix: pulumi.Input[int]):
+        """
+        :param pulumi.Input[str] address: Network address.
+        :param pulumi.Input[int] prefix: Subnet prefix.
+        """
+        pulumi.set(__self__, "address", address)
+        pulumi.set(__self__, "prefix", prefix)
+
+    @property
+    @pulumi.getter
+    def address(self) -> pulumi.Input[str]:
+        """
+        Network address.
+        """
+        return pulumi.get(self, "address")
+
+    @address.setter
+    def address(self, value: pulumi.Input[str]):
+        pulumi.set(self, "address", value)
+
+    @property
+    @pulumi.getter
+    def prefix(self) -> pulumi.Input[int]:
+        """
+        Subnet prefix.
+        """
+        return pulumi.get(self, "prefix")
+
+    @prefix.setter
+    def prefix(self, value: pulumi.Input[int]):
+        pulumi.set(self, "prefix", value)
+
+
+if not MYPY:
+    class SupervisorManagementNetworkArgsDict(TypedDict):
+        address_count: pulumi.Input[int]
+        """
+        Number of addresses to allocate. Starts from 'starting_address'
+        """
+        gateway: pulumi.Input[str]
+        """
+        Gateway IP address.
+        """
+        network: pulumi.Input[str]
+        """
+        ID of the network. (e.g. a distributed port group).
+        """
+        starting_address: pulumi.Input[str]
+        """
+        Starting address of the management network range.
+        """
+        subnet_mask: pulumi.Input[str]
+        """
+        Subnet mask.
+        """
+elif False:
+    SupervisorManagementNetworkArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SupervisorManagementNetworkArgs:
+    def __init__(__self__, *,
+                 address_count: pulumi.Input[int],
+                 gateway: pulumi.Input[str],
+                 network: pulumi.Input[str],
+                 starting_address: pulumi.Input[str],
+                 subnet_mask: pulumi.Input[str]):
+        """
+        :param pulumi.Input[int] address_count: Number of addresses to allocate. Starts from 'starting_address'
+        :param pulumi.Input[str] gateway: Gateway IP address.
+        :param pulumi.Input[str] network: ID of the network. (e.g. a distributed port group).
+        :param pulumi.Input[str] starting_address: Starting address of the management network range.
+        :param pulumi.Input[str] subnet_mask: Subnet mask.
+        """
+        pulumi.set(__self__, "address_count", address_count)
+        pulumi.set(__self__, "gateway", gateway)
+        pulumi.set(__self__, "network", network)
+        pulumi.set(__self__, "starting_address", starting_address)
+        pulumi.set(__self__, "subnet_mask", subnet_mask)
+
+    @property
+    @pulumi.getter(name="addressCount")
+    def address_count(self) -> pulumi.Input[int]:
+        """
+        Number of addresses to allocate. Starts from 'starting_address'
+        """
+        return pulumi.get(self, "address_count")
+
+    @address_count.setter
+    def address_count(self, value: pulumi.Input[int]):
+        pulumi.set(self, "address_count", value)
+
+    @property
+    @pulumi.getter
+    def gateway(self) -> pulumi.Input[str]:
+        """
+        Gateway IP address.
+        """
+        return pulumi.get(self, "gateway")
+
+    @gateway.setter
+    def gateway(self, value: pulumi.Input[str]):
+        pulumi.set(self, "gateway", value)
+
+    @property
+    @pulumi.getter
+    def network(self) -> pulumi.Input[str]:
+        """
+        ID of the network. (e.g. a distributed port group).
+        """
+        return pulumi.get(self, "network")
+
+    @network.setter
+    def network(self, value: pulumi.Input[str]):
+        pulumi.set(self, "network", value)
+
+    @property
+    @pulumi.getter(name="startingAddress")
+    def starting_address(self) -> pulumi.Input[str]:
+        """
+        Starting address of the management network range.
+        """
+        return pulumi.get(self, "starting_address")
+
+    @starting_address.setter
+    def starting_address(self, value: pulumi.Input[str]):
+        pulumi.set(self, "starting_address", value)
+
+    @property
+    @pulumi.getter(name="subnetMask")
+    def subnet_mask(self) -> pulumi.Input[str]:
+        """
+        Subnet mask.
+        """
+        return pulumi.get(self, "subnet_mask")
+
+    @subnet_mask.setter
+    def subnet_mask(self, value: pulumi.Input[str]):
+        pulumi.set(self, "subnet_mask", value)
+
+
+if not MYPY:
+    class SupervisorNamespaceArgsDict(TypedDict):
+        name: pulumi.Input[str]
+        """
+        The name of the namespace.
+        """
+        content_libraries: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        A list of content libraries.
+        """
+        vm_classes: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        A list of virtual machine classes.
+        """
+elif False:
+    SupervisorNamespaceArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SupervisorNamespaceArgs:
+    def __init__(__self__, *,
+                 name: pulumi.Input[str],
+                 content_libraries: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 vm_classes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
+        """
+        :param pulumi.Input[str] name: The name of the namespace.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] content_libraries: A list of content libraries.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] vm_classes: A list of virtual machine classes.
+        """
+        pulumi.set(__self__, "name", name)
+        if content_libraries is not None:
+            pulumi.set(__self__, "content_libraries", content_libraries)
+        if vm_classes is not None:
+            pulumi.set(__self__, "vm_classes", vm_classes)
+
+    @property
+    @pulumi.getter
+    def name(self) -> pulumi.Input[str]:
+        """
+        The name of the namespace.
+        """
+        return pulumi.get(self, "name")
+
+    @name.setter
+    def name(self, value: pulumi.Input[str]):
+        pulumi.set(self, "name", value)
+
+    @property
+    @pulumi.getter(name="contentLibraries")
+    def content_libraries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        A list of content libraries.
+        """
+        return pulumi.get(self, "content_libraries")
+
+    @content_libraries.setter
+    def content_libraries(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "content_libraries", value)
+
+    @property
+    @pulumi.getter(name="vmClasses")
+    def vm_classes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        A list of virtual machine classes.
+        """
+        return pulumi.get(self, "vm_classes")
+
+    @vm_classes.setter
+    def vm_classes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "vm_classes", value)
+
+
+if not MYPY:
+    class SupervisorPodCidrArgsDict(TypedDict):
+        address: pulumi.Input[str]
+        """
+        Network address.
+        """
+        prefix: pulumi.Input[int]
+        """
+        Subnet prefix.
+        """
+elif False:
+    SupervisorPodCidrArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SupervisorPodCidrArgs:
+    def __init__(__self__, *,
+                 address: pulumi.Input[str],
+                 prefix: pulumi.Input[int]):
+        """
+        :param pulumi.Input[str] address: Network address.
+        :param pulumi.Input[int] prefix: Subnet prefix.
+        """
+        pulumi.set(__self__, "address", address)
+        pulumi.set(__self__, "prefix", prefix)
+
+    @property
+    @pulumi.getter
+    def address(self) -> pulumi.Input[str]:
+        """
+        Network address.
+        """
+        return pulumi.get(self, "address")
+
+    @address.setter
+    def address(self, value: pulumi.Input[str]):
+        pulumi.set(self, "address", value)
+
+    @property
+    @pulumi.getter
+    def prefix(self) -> pulumi.Input[int]:
+        """
+        Subnet prefix.
+        """
+        return pulumi.get(self, "prefix")
+
+    @prefix.setter
+    def prefix(self, value: pulumi.Input[int]):
+        pulumi.set(self, "prefix", value)
+
+
+if not MYPY:
+    class SupervisorServiceCidrArgsDict(TypedDict):
+        address: pulumi.Input[str]
+        """
+        Network address.
+        """
+        prefix: pulumi.Input[int]
+        """
+        Subnet prefix.
+        """
+elif False:
+    SupervisorServiceCidrArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SupervisorServiceCidrArgs:
+    def __init__(__self__, *,
+                 address: pulumi.Input[str],
+                 prefix: pulumi.Input[int]):
+        """
+        :param pulumi.Input[str] address: Network address.
+        :param pulumi.Input[int] prefix: Subnet prefix.
+        """
+        pulumi.set(__self__, "address", address)
+        pulumi.set(__self__, "prefix", prefix)
+
+    @property
+    @pulumi.getter
+    def address(self) -> pulumi.Input[str]:
+        """
+        Network address.
+        """
+        return pulumi.get(self, "address")
+
+    @address.setter
+    def address(self, value: pulumi.Input[str]):
+        pulumi.set(self, "address", value)
+
+    @property
+    @pulumi.getter
+    def prefix(self) -> pulumi.Input[int]:
+        """
+        Subnet prefix.
+        """
+        return pulumi.get(self, "prefix")
+
+    @prefix.setter
+    def prefix(self, value: pulumi.Input[int]):
+        pulumi.set(self, "prefix", value)
+
+
+if not MYPY:
+    class VirtualMachineCdromArgsDict(TypedDict):
+        client_device: NotRequired[pulumi.Input[bool]]
+        """
+        Indicates whether the device should be mapped to a remote client device
+        """
+        datastore_id: NotRequired[pulumi.Input[str]]
+        """
+        The datastore ID the ISO is located on.
+        """
+        device_address: NotRequired[pulumi.Input[str]]
+        """
+        The internally-computed address of this device, such as scsi:0:1, denoting scsi bus #0 and device unit 1.
+        """
+        key: NotRequired[pulumi.Input[int]]
+        """
+        The ID of the device within the virtual machine.
+        """
+        path: NotRequired[pulumi.Input[str]]
+        """
+        The path to the ISO file on the datastore.
+        """
+elif False:
+    VirtualMachineCdromArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class VirtualMachineCdromArgs:
     def __init__(__self__, *,
@@ -1354,15 +2379,11 @@ class VirtualMachineCdromArgs:
                  key: Optional[pulumi.Input[int]] = None,
                  path: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[bool] client_device: Indicates whether the device should be backed by remote client device. Conflicts with `datastore_id` and `path`.
-        :param pulumi.Input[str] datastore_id: The datastore ID that on which the ISO is located. Required for using a datastore ISO. Conflicts with `client_device`.
+        :param pulumi.Input[bool] client_device: Indicates whether the device should be mapped to a remote client device
+        :param pulumi.Input[str] datastore_id: The datastore ID the ISO is located on.
         :param pulumi.Input[str] device_address: The internally-computed address of this device, such as scsi:0:1, denoting scsi bus #0 and device unit 1.
         :param pulumi.Input[int] key: The ID of the device within the virtual machine.
-        :param pulumi.Input[str] path: The path to the ISO file. Required for using a datastore ISO. Conflicts with `client_device`.
-               
-               > **NOTE:** Either `client_device` (for a remote backed CD-ROM) or `datastore_id` and `path` (for a datastore ISO backed CD-ROM) are required to .
-               
-               > **NOTE:** Some CD-ROM drive types are not supported by this resource, such as pass-through devices. If these drives are present in a cloned template, or added outside of the provider, the desired state will be corrected to the defined device, or removed if no `cdrom` block is present.
+        :param pulumi.Input[str] path: The path to the ISO file on the datastore.
         """
         if client_device is not None:
             pulumi.set(__self__, "client_device", client_device)
@@ -1379,7 +2400,7 @@ class VirtualMachineCdromArgs:
     @pulumi.getter(name="clientDevice")
     def client_device(self) -> Optional[pulumi.Input[bool]]:
         """
-        Indicates whether the device should be backed by remote client device. Conflicts with `datastore_id` and `path`.
+        Indicates whether the device should be mapped to a remote client device
         """
         return pulumi.get(self, "client_device")
 
@@ -1391,7 +2412,7 @@ class VirtualMachineCdromArgs:
     @pulumi.getter(name="datastoreId")
     def datastore_id(self) -> Optional[pulumi.Input[str]]:
         """
-        The datastore ID that on which the ISO is located. Required for using a datastore ISO. Conflicts with `client_device`.
+        The datastore ID the ISO is located on.
         """
         return pulumi.get(self, "datastore_id")
 
@@ -1427,11 +2448,7 @@ class VirtualMachineCdromArgs:
     @pulumi.getter
     def path(self) -> Optional[pulumi.Input[str]]:
         """
-        The path to the ISO file. Required for using a datastore ISO. Conflicts with `client_device`.
-
-        > **NOTE:** Either `client_device` (for a remote backed CD-ROM) or `datastore_id` and `path` (for a datastore ISO backed CD-ROM) are required to .
-
-        > **NOTE:** Some CD-ROM drive types are not supported by this resource, such as pass-through devices. If these drives are present in a cloned template, or added outside of the provider, the desired state will be corrected to the defined device, or removed if no `cdrom` block is present.
+        The path to the ISO file on the datastore.
         """
         return pulumi.get(self, "path")
 
@@ -1440,6 +2457,39 @@ class VirtualMachineCdromArgs:
         pulumi.set(self, "path", value)
 
 
+if not MYPY:
+    class VirtualMachineCloneArgsDict(TypedDict):
+        template_uuid: pulumi.Input[str]
+        """
+        The UUID of the source virtual machine or template.
+        """
+        customization_spec: NotRequired[pulumi.Input['VirtualMachineCloneCustomizationSpecArgsDict']]
+        """
+        The customization specification for the virtual machine post-clone.
+        """
+        customize: NotRequired[pulumi.Input['VirtualMachineCloneCustomizeArgsDict']]
+        """
+        The customization specification for the virtual machine post-clone.
+        """
+        linked_clone: NotRequired[pulumi.Input[bool]]
+        """
+        Whether or not to create a linked clone when cloning. When this option is used, the source VM must have a single snapshot associated with it.
+        """
+        ovf_network_map: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Mapping of ovf networks to the networks to use in vSphere.
+        """
+        ovf_storage_map: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Mapping of ovf storage to the datastores to use in vSphere.
+        """
+        timeout: NotRequired[pulumi.Input[int]]
+        """
+        The timeout, in minutes, to wait for the virtual machine clone to complete.
+        """
+elif False:
+    VirtualMachineCloneArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class VirtualMachineCloneArgs:
     def __init__(__self__, *,
@@ -1558,6 +2608,19 @@ class VirtualMachineCloneArgs:
         pulumi.set(self, "timeout", value)
 
 
+if not MYPY:
+    class VirtualMachineCloneCustomizationSpecArgsDict(TypedDict):
+        id: pulumi.Input[str]
+        """
+        The UUID of the virtual machine.
+        """
+        timeout: NotRequired[pulumi.Input[int]]
+        """
+        The amount of time, in minutes, to wait for guest OS customization to complete before returning with an error. Setting this value to 0 or a negative value skips the waiter. Default: 10.
+        """
+elif False:
+    VirtualMachineCloneCustomizationSpecArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class VirtualMachineCloneCustomizationSpecArgs:
     def __init__(__self__, *,
@@ -1596,6 +2659,47 @@ class VirtualMachineCloneCustomizationSpecArgs:
         pulumi.set(self, "timeout", value)
 
 
+if not MYPY:
+    class VirtualMachineCloneCustomizeArgsDict(TypedDict):
+        dns_server_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The list of DNS servers for a virtual network adapter with a static IP address.
+        """
+        dns_suffix_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        A list of DNS search domains to add to the DNS configuration on the virtual machine.
+        """
+        ipv4_gateway: NotRequired[pulumi.Input[str]]
+        """
+        The IPv4 default gateway when using network_interface customization on the virtual machine. This address must be local to a static IPv4 address configured in an interface sub-resource.
+        """
+        ipv6_gateway: NotRequired[pulumi.Input[str]]
+        """
+        The IPv6 default gateway when using network_interface customization on the virtual machine. This address must be local to a static IPv4 address configured in an interface sub-resource.
+        """
+        linux_options: NotRequired[pulumi.Input['VirtualMachineCloneCustomizeLinuxOptionsArgsDict']]
+        """
+        A list of configuration options specific to Linux virtual machines.
+        """
+        network_interfaces: NotRequired[pulumi.Input[Sequence[pulumi.Input['VirtualMachineCloneCustomizeNetworkInterfaceArgsDict']]]]
+        """
+        A specification of network interface configuration options.
+        """
+        timeout: NotRequired[pulumi.Input[int]]
+        """
+        The amount of time, in minutes, to wait for guest OS customization to complete before returning with an error. Setting this value to 0 or a negative value skips the waiter. Default: 10.
+        """
+        windows_options: NotRequired[pulumi.Input['VirtualMachineCloneCustomizeWindowsOptionsArgsDict']]
+        """
+        A list of configuration options specific to Windows virtual machines.
+        """
+        windows_sysprep_text: NotRequired[pulumi.Input[str]]
+        """
+        Use this option to specify a windows sysprep file directly.
+        """
+elif False:
+    VirtualMachineCloneCustomizeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class VirtualMachineCloneCustomizeArgs:
     def __init__(__self__, *,
@@ -1614,7 +2718,7 @@ class VirtualMachineCloneCustomizeArgs:
         :param pulumi.Input[str] ipv4_gateway: The IPv4 default gateway when using network_interface customization on the virtual machine. This address must be local to a static IPv4 address configured in an interface sub-resource.
         :param pulumi.Input[str] ipv6_gateway: The IPv6 default gateway when using network_interface customization on the virtual machine. This address must be local to a static IPv4 address configured in an interface sub-resource.
         :param pulumi.Input['VirtualMachineCloneCustomizeLinuxOptionsArgs'] linux_options: A list of configuration options specific to Linux virtual machines.
-        :param pulumi.Input[Sequence[pulumi.Input['VirtualMachineCloneCustomizeNetworkInterfaceArgs']]] network_interfaces: A specification for a virtual NIC on the virtual machine. See network interface options for more information.
+        :param pulumi.Input[Sequence[pulumi.Input['VirtualMachineCloneCustomizeNetworkInterfaceArgs']]] network_interfaces: A specification of network interface configuration options.
         :param pulumi.Input[int] timeout: The amount of time, in minutes, to wait for guest OS customization to complete before returning with an error. Setting this value to 0 or a negative value skips the waiter. Default: 10.
         :param pulumi.Input['VirtualMachineCloneCustomizeWindowsOptionsArgs'] windows_options: A list of configuration options specific to Windows virtual machines.
         :param pulumi.Input[str] windows_sysprep_text: Use this option to specify a windows sysprep file directly.
@@ -1702,7 +2806,7 @@ class VirtualMachineCloneCustomizeArgs:
     @pulumi.getter(name="networkInterfaces")
     def network_interfaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VirtualMachineCloneCustomizeNetworkInterfaceArgs']]]]:
         """
-        A specification for a virtual NIC on the virtual machine. See network interface options for more information.
+        A specification of network interface configuration options.
         """
         return pulumi.get(self, "network_interfaces")
 
@@ -1738,14 +2842,39 @@ class VirtualMachineCloneCustomizeArgs:
     @pulumi.getter(name="windowsSysprepText")
     def windows_sysprep_text(self) -> Optional[pulumi.Input[str]]:
         """
-        Use this option to specify a windows sysprep file directly.
+        Use this option to specify a windows sysprep file directly.
+        """
+        return pulumi.get(self, "windows_sysprep_text")
+
+    @windows_sysprep_text.setter
+    def windows_sysprep_text(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "windows_sysprep_text", value)
+
+
+if not MYPY:
+    class VirtualMachineCloneCustomizeLinuxOptionsArgsDict(TypedDict):
+        domain: pulumi.Input[str]
+        """
+        The domain name for this virtual machine.
+        """
+        host_name: pulumi.Input[str]
+        """
+        The hostname for this virtual machine.
+        """
+        hw_clock_utc: NotRequired[pulumi.Input[bool]]
+        """
+        Specifies whether or not the hardware clock should be in UTC or not.
+        """
+        script_text: NotRequired[pulumi.Input[str]]
+        """
+        The customization script to run before and or after guest customization
+        """
+        time_zone: NotRequired[pulumi.Input[str]]
+        """
+        Customize the time zone on the VM. This should be a time zone-style entry, like America/Los_Angeles.
         """
-        return pulumi.get(self, "windows_sysprep_text")
-
-    @windows_sysprep_text.setter
-    def windows_sysprep_text(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "windows_sysprep_text", value)
-
+elif False:
+    VirtualMachineCloneCustomizeLinuxOptionsArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class VirtualMachineCloneCustomizeLinuxOptionsArgs:
@@ -1832,6 +2961,35 @@ class VirtualMachineCloneCustomizeLinuxOptionsArgs:
         pulumi.set(self, "time_zone", value)
 
 
+if not MYPY:
+    class VirtualMachineCloneCustomizeNetworkInterfaceArgsDict(TypedDict):
+        dns_domain: NotRequired[pulumi.Input[str]]
+        """
+        A DNS search domain to add to the DNS configuration on the virtual machine.
+        """
+        dns_server_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Network-interface specific DNS settings for Windows operating systems. Ignored on Linux.
+        """
+        ipv4_address: NotRequired[pulumi.Input[str]]
+        """
+        The IPv4 address assigned to this network adapter. If left blank, DHCP is used.
+        """
+        ipv4_netmask: NotRequired[pulumi.Input[int]]
+        """
+        The IPv4 CIDR netmask for the supplied IP address. Ignored if DHCP is selected.
+        """
+        ipv6_address: NotRequired[pulumi.Input[str]]
+        """
+        The IPv6 address assigned to this network adapter. If left blank, default auto-configuration is used.
+        """
+        ipv6_netmask: NotRequired[pulumi.Input[int]]
+        """
+        The IPv6 CIDR netmask for the supplied IP address. Ignored if auto-configuration is selected.
+        """
+elif False:
+    VirtualMachineCloneCustomizeNetworkInterfaceArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class VirtualMachineCloneCustomizeNetworkInterfaceArgs:
     def __init__(__self__, *,
@@ -1935,6 +3093,67 @@ class VirtualMachineCloneCustomizeNetworkInterfaceArgs:
         pulumi.set(self, "ipv6_netmask", value)
 
 
+if not MYPY:
+    class VirtualMachineCloneCustomizeWindowsOptionsArgsDict(TypedDict):
+        computer_name: pulumi.Input[str]
+        """
+        The host name for this virtual machine.
+        """
+        admin_password: NotRequired[pulumi.Input[str]]
+        """
+        The new administrator password for this virtual machine.
+        """
+        auto_logon: NotRequired[pulumi.Input[bool]]
+        """
+        Specifies whether or not the VM automatically logs on as Administrator.
+        """
+        auto_logon_count: NotRequired[pulumi.Input[int]]
+        """
+        Specifies how many times the VM should auto-logon the Administrator account when auto_logon is true.
+        """
+        domain_admin_password: NotRequired[pulumi.Input[str]]
+        """
+        The password of the domain administrator used to join this virtual machine to the domain.
+        """
+        domain_admin_user: NotRequired[pulumi.Input[str]]
+        """
+        The user account of the domain administrator used to join this virtual machine to the domain.
+        """
+        domain_ou: NotRequired[pulumi.Input[str]]
+        """
+        The MachineObjectOU which specifies the full LDAP path name of the OU to which the virtual machine belongs.
+        """
+        full_name: NotRequired[pulumi.Input[str]]
+        """
+        The full name of the user of this virtual machine.
+        """
+        join_domain: NotRequired[pulumi.Input[str]]
+        """
+        The domain that the virtual machine should join.
+        """
+        organization_name: NotRequired[pulumi.Input[str]]
+        """
+        The organization name this virtual machine is being installed for.
+        """
+        product_key: NotRequired[pulumi.Input[str]]
+        """
+        The product key for this virtual machine.
+        """
+        run_once_command_lists: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        A list of commands to run at first user logon, after guest customization.
+        """
+        time_zone: NotRequired[pulumi.Input[int]]
+        """
+        The new time zone for the virtual machine. This is a sysprep-dictated timezone code.
+        """
+        workgroup: NotRequired[pulumi.Input[str]]
+        """
+        The workgroup for this virtual machine if not joining a domain.
+        """
+elif False:
+    VirtualMachineCloneCustomizeWindowsOptionsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class VirtualMachineCloneCustomizeWindowsOptionsArgs:
     def __init__(__self__, *,
@@ -1944,6 +3163,7 @@ class VirtualMachineCloneCustomizeWindowsOptionsArgs:
                  auto_logon_count: Optional[pulumi.Input[int]] = None,
                  domain_admin_password: Optional[pulumi.Input[str]] = None,
                  domain_admin_user: Optional[pulumi.Input[str]] = None,
+                 domain_ou: Optional[pulumi.Input[str]] = None,
                  full_name: Optional[pulumi.Input[str]] = None,
                  join_domain: Optional[pulumi.Input[str]] = None,
                  organization_name: Optional[pulumi.Input[str]] = None,
@@ -1958,6 +3178,7 @@ class VirtualMachineCloneCustomizeWindowsOptionsArgs:
         :param pulumi.Input[int] auto_logon_count: Specifies how many times the VM should auto-logon the Administrator account when auto_logon is true.
         :param pulumi.Input[str] domain_admin_password: The password of the domain administrator used to join this virtual machine to the domain.
         :param pulumi.Input[str] domain_admin_user: The user account of the domain administrator used to join this virtual machine to the domain.
+        :param pulumi.Input[str] domain_ou: The MachineObjectOU which specifies the full LDAP path name of the OU to which the virtual machine belongs.
         :param pulumi.Input[str] full_name: The full name of the user of this virtual machine.
         :param pulumi.Input[str] join_domain: The domain that the virtual machine should join.
         :param pulumi.Input[str] organization_name: The organization name this virtual machine is being installed for.
@@ -1977,6 +3198,8 @@ class VirtualMachineCloneCustomizeWindowsOptionsArgs:
             pulumi.set(__self__, "domain_admin_password", domain_admin_password)
         if domain_admin_user is not None:
             pulumi.set(__self__, "domain_admin_user", domain_admin_user)
+        if domain_ou is not None:
+            pulumi.set(__self__, "domain_ou", domain_ou)
         if full_name is not None:
             pulumi.set(__self__, "full_name", full_name)
         if join_domain is not None:
@@ -2064,6 +3287,18 @@ class VirtualMachineCloneCustomizeWindowsOptionsArgs:
     def domain_admin_user(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "domain_admin_user", value)
 
+    @property
+    @pulumi.getter(name="domainOu")
+    def domain_ou(self) -> Optional[pulumi.Input[str]]:
+        """
+        The MachineObjectOU which specifies the full LDAP path name of the OU to which the virtual machine belongs.
+        """
+        return pulumi.get(self, "domain_ou")
+
+    @domain_ou.setter
+    def domain_ou(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "domain_ou", value)
+
     @property
     @pulumi.getter(name="fullName")
     def full_name(self) -> Optional[pulumi.Input[str]]:
@@ -2149,6 +3384,95 @@ class VirtualMachineCloneCustomizeWindowsOptionsArgs:
         pulumi.set(self, "workgroup", value)
 
 
+if not MYPY:
+    class VirtualMachineDiskArgsDict(TypedDict):
+        label: pulumi.Input[str]
+        """
+        A unique label for this disk.
+        """
+        attach: NotRequired[pulumi.Input[bool]]
+        """
+        If this is true, the disk is attached instead of created. Implies keep_on_remove.
+        """
+        controller_type: NotRequired[pulumi.Input[str]]
+        """
+        The type of controller the disk should be connected to. Must be 'scsi', 'sata', or 'ide'.
+        """
+        datastore_id: NotRequired[pulumi.Input[str]]
+        """
+        The datastore ID for this virtual disk, if different than the virtual machine.
+        """
+        device_address: NotRequired[pulumi.Input[str]]
+        """
+        The internally-computed address of this device, such as scsi:0:1, denoting scsi bus #0 and device unit 1.
+        """
+        disk_mode: NotRequired[pulumi.Input[str]]
+        """
+        The mode of this this virtual disk for purposes of writes and snapshotting. Can be one of append, independent_nonpersistent, independent_persistent, nonpersistent, persistent, or undoable.
+        """
+        disk_sharing: NotRequired[pulumi.Input[str]]
+        """
+        The sharing mode of this virtual disk. Can be one of sharingMultiWriter or sharingNone.
+        """
+        eagerly_scrub: NotRequired[pulumi.Input[bool]]
+        """
+        The virtual disk file zeroing policy when thin_provision is not true. The default is false, which lazily-zeros the disk, speeding up thick-provisioned disk creation time.
+        """
+        io_limit: NotRequired[pulumi.Input[int]]
+        """
+        The upper limit of IOPS that this disk can use.
+        """
+        io_reservation: NotRequired[pulumi.Input[int]]
+        """
+        The I/O guarantee that this disk has, in IOPS.
+        """
+        io_share_count: NotRequired[pulumi.Input[int]]
+        """
+        The share count for this disk when the share level is custom.
+        """
+        io_share_level: NotRequired[pulumi.Input[str]]
+        """
+        The share allocation level for this disk. Can be one of low, normal, high, or custom.
+        """
+        keep_on_remove: NotRequired[pulumi.Input[bool]]
+        """
+        Set to true to keep the underlying VMDK file when removing this virtual disk from configuration.
+        """
+        key: NotRequired[pulumi.Input[int]]
+        """
+        The ID of the device within the virtual machine.
+        """
+        path: NotRequired[pulumi.Input[str]]
+        """
+        The full path of the virtual disk. This can only be provided if attach is set to true, otherwise it is a read-only value.
+        """
+        size: NotRequired[pulumi.Input[int]]
+        """
+        The size of the disk, in GB.
+        """
+        storage_policy_id: NotRequired[pulumi.Input[str]]
+        """
+        The ID of the storage policy to assign to the virtual disk in VM.
+        """
+        thin_provisioned: NotRequired[pulumi.Input[bool]]
+        """
+        If true, this disk is thin provisioned, with space for the file being allocated on an as-needed basis.
+        """
+        unit_number: NotRequired[pulumi.Input[int]]
+        """
+        The unique device number for this disk. This number determines where on the SCSI bus this device will be attached.
+        """
+        uuid: NotRequired[pulumi.Input[str]]
+        """
+        The UUID of the virtual machine. Also exposed as the `id` of the resource.
+        """
+        write_through: NotRequired[pulumi.Input[bool]]
+        """
+        If true, writes for this disk are sent directly to the filesystem immediately instead of being buffered.
+        """
+elif False:
+    VirtualMachineDiskArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class VirtualMachineDiskArgs:
     def __init__(__self__, *,
@@ -2175,36 +3499,26 @@ class VirtualMachineDiskArgs:
                  write_through: Optional[pulumi.Input[bool]] = None):
         """
         :param pulumi.Input[str] label: A unique label for this disk.
-        :param pulumi.Input[bool] attach: Attach an external disk instead of creating a new one. Implies and conflicts with `keep_on_remove`. If set, you cannot set `size`, `eagerly_scrub`, or `thin_provisioned`. Must set `path` if used.
-               
-               > **NOTE:** External disks cannot be attached when `datastore_cluster_id` is used.
-        :param pulumi.Input[str] controller_type: The type of storage controller to attach the  disk to. Can be `scsi`, `sata`, or `ide`. You must have the appropriate number of controllers enabled for the selected type. Default `scsi`.
-        :param pulumi.Input[str] datastore_id: The datastore ID that on which the ISO is located. Required for using a datastore ISO. Conflicts with `client_device`.
+        :param pulumi.Input[bool] attach: If this is true, the disk is attached instead of created. Implies keep_on_remove.
+        :param pulumi.Input[str] controller_type: The type of controller the disk should be connected to. Must be 'scsi', 'sata', or 'ide'.
+        :param pulumi.Input[str] datastore_id: The datastore ID for this virtual disk, if different than the virtual machine.
         :param pulumi.Input[str] device_address: The internally-computed address of this device, such as scsi:0:1, denoting scsi bus #0 and device unit 1.
-        :param pulumi.Input[str] disk_mode: The mode of this this virtual disk for purposes of writes and snapshots. One of `append`, `independent_nonpersistent`, `independent_persistent`, `nonpersistent`, `persistent`, or `undoable`. Default: `persistent`. For more information on these option, please refer to the [product documentation][vmware-docs-disk-mode].
-               
-               [vmware-docs-disk-mode]: https://vdc-download.vmware.com/vmwb-repository/dcr-public/da47f910-60ac-438b-8b9b-6122f4d14524/16b7274a-bf8b-4b4c-a05e-746f2aa93c8c/doc/vim.vm.device.VirtualDiskOption.DiskMode.html
-        :param pulumi.Input[str] disk_sharing: The sharing mode of this virtual disk. One of `sharingMultiWriter` or `sharingNone`. Default: `sharingNone`.
-               
-               > **NOTE:** Disk sharing is only available on vSphere 6.0 and later.
-        :param pulumi.Input[bool] eagerly_scrub: If set to `true`, the disk space is zeroed out when the virtual machine is created. This will delay the creation of the virtual disk. Cannot be set to `true` when `thin_provisioned` is `true`.  See the section on picking a disk type for more information.  Default: `false`.
-        :param pulumi.Input[int] io_limit: The upper limit of IOPS that this disk can use. The default is no limit.
-        :param pulumi.Input[int] io_reservation: The I/O reservation (guarantee) for the virtual disk has, in IOPS.  The default is no reservation.
-        :param pulumi.Input[int] io_share_count: The share count for the virtual disk when the share level is `custom`.
-        :param pulumi.Input[str] io_share_level: The share allocation level for the virtual disk. One of `low`, `normal`, `high`, or `custom`. Default: `normal`.
-        :param pulumi.Input[bool] keep_on_remove: Keep this disk when removing the device or destroying the virtual machine. Default: `false`.
+        :param pulumi.Input[str] disk_mode: The mode of this this virtual disk for purposes of writes and snapshotting. Can be one of append, independent_nonpersistent, independent_persistent, nonpersistent, persistent, or undoable.
+        :param pulumi.Input[str] disk_sharing: The sharing mode of this virtual disk. Can be one of sharingMultiWriter or sharingNone.
+        :param pulumi.Input[bool] eagerly_scrub: The virtual disk file zeroing policy when thin_provision is not true. The default is false, which lazily-zeros the disk, speeding up thick-provisioned disk creation time.
+        :param pulumi.Input[int] io_limit: The upper limit of IOPS that this disk can use.
+        :param pulumi.Input[int] io_reservation: The I/O guarantee that this disk has, in IOPS.
+        :param pulumi.Input[int] io_share_count: The share count for this disk when the share level is custom.
+        :param pulumi.Input[str] io_share_level: The share allocation level for this disk. Can be one of low, normal, high, or custom.
+        :param pulumi.Input[bool] keep_on_remove: Set to true to keep the underlying VMDK file when removing this virtual disk from configuration.
         :param pulumi.Input[int] key: The ID of the device within the virtual machine.
-        :param pulumi.Input[str] path: The path to the ISO file. Required for using a datastore ISO. Conflicts with `client_device`.
-               
-               > **NOTE:** Either `client_device` (for a remote backed CD-ROM) or `datastore_id` and `path` (for a datastore ISO backed CD-ROM) are required to .
-               
-               > **NOTE:** Some CD-ROM drive types are not supported by this resource, such as pass-through devices. If these drives are present in a cloned template, or added outside of the provider, the desired state will be corrected to the defined device, or removed if no `cdrom` block is present.
-        :param pulumi.Input[int] size: The size of the disk, in GB. Must be a whole number.
-        :param pulumi.Input[str] storage_policy_id: The UUID of the storage policy to assign to the virtual disk.
-        :param pulumi.Input[bool] thin_provisioned: If `true`, the disk is thin provisioned, with space for the file being allocated on an as-needed basis. Cannot be set to `true` when `eagerly_scrub` is `true`. See the section on selecting a disk type for more information. Default: `true`.
-        :param pulumi.Input[int] unit_number: The disk number on the storage bus. The maximum value for this setting is the value of the controller count times the controller capacity (15 for SCSI, 30 for SATA, and 2 for IDE). Duplicate unit numbers are not allowed. Default `0`, for which one disk must be set to.
-        :param pulumi.Input[str] uuid: The UUID of the virtual disk VMDK file. This is used to track the virtual disk on the virtual machine.
-        :param pulumi.Input[bool] write_through: If `true`, writes for this disk are sent directly to the filesystem immediately instead of being buffered. Default: `false`.
+        :param pulumi.Input[str] path: The full path of the virtual disk. This can only be provided if attach is set to true, otherwise it is a read-only value.
+        :param pulumi.Input[int] size: The size of the disk, in GB.
+        :param pulumi.Input[str] storage_policy_id: The ID of the storage policy to assign to the virtual disk in VM.
+        :param pulumi.Input[bool] thin_provisioned: If true, this disk is thin provisioned, with space for the file being allocated on an as-needed basis.
+        :param pulumi.Input[int] unit_number: The unique device number for this disk. This number determines where on the SCSI bus this device will be attached.
+        :param pulumi.Input[str] uuid: The UUID of the virtual machine. Also exposed as the `id` of the resource.
+        :param pulumi.Input[bool] write_through: If true, writes for this disk are sent directly to the filesystem immediately instead of being buffered.
         """
         pulumi.set(__self__, "label", label)
         if attach is not None:
@@ -2264,9 +3578,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter
     def attach(self) -> Optional[pulumi.Input[bool]]:
         """
-        Attach an external disk instead of creating a new one. Implies and conflicts with `keep_on_remove`. If set, you cannot set `size`, `eagerly_scrub`, or `thin_provisioned`. Must set `path` if used.
-
-        > **NOTE:** External disks cannot be attached when `datastore_cluster_id` is used.
+        If this is true, the disk is attached instead of created. Implies keep_on_remove.
         """
         return pulumi.get(self, "attach")
 
@@ -2278,7 +3590,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter(name="controllerType")
     def controller_type(self) -> Optional[pulumi.Input[str]]:
         """
-        The type of storage controller to attach the  disk to. Can be `scsi`, `sata`, or `ide`. You must have the appropriate number of controllers enabled for the selected type. Default `scsi`.
+        The type of controller the disk should be connected to. Must be 'scsi', 'sata', or 'ide'.
         """
         return pulumi.get(self, "controller_type")
 
@@ -2290,7 +3602,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter(name="datastoreId")
     def datastore_id(self) -> Optional[pulumi.Input[str]]:
         """
-        The datastore ID that on which the ISO is located. Required for using a datastore ISO. Conflicts with `client_device`.
+        The datastore ID for this virtual disk, if different than the virtual machine.
         """
         return pulumi.get(self, "datastore_id")
 
@@ -2314,9 +3626,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter(name="diskMode")
     def disk_mode(self) -> Optional[pulumi.Input[str]]:
         """
-        The mode of this this virtual disk for purposes of writes and snapshots. One of `append`, `independent_nonpersistent`, `independent_persistent`, `nonpersistent`, `persistent`, or `undoable`. Default: `persistent`. For more information on these option, please refer to the [product documentation][vmware-docs-disk-mode].
-
-        [vmware-docs-disk-mode]: https://vdc-download.vmware.com/vmwb-repository/dcr-public/da47f910-60ac-438b-8b9b-6122f4d14524/16b7274a-bf8b-4b4c-a05e-746f2aa93c8c/doc/vim.vm.device.VirtualDiskOption.DiskMode.html
+        The mode of this this virtual disk for purposes of writes and snapshotting. Can be one of append, independent_nonpersistent, independent_persistent, nonpersistent, persistent, or undoable.
         """
         return pulumi.get(self, "disk_mode")
 
@@ -2328,9 +3638,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter(name="diskSharing")
     def disk_sharing(self) -> Optional[pulumi.Input[str]]:
         """
-        The sharing mode of this virtual disk. One of `sharingMultiWriter` or `sharingNone`. Default: `sharingNone`.
-
-        > **NOTE:** Disk sharing is only available on vSphere 6.0 and later.
+        The sharing mode of this virtual disk. Can be one of sharingMultiWriter or sharingNone.
         """
         return pulumi.get(self, "disk_sharing")
 
@@ -2342,7 +3650,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter(name="eagerlyScrub")
     def eagerly_scrub(self) -> Optional[pulumi.Input[bool]]:
         """
-        If set to `true`, the disk space is zeroed out when the virtual machine is created. This will delay the creation of the virtual disk. Cannot be set to `true` when `thin_provisioned` is `true`.  See the section on picking a disk type for more information.  Default: `false`.
+        The virtual disk file zeroing policy when thin_provision is not true. The default is false, which lazily-zeros the disk, speeding up thick-provisioned disk creation time.
         """
         return pulumi.get(self, "eagerly_scrub")
 
@@ -2354,7 +3662,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter(name="ioLimit")
     def io_limit(self) -> Optional[pulumi.Input[int]]:
         """
-        The upper limit of IOPS that this disk can use. The default is no limit.
+        The upper limit of IOPS that this disk can use.
         """
         return pulumi.get(self, "io_limit")
 
@@ -2366,7 +3674,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter(name="ioReservation")
     def io_reservation(self) -> Optional[pulumi.Input[int]]:
         """
-        The I/O reservation (guarantee) for the virtual disk has, in IOPS.  The default is no reservation.
+        The I/O guarantee that this disk has, in IOPS.
         """
         return pulumi.get(self, "io_reservation")
 
@@ -2378,7 +3686,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter(name="ioShareCount")
     def io_share_count(self) -> Optional[pulumi.Input[int]]:
         """
-        The share count for the virtual disk when the share level is `custom`.
+        The share count for this disk when the share level is custom.
         """
         return pulumi.get(self, "io_share_count")
 
@@ -2390,7 +3698,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter(name="ioShareLevel")
     def io_share_level(self) -> Optional[pulumi.Input[str]]:
         """
-        The share allocation level for the virtual disk. One of `low`, `normal`, `high`, or `custom`. Default: `normal`.
+        The share allocation level for this disk. Can be one of low, normal, high, or custom.
         """
         return pulumi.get(self, "io_share_level")
 
@@ -2402,7 +3710,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter(name="keepOnRemove")
     def keep_on_remove(self) -> Optional[pulumi.Input[bool]]:
         """
-        Keep this disk when removing the device or destroying the virtual machine. Default: `false`.
+        Set to true to keep the underlying VMDK file when removing this virtual disk from configuration.
         """
         return pulumi.get(self, "keep_on_remove")
 
@@ -2426,11 +3734,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter
     def path(self) -> Optional[pulumi.Input[str]]:
         """
-        The path to the ISO file. Required for using a datastore ISO. Conflicts with `client_device`.
-
-        > **NOTE:** Either `client_device` (for a remote backed CD-ROM) or `datastore_id` and `path` (for a datastore ISO backed CD-ROM) are required to .
-
-        > **NOTE:** Some CD-ROM drive types are not supported by this resource, such as pass-through devices. If these drives are present in a cloned template, or added outside of the provider, the desired state will be corrected to the defined device, or removed if no `cdrom` block is present.
+        The full path of the virtual disk. This can only be provided if attach is set to true, otherwise it is a read-only value.
         """
         return pulumi.get(self, "path")
 
@@ -2442,7 +3746,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter
     def size(self) -> Optional[pulumi.Input[int]]:
         """
-        The size of the disk, in GB. Must be a whole number.
+        The size of the disk, in GB.
         """
         return pulumi.get(self, "size")
 
@@ -2454,7 +3758,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter(name="storagePolicyId")
     def storage_policy_id(self) -> Optional[pulumi.Input[str]]:
         """
-        The UUID of the storage policy to assign to the virtual disk.
+        The ID of the storage policy to assign to the virtual disk in VM.
         """
         return pulumi.get(self, "storage_policy_id")
 
@@ -2466,7 +3770,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter(name="thinProvisioned")
     def thin_provisioned(self) -> Optional[pulumi.Input[bool]]:
         """
-        If `true`, the disk is thin provisioned, with space for the file being allocated on an as-needed basis. Cannot be set to `true` when `eagerly_scrub` is `true`. See the section on selecting a disk type for more information. Default: `true`.
+        If true, this disk is thin provisioned, with space for the file being allocated on an as-needed basis.
         """
         return pulumi.get(self, "thin_provisioned")
 
@@ -2478,7 +3782,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter(name="unitNumber")
     def unit_number(self) -> Optional[pulumi.Input[int]]:
         """
-        The disk number on the storage bus. The maximum value for this setting is the value of the controller count times the controller capacity (15 for SCSI, 30 for SATA, and 2 for IDE). Duplicate unit numbers are not allowed. Default `0`, for which one disk must be set to.
+        The unique device number for this disk. This number determines where on the SCSI bus this device will be attached.
         """
         return pulumi.get(self, "unit_number")
 
@@ -2490,7 +3794,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter
     def uuid(self) -> Optional[pulumi.Input[str]]:
         """
-        The UUID of the virtual disk VMDK file. This is used to track the virtual disk on the virtual machine.
+        The UUID of the virtual machine. Also exposed as the `id` of the resource.
         """
         return pulumi.get(self, "uuid")
 
@@ -2502,7 +3806,7 @@ class VirtualMachineDiskArgs:
     @pulumi.getter(name="writeThrough")
     def write_through(self) -> Optional[pulumi.Input[bool]]:
         """
-        If `true`, writes for this disk are sent directly to the filesystem immediately instead of being buffered. Default: `false`.
+        If true, writes for this disk are sent directly to the filesystem immediately instead of being buffered.
         """
         return pulumi.get(self, "write_through")
 
@@ -2511,6 +3815,59 @@ class VirtualMachineDiskArgs:
         pulumi.set(self, "write_through", value)
 
 
+if not MYPY:
+    class VirtualMachineNetworkInterfaceArgsDict(TypedDict):
+        network_id: pulumi.Input[str]
+        """
+        The ID of the network to connect this network interface to.
+        """
+        adapter_type: NotRequired[pulumi.Input[str]]
+        """
+        The controller type. Can be one of e1000, e1000e, sriov, vmxnet3, or vrdma.
+        """
+        bandwidth_limit: NotRequired[pulumi.Input[int]]
+        """
+        The upper bandwidth limit of this network interface, in Mbits/sec.
+        """
+        bandwidth_reservation: NotRequired[pulumi.Input[int]]
+        """
+        The bandwidth reservation of this network interface, in Mbits/sec.
+        """
+        bandwidth_share_count: NotRequired[pulumi.Input[int]]
+        """
+        The share count for this network interface when the share level is custom.
+        """
+        bandwidth_share_level: NotRequired[pulumi.Input[str]]
+        """
+        The bandwidth share allocation level for this interface. Can be one of low, normal, high, or custom.
+        """
+        device_address: NotRequired[pulumi.Input[str]]
+        """
+        The internally-computed address of this device, such as scsi:0:1, denoting scsi bus #0 and device unit 1.
+        """
+        key: NotRequired[pulumi.Input[int]]
+        """
+        The ID of the device within the virtual machine.
+        """
+        mac_address: NotRequired[pulumi.Input[str]]
+        """
+        The MAC address of this network interface. Can only be manually set if use_static_mac is true.
+        """
+        ovf_mapping: NotRequired[pulumi.Input[str]]
+        """
+        Mapping of network interface to OVF network.
+        """
+        physical_function: NotRequired[pulumi.Input[str]]
+        """
+        The ID of the Physical SR-IOV NIC to attach to, e.g. '0000:d8:00.0'
+        """
+        use_static_mac: NotRequired[pulumi.Input[bool]]
+        """
+        If true, the mac_address field is treated as a static MAC address and set accordingly.
+        """
+elif False:
+    VirtualMachineNetworkInterfaceArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class VirtualMachineNetworkInterfaceArgs:
     def __init__(__self__, *,
@@ -2527,18 +3884,18 @@ class VirtualMachineNetworkInterfaceArgs:
                  physical_function: Optional[pulumi.Input[str]] = None,
                  use_static_mac: Optional[pulumi.Input[bool]] = None):
         """
-        :param pulumi.Input[str] network_id: The [managed object reference ID][docs-about-morefs] of the network on which to connect the virtual machine network interface.
-        :param pulumi.Input[str] adapter_type: The network interface type. One of `e1000`, `e1000e`, `sriov`, or `vmxnet3`. Default: `vmxnet3`.
-        :param pulumi.Input[int] bandwidth_limit: The upper bandwidth limit of the network interface, in Mbits/sec. The default is no limit. Ignored if `adapter_type` is set to `sriov`.
-        :param pulumi.Input[int] bandwidth_reservation: The bandwidth reservation of the network interface, in Mbits/sec. The default is no reservation.
-        :param pulumi.Input[int] bandwidth_share_count: The share count for the network interface when the share level is `custom`. Ignored if `adapter_type` is set to `sriov`.
-        :param pulumi.Input[str] bandwidth_share_level: The bandwidth share allocation level for the network interface. One of `low`, `normal`, `high`, or `custom`. Default: `normal`. Ignored if `adapter_type` is set to `sriov`.
+        :param pulumi.Input[str] network_id: The ID of the network to connect this network interface to.
+        :param pulumi.Input[str] adapter_type: The controller type. Can be one of e1000, e1000e, sriov, vmxnet3, or vrdma.
+        :param pulumi.Input[int] bandwidth_limit: The upper bandwidth limit of this network interface, in Mbits/sec.
+        :param pulumi.Input[int] bandwidth_reservation: The bandwidth reservation of this network interface, in Mbits/sec.
+        :param pulumi.Input[int] bandwidth_share_count: The share count for this network interface when the share level is custom.
+        :param pulumi.Input[str] bandwidth_share_level: The bandwidth share allocation level for this interface. Can be one of low, normal, high, or custom.
         :param pulumi.Input[str] device_address: The internally-computed address of this device, such as scsi:0:1, denoting scsi bus #0 and device unit 1.
         :param pulumi.Input[int] key: The ID of the device within the virtual machine.
-        :param pulumi.Input[str] mac_address: The MAC address of the network interface. Can only be manually set if `use_static_mac` is `true`. Otherwise, the value is computed and presents the assigned MAC address for the interface.
-        :param pulumi.Input[str] ovf_mapping: Specifies which NIC in an OVF/OVA the `network_interface` should be associated. Only applies at creation when deploying from an OVF/OVA.
+        :param pulumi.Input[str] mac_address: The MAC address of this network interface. Can only be manually set if use_static_mac is true.
+        :param pulumi.Input[str] ovf_mapping: Mapping of network interface to OVF network.
         :param pulumi.Input[str] physical_function: The ID of the Physical SR-IOV NIC to attach to, e.g. '0000:d8:00.0'
-        :param pulumi.Input[bool] use_static_mac: If true, the `mac_address` field is treated as a static MAC address and set accordingly. Setting this to `true` requires `mac_address` to be set. Default: `false`.
+        :param pulumi.Input[bool] use_static_mac: If true, the mac_address field is treated as a static MAC address and set accordingly.
         """
         pulumi.set(__self__, "network_id", network_id)
         if adapter_type is not None:
@@ -2568,7 +3925,7 @@ class VirtualMachineNetworkInterfaceArgs:
     @pulumi.getter(name="networkId")
     def network_id(self) -> pulumi.Input[str]:
         """
-        The [managed object reference ID][docs-about-morefs] of the network on which to connect the virtual machine network interface.
+        The ID of the network to connect this network interface to.
         """
         return pulumi.get(self, "network_id")
 
@@ -2580,7 +3937,7 @@ class VirtualMachineNetworkInterfaceArgs:
     @pulumi.getter(name="adapterType")
     def adapter_type(self) -> Optional[pulumi.Input[str]]:
         """
-        The network interface type. One of `e1000`, `e1000e`, `sriov`, or `vmxnet3`. Default: `vmxnet3`.
+        The controller type. Can be one of e1000, e1000e, sriov, vmxnet3, or vrdma.
         """
         return pulumi.get(self, "adapter_type")
 
@@ -2592,7 +3949,7 @@ class VirtualMachineNetworkInterfaceArgs:
     @pulumi.getter(name="bandwidthLimit")
     def bandwidth_limit(self) -> Optional[pulumi.Input[int]]:
         """
-        The upper bandwidth limit of the network interface, in Mbits/sec. The default is no limit. Ignored if `adapter_type` is set to `sriov`.
+        The upper bandwidth limit of this network interface, in Mbits/sec.
         """
         return pulumi.get(self, "bandwidth_limit")
 
@@ -2604,7 +3961,7 @@ class VirtualMachineNetworkInterfaceArgs:
     @pulumi.getter(name="bandwidthReservation")
     def bandwidth_reservation(self) -> Optional[pulumi.Input[int]]:
         """
-        The bandwidth reservation of the network interface, in Mbits/sec. The default is no reservation.
+        The bandwidth reservation of this network interface, in Mbits/sec.
         """
         return pulumi.get(self, "bandwidth_reservation")
 
@@ -2616,7 +3973,7 @@ class VirtualMachineNetworkInterfaceArgs:
     @pulumi.getter(name="bandwidthShareCount")
     def bandwidth_share_count(self) -> Optional[pulumi.Input[int]]:
         """
-        The share count for the network interface when the share level is `custom`. Ignored if `adapter_type` is set to `sriov`.
+        The share count for this network interface when the share level is custom.
         """
         return pulumi.get(self, "bandwidth_share_count")
 
@@ -2628,7 +3985,7 @@ class VirtualMachineNetworkInterfaceArgs:
     @pulumi.getter(name="bandwidthShareLevel")
     def bandwidth_share_level(self) -> Optional[pulumi.Input[str]]:
         """
-        The bandwidth share allocation level for the network interface. One of `low`, `normal`, `high`, or `custom`. Default: `normal`. Ignored if `adapter_type` is set to `sriov`.
+        The bandwidth share allocation level for this interface. Can be one of low, normal, high, or custom.
         """
         return pulumi.get(self, "bandwidth_share_level")
 
@@ -2664,7 +4021,7 @@ class VirtualMachineNetworkInterfaceArgs:
     @pulumi.getter(name="macAddress")
     def mac_address(self) -> Optional[pulumi.Input[str]]:
         """
-        The MAC address of the network interface. Can only be manually set if `use_static_mac` is `true`. Otherwise, the value is computed and presents the assigned MAC address for the interface.
+        The MAC address of this network interface. Can only be manually set if use_static_mac is true.
         """
         return pulumi.get(self, "mac_address")
 
@@ -2676,7 +4033,7 @@ class VirtualMachineNetworkInterfaceArgs:
     @pulumi.getter(name="ovfMapping")
     def ovf_mapping(self) -> Optional[pulumi.Input[str]]:
         """
-        Specifies which NIC in an OVF/OVA the `network_interface` should be associated. Only applies at creation when deploying from an OVF/OVA.
+        Mapping of network interface to OVF network.
         """
         return pulumi.get(self, "ovf_mapping")
 
@@ -2700,7 +4057,7 @@ class VirtualMachineNetworkInterfaceArgs:
     @pulumi.getter(name="useStaticMac")
     def use_static_mac(self) -> Optional[pulumi.Input[bool]]:
         """
-        If true, the `mac_address` field is treated as a static MAC address and set accordingly. Setting this to `true` requires `mac_address` to be set. Default: `false`.
+        If true, the mac_address field is treated as a static MAC address and set accordingly.
         """
         return pulumi.get(self, "use_static_mac")
 
@@ -2709,6 +4066,47 @@ class VirtualMachineNetworkInterfaceArgs:
         pulumi.set(self, "use_static_mac", value)
 
 
+if not MYPY:
+    class VirtualMachineOvfDeployArgsDict(TypedDict):
+        allow_unverified_ssl_cert: NotRequired[pulumi.Input[bool]]
+        """
+        Allow unverified ssl certificates while deploying ovf/ova from url.
+        """
+        deployment_option: NotRequired[pulumi.Input[str]]
+        """
+        The Deployment option to be chosen. If empty, the default option is used.
+        """
+        disk_provisioning: NotRequired[pulumi.Input[str]]
+        """
+        An optional disk provisioning. If set, all the disks in the deployed ovf will have the same specified disk type (e.g., thin provisioned).
+        """
+        enable_hidden_properties: NotRequired[pulumi.Input[bool]]
+        """
+        Allow properties with ovf:userConfigurable=false to be set.
+        """
+        ip_allocation_policy: NotRequired[pulumi.Input[str]]
+        """
+        The IP allocation policy.
+        """
+        ip_protocol: NotRequired[pulumi.Input[str]]
+        """
+        The IP protocol.
+        """
+        local_ovf_path: NotRequired[pulumi.Input[str]]
+        """
+        The absolute path to the ovf/ova file in the local system.
+        """
+        ovf_network_map: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        The mapping of name of network identifiers from the ovf descriptor to network UUID in the VI infrastructure.
+        """
+        remote_ovf_url: NotRequired[pulumi.Input[str]]
+        """
+        URL to the remote ovf/ova file to be deployed.
+        """
+elif False:
+    VirtualMachineOvfDeployArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class VirtualMachineOvfDeployArgs:
     def __init__(__self__, *,
@@ -2860,6 +4258,15 @@ class VirtualMachineOvfDeployArgs:
         pulumi.set(self, "remote_ovf_url", value)
 
 
+if not MYPY:
+    class VirtualMachineVappArgsDict(TypedDict):
+        properties: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A map of customizable vApp properties and their values. Allows customization of VMs cloned from OVF templates which have customizable vApp properties.
+        """
+elif False:
+    VirtualMachineVappArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class VirtualMachineVappArgs:
     def __init__(__self__, *,
@@ -2883,6 +4290,55 @@ class VirtualMachineVappArgs:
         pulumi.set(self, "properties", value)
 
 
+if not MYPY:
+    class VirtualMachineVtpmArgsDict(TypedDict):
+        version: NotRequired[pulumi.Input[str]]
+        """
+        The version of the TPM device. Default is 2.0.
+        """
+elif False:
+    VirtualMachineVtpmArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class VirtualMachineVtpmArgs:
+    def __init__(__self__, *,
+                 version: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] version: The version of the TPM device. Default is 2.0.
+        """
+        if version is not None:
+            pulumi.set(__self__, "version", version)
+
+    @property
+    @pulumi.getter
+    def version(self) -> Optional[pulumi.Input[str]]:
+        """
+        The version of the TPM device. Default is 2.0.
+        """
+        return pulumi.get(self, "version")
+
+    @version.setter
+    def version(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "version", value)
+
+
+if not MYPY:
+    class VmStoragePolicyTagRuleArgsDict(TypedDict):
+        tag_category: pulumi.Input[str]
+        """
+        Name of the tag category.
+        """
+        tags: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        List of Name of tags to select from the given category.
+        """
+        include_datastores_with_tags: NotRequired[pulumi.Input[bool]]
+        """
+        Include datastores with the given tags or exclude. Default `true`.
+        """
+elif False:
+    VmStoragePolicyTagRuleArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class VmStoragePolicyTagRuleArgs:
     def __init__(__self__, *,
@@ -2936,6 +4392,27 @@ class VmStoragePolicyTagRuleArgs:
         pulumi.set(self, "include_datastores_with_tags", value)
 
 
+if not MYPY:
+    class VnicIpv4ArgsDict(TypedDict):
+        dhcp: NotRequired[pulumi.Input[bool]]
+        """
+        Use DHCP to configure the interface's IPv4 stack.
+        """
+        gw: NotRequired[pulumi.Input[str]]
+        """
+        IP address of the default gateway, if DHCP is not set.
+        """
+        ip: NotRequired[pulumi.Input[str]]
+        """
+        address of the interface, if DHCP is not set.
+        """
+        netmask: NotRequired[pulumi.Input[str]]
+        """
+        netmask of the interface, if DHCP is not set.
+        """
+elif False:
+    VnicIpv4ArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class VnicIpv4Args:
     def __init__(__self__, *,
@@ -2944,10 +4421,10 @@ class VnicIpv4Args:
                  ip: Optional[pulumi.Input[str]] = None,
                  netmask: Optional[pulumi.Input[str]] = None):
         """
-        :param pulumi.Input[bool] dhcp: Use DHCP to configure the interface's IPv6 stack.
-        :param pulumi.Input[str] gw: IP address of the default gateway, if DHCP or autoconfig is not set.
-        :param pulumi.Input[str] ip: Address of the interface, if DHCP is not set.
-        :param pulumi.Input[str] netmask: Netmask of the interface, if DHCP is not set.
+        :param pulumi.Input[bool] dhcp: Use DHCP to configure the interface's IPv4 stack.
+        :param pulumi.Input[str] gw: IP address of the default gateway, if DHCP is not set.
+        :param pulumi.Input[str] ip: address of the interface, if DHCP is not set.
+        :param pulumi.Input[str] netmask: netmask of the interface, if DHCP is not set.
         """
         if dhcp is not None:
             pulumi.set(__self__, "dhcp", dhcp)
@@ -2962,7 +4439,7 @@ class VnicIpv4Args:
     @pulumi.getter
     def dhcp(self) -> Optional[pulumi.Input[bool]]:
         """
-        Use DHCP to configure the interface's IPv6 stack.
+        Use DHCP to configure the interface's IPv4 stack.
         """
         return pulumi.get(self, "dhcp")
 
@@ -2974,7 +4451,7 @@ class VnicIpv4Args:
     @pulumi.getter
     def gw(self) -> Optional[pulumi.Input[str]]:
         """
-        IP address of the default gateway, if DHCP or autoconfig is not set.
+        IP address of the default gateway, if DHCP is not set.
         """
         return pulumi.get(self, "gw")
 
@@ -2986,7 +4463,7 @@ class VnicIpv4Args:
     @pulumi.getter
     def ip(self) -> Optional[pulumi.Input[str]]:
         """
-        Address of the interface, if DHCP is not set.
+        address of the interface, if DHCP is not set.
         """
         return pulumi.get(self, "ip")
 
@@ -2998,7 +4475,7 @@ class VnicIpv4Args:
     @pulumi.getter
     def netmask(self) -> Optional[pulumi.Input[str]]:
         """
-        Netmask of the interface, if DHCP is not set.
+        netmask of the interface, if DHCP is not set.
         """
         return pulumi.get(self, "netmask")
 
@@ -3007,6 +4484,27 @@ class VnicIpv4Args:
         pulumi.set(self, "netmask", value)
 
 
+if not MYPY:
+    class VnicIpv6ArgsDict(TypedDict):
+        addresses: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        List of IPv6 addresses
+        """
+        autoconfig: NotRequired[pulumi.Input[bool]]
+        """
+        Use IPv6 Autoconfiguration (RFC2462).
+        """
+        dhcp: NotRequired[pulumi.Input[bool]]
+        """
+        Use DHCP to configure the interface's IPv4 stack.
+        """
+        gw: NotRequired[pulumi.Input[str]]
+        """
+        IP address of the default gateway, if DHCP or autoconfig is not set.
+        """
+elif False:
+    VnicIpv6ArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class VnicIpv6Args:
     def __init__(__self__, *,
@@ -3017,7 +4515,7 @@ class VnicIpv6Args:
         """
         :param pulumi.Input[Sequence[pulumi.Input[str]]] addresses: List of IPv6 addresses
         :param pulumi.Input[bool] autoconfig: Use IPv6 Autoconfiguration (RFC2462).
-        :param pulumi.Input[bool] dhcp: Use DHCP to configure the interface's IPv6 stack.
+        :param pulumi.Input[bool] dhcp: Use DHCP to configure the interface's IPv4 stack.
         :param pulumi.Input[str] gw: IP address of the default gateway, if DHCP or autoconfig is not set.
         """
         if addresses is not None:
@@ -3057,7 +4555,7 @@ class VnicIpv6Args:
     @pulumi.getter
     def dhcp(self) -> Optional[pulumi.Input[bool]]:
         """
-        Use DHCP to configure the interface's IPv6 stack.
+        Use DHCP to configure the interface's IPv4 stack.
         """
         return pulumi.get(self, "dhcp")
 
@@ -3078,6 +4576,47 @@ class VnicIpv6Args:
         pulumi.set(self, "gw", value)
 
 
+if not MYPY:
+    class GetNetworkFilterArgsDict(TypedDict):
+        network_type: NotRequired[str]
+        """
+        This is required if you have multiple port groups with the same name. This will be one of `DistributedVirtualPortgroup` for distributed port groups, `Network` for standard (host-based) port groups, or `OpaqueNetwork` for networks managed externally, such as those managed by NSX.
+        """
+elif False:
+    GetNetworkFilterArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GetNetworkFilterArgs:
+    def __init__(__self__, *,
+                 network_type: Optional[str] = None):
+        """
+        :param str network_type: This is required if you have multiple port groups with the same name. This will be one of `DistributedVirtualPortgroup` for distributed port groups, `Network` for standard (host-based) port groups, or `OpaqueNetwork` for networks managed externally, such as those managed by NSX.
+        """
+        if network_type is not None:
+            pulumi.set(__self__, "network_type", network_type)
+
+    @property
+    @pulumi.getter(name="networkType")
+    def network_type(self) -> Optional[str]:
+        """
+        This is required if you have multiple port groups with the same name. This will be one of `DistributedVirtualPortgroup` for distributed port groups, `Network` for standard (host-based) port groups, or `OpaqueNetwork` for networks managed externally, such as those managed by NSX.
+        """
+        return pulumi.get(self, "network_type")
+
+    @network_type.setter
+    def network_type(self, value: Optional[str]):
+        pulumi.set(self, "network_type", value)
+
+
+if not MYPY:
+    class GetVirtualMachineVappArgsDict(TypedDict):
+        properties: NotRequired[Mapping[str, str]]
+        """
+        A map of customizable vApp properties and their values. Allows customization of VMs cloned from OVF templates which have customizable vApp properties.
+        """
+elif False:
+    GetVirtualMachineVappArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GetVirtualMachineVappArgs:
     def __init__(__self__, *,