pulumi-vsphere 4.9.0a1698129503__py3-none-any.whl → 4.9.0a1698198425__py3-none-any.whl

pulumi_vsphere/_inputs.py

@@ -46,31 +46,6 @@ class ComputeClusterVsanDiskGroupArgs:
                
                > **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.
-               
-               ```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_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"],
-                   )])
-               ```
         """
         ComputeClusterVsanDiskGroupArgs._configure(
             lambda key, value: pulumi.set(__self__, key, value),
@@ -82,7 +57,9 @@ class ComputeClusterVsanDiskGroupArgs:
              _setter: Callable[[Any, Any], None],
              cache: Optional[pulumi.Input[str]] = None,
              storages: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+
         if cache is not None:
             _setter("cache", cache)
         if storages is not None:
@@ -108,31 +85,6 @@ class ComputeClusterVsanDiskGroupArgs:
 
         > **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.
-
-        ```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_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"],
-            )])
-        ```
         """
         return pulumi.get(self, "storages")
 
@@ -172,7 +124,13 @@ class ContentLibraryPublicationArgs:
              publish_url: Optional[pulumi.Input[str]] = None,
              published: Optional[pulumi.Input[bool]] = None,
              username: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if authentication_method is None and 'authenticationMethod' in kwargs:
+            authentication_method = kwargs['authenticationMethod']
+        if publish_url is None and 'publishUrl' in kwargs:
+            publish_url = kwargs['publishUrl']
+
         if authentication_method is not None:
             _setter("authentication_method", authentication_method)
         if password is not None:
@@ -280,7 +238,17 @@ class ContentLibrarySubscriptionArgs:
              password: Optional[pulumi.Input[str]] = None,
              subscription_url: Optional[pulumi.Input[str]] = None,
              username: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if authentication_method is None and 'authenticationMethod' in kwargs:
+            authentication_method = kwargs['authenticationMethod']
+        if automatic_sync is None and 'automaticSync' in kwargs:
+            automatic_sync = kwargs['automaticSync']
+        if on_demand is None and 'onDemand' in kwargs:
+            on_demand = kwargs['onDemand']
+        if subscription_url is None and 'subscriptionUrl' in kwargs:
+            subscription_url = kwargs['subscriptionUrl']
+
         if authentication_method is not None:
             _setter("authentication_method", authentication_method)
         if automatic_sync is not None:
@@ -380,9 +348,19 @@ class DistributedPortGroupVlanRangeArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             max_vlan: pulumi.Input[int],
-             min_vlan: pulumi.Input[int],
-             opts: Optional[pulumi.ResourceOptions]=None):
+             max_vlan: Optional[pulumi.Input[int]] = None,
+             min_vlan: Optional[pulumi.Input[int]] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if max_vlan is None and 'maxVlan' in kwargs:
+            max_vlan = kwargs['maxVlan']
+        if max_vlan is None:
+            raise TypeError("Missing 'max_vlan' argument")
+        if min_vlan is None and 'minVlan' in kwargs:
+            min_vlan = kwargs['minVlan']
+        if min_vlan is None:
+            raise TypeError("Missing 'min_vlan' argument")
+
         _setter("max_vlan", max_vlan)
         _setter("min_vlan", min_vlan)
 
@@ -424,9 +402,15 @@ class DistributedVirtualSwitchHostArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             host_system_id: pulumi.Input[str],
+             host_system_id: Optional[pulumi.Input[str]] = None,
              devices: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if host_system_id is None and 'hostSystemId' in kwargs:
+            host_system_id = kwargs['hostSystemId']
+        if host_system_id is None:
+            raise TypeError("Missing 'host_system_id' argument")
+
         _setter("host_system_id", host_system_id)
         if devices is not None:
             _setter("devices", devices)
@@ -481,10 +465,24 @@ class DistributedVirtualSwitchPvlanMappingArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             primary_vlan_id: pulumi.Input[int],
-             pvlan_type: pulumi.Input[str],
-             secondary_vlan_id: pulumi.Input[int],
-             opts: Optional[pulumi.ResourceOptions]=None):
+             primary_vlan_id: Optional[pulumi.Input[int]] = None,
+             pvlan_type: Optional[pulumi.Input[str]] = None,
+             secondary_vlan_id: Optional[pulumi.Input[int]] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if primary_vlan_id is None and 'primaryVlanId' in kwargs:
+            primary_vlan_id = kwargs['primaryVlanId']
+        if primary_vlan_id is None:
+            raise TypeError("Missing 'primary_vlan_id' argument")
+        if pvlan_type is None and 'pvlanType' in kwargs:
+            pvlan_type = kwargs['pvlanType']
+        if pvlan_type is None:
+            raise TypeError("Missing 'pvlan_type' argument")
+        if secondary_vlan_id is None and 'secondaryVlanId' in kwargs:
+            secondary_vlan_id = kwargs['secondaryVlanId']
+        if secondary_vlan_id is None:
+            raise TypeError("Missing 'secondary_vlan_id' argument")
+
         _setter("primary_vlan_id", primary_vlan_id)
         _setter("pvlan_type", pvlan_type)
         _setter("secondary_vlan_id", secondary_vlan_id)
@@ -542,9 +540,19 @@ class DistributedVirtualSwitchVlanRangeArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             max_vlan: pulumi.Input[int],
-             min_vlan: pulumi.Input[int],
-             opts: Optional[pulumi.ResourceOptions]=None):
+             max_vlan: Optional[pulumi.Input[int]] = None,
+             min_vlan: Optional[pulumi.Input[int]] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if max_vlan is None and 'maxVlan' in kwargs:
+            max_vlan = kwargs['maxVlan']
+        if max_vlan is None:
+            raise TypeError("Missing 'max_vlan' argument")
+        if min_vlan is None and 'minVlan' in kwargs:
+            min_vlan = kwargs['minVlan']
+        if min_vlan is None:
+            raise TypeError("Missing 'min_vlan' argument")
+
         _setter("max_vlan", max_vlan)
         _setter("min_vlan", min_vlan)
 
@@ -590,11 +598,27 @@ class EntityPermissionsPermissionArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             is_group: pulumi.Input[bool],
-             propagate: pulumi.Input[bool],
-             role_id: pulumi.Input[str],
-             user_or_group: pulumi.Input[str],
-             opts: Optional[pulumi.ResourceOptions]=None):
+             is_group: Optional[pulumi.Input[bool]] = None,
+             propagate: Optional[pulumi.Input[bool]] = None,
+             role_id: Optional[pulumi.Input[str]] = None,
+             user_or_group: Optional[pulumi.Input[str]] = None,
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if is_group is None and 'isGroup' in kwargs:
+            is_group = kwargs['isGroup']
+        if is_group is None:
+            raise TypeError("Missing 'is_group' argument")
+        if propagate is None:
+            raise TypeError("Missing 'propagate' argument")
+        if role_id is None and 'roleId' in kwargs:
+            role_id = kwargs['roleId']
+        if role_id is None:
+            raise TypeError("Missing 'role_id' argument")
+        if user_or_group is None and 'userOrGroup' in kwargs:
+            user_or_group = kwargs['userOrGroup']
+        if user_or_group is None:
+            raise TypeError("Missing 'user_or_group' argument")
+
         _setter("is_group", is_group)
         _setter("propagate", propagate)
         _setter("role_id", role_id)
@@ -670,7 +694,11 @@ class HostPortGroupPortArgs:
              key: Optional[pulumi.Input[str]] = None,
              mac_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
              type: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if mac_addresses is None and 'macAddresses' in kwargs:
+            mac_addresses = kwargs['macAddresses']
+
         if key is not None:
             _setter("key", key)
         if mac_addresses is not None:
@@ -743,7 +771,15 @@ class VirtualMachineCdromArgs:
              device_address: Optional[pulumi.Input[str]] = None,
              key: Optional[pulumi.Input[int]] = None,
              path: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if client_device is None and 'clientDevice' in kwargs:
+            client_device = kwargs['clientDevice']
+        if datastore_id is None and 'datastoreId' in kwargs:
+            datastore_id = kwargs['datastoreId']
+        if device_address is None and 'deviceAddress' in kwargs:
+            device_address = kwargs['deviceAddress']
+
         if client_device is not None:
             _setter("client_device", client_device)
         if datastore_id is not None:
@@ -838,13 +874,25 @@ class VirtualMachineCloneArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             template_uuid: pulumi.Input[str],
+             template_uuid: Optional[pulumi.Input[str]] = None,
              customize: Optional[pulumi.Input['VirtualMachineCloneCustomizeArgs']] = None,
              linked_clone: Optional[pulumi.Input[bool]] = None,
              ovf_network_map: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
              ovf_storage_map: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
              timeout: Optional[pulumi.Input[int]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if template_uuid is None and 'templateUuid' in kwargs:
+            template_uuid = kwargs['templateUuid']
+        if template_uuid is None:
+            raise TypeError("Missing 'template_uuid' argument")
+        if linked_clone is None and 'linkedClone' in kwargs:
+            linked_clone = kwargs['linkedClone']
+        if ovf_network_map is None and 'ovfNetworkMap' in kwargs:
+            ovf_network_map = kwargs['ovfNetworkMap']
+        if ovf_storage_map is None and 'ovfStorageMap' in kwargs:
+            ovf_storage_map = kwargs['ovfStorageMap']
+
         _setter("template_uuid", template_uuid)
         if customize is not None:
             _setter("customize", customize)
@@ -951,7 +999,25 @@ class VirtualMachineCloneCustomizeArgs:
              timeout: Optional[pulumi.Input[int]] = None,
              windows_options: Optional[pulumi.Input['VirtualMachineCloneCustomizeWindowsOptionsArgs']] = None,
              windows_sysprep_text: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if dns_server_lists is None and 'dnsServerLists' in kwargs:
+            dns_server_lists = kwargs['dnsServerLists']
+        if dns_suffix_lists is None and 'dnsSuffixLists' in kwargs:
+            dns_suffix_lists = kwargs['dnsSuffixLists']
+        if ipv4_gateway is None and 'ipv4Gateway' in kwargs:
+            ipv4_gateway = kwargs['ipv4Gateway']
+        if ipv6_gateway is None and 'ipv6Gateway' in kwargs:
+            ipv6_gateway = kwargs['ipv6Gateway']
+        if linux_options is None and 'linuxOptions' in kwargs:
+            linux_options = kwargs['linuxOptions']
+        if network_interfaces is None and 'networkInterfaces' in kwargs:
+            network_interfaces = kwargs['networkInterfaces']
+        if windows_options is None and 'windowsOptions' in kwargs:
+            windows_options = kwargs['windowsOptions']
+        if windows_sysprep_text is None and 'windowsSysprepText' in kwargs:
+            windows_sysprep_text = kwargs['windowsSysprepText']
+
         if dns_server_lists is not None:
             _setter("dns_server_lists", dns_server_lists)
         if dns_suffix_lists is not None:
@@ -1075,12 +1141,26 @@ class VirtualMachineCloneCustomizeLinuxOptionsArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             domain: pulumi.Input[str],
-             host_name: pulumi.Input[str],
+             domain: Optional[pulumi.Input[str]] = None,
+             host_name: Optional[pulumi.Input[str]] = None,
              hw_clock_utc: Optional[pulumi.Input[bool]] = None,
              script_text: Optional[pulumi.Input[str]] = None,
              time_zone: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if domain is None:
+            raise TypeError("Missing 'domain' argument")
+        if host_name is None and 'hostName' in kwargs:
+            host_name = kwargs['hostName']
+        if host_name is None:
+            raise TypeError("Missing 'host_name' argument")
+        if hw_clock_utc is None and 'hwClockUtc' in kwargs:
+            hw_clock_utc = kwargs['hwClockUtc']
+        if script_text is None and 'scriptText' in kwargs:
+            script_text = kwargs['scriptText']
+        if time_zone is None and 'timeZone' in kwargs:
+            time_zone = kwargs['timeZone']
+
         _setter("domain", domain)
         _setter("host_name", host_name)
         if hw_clock_utc is not None:
@@ -1163,7 +1243,21 @@ class VirtualMachineCloneCustomizeNetworkInterfaceArgs:
              ipv4_netmask: Optional[pulumi.Input[int]] = None,
              ipv6_address: Optional[pulumi.Input[str]] = None,
              ipv6_netmask: Optional[pulumi.Input[int]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if dns_domain is None and 'dnsDomain' in kwargs:
+            dns_domain = kwargs['dnsDomain']
+        if dns_server_lists is None and 'dnsServerLists' in kwargs:
+            dns_server_lists = kwargs['dnsServerLists']
+        if ipv4_address is None and 'ipv4Address' in kwargs:
+            ipv4_address = kwargs['ipv4Address']
+        if ipv4_netmask is None and 'ipv4Netmask' in kwargs:
+            ipv4_netmask = kwargs['ipv4Netmask']
+        if ipv6_address is None and 'ipv6Address' in kwargs:
+            ipv6_address = kwargs['ipv6Address']
+        if ipv6_netmask is None and 'ipv6Netmask' in kwargs:
+            ipv6_netmask = kwargs['ipv6Netmask']
+
         if dns_domain is not None:
             _setter("dns_domain", dns_domain)
         if dns_server_lists is not None:
@@ -1267,7 +1361,7 @@ class VirtualMachineCloneCustomizeWindowsOptionsArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             computer_name: pulumi.Input[str],
+             computer_name: Optional[pulumi.Input[str]] = None,
              admin_password: Optional[pulumi.Input[str]] = None,
              auto_logon: Optional[pulumi.Input[bool]] = None,
              auto_logon_count: Optional[pulumi.Input[int]] = None,
@@ -1280,7 +1374,35 @@ class VirtualMachineCloneCustomizeWindowsOptionsArgs:
              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,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if computer_name is None and 'computerName' in kwargs:
+            computer_name = kwargs['computerName']
+        if computer_name is None:
+            raise TypeError("Missing 'computer_name' argument")
+        if admin_password is None and 'adminPassword' in kwargs:
+            admin_password = kwargs['adminPassword']
+        if auto_logon is None and 'autoLogon' in kwargs:
+            auto_logon = kwargs['autoLogon']
+        if auto_logon_count is None and 'autoLogonCount' in kwargs:
+            auto_logon_count = kwargs['autoLogonCount']
+        if domain_admin_password is None and 'domainAdminPassword' in kwargs:
+            domain_admin_password = kwargs['domainAdminPassword']
+        if domain_admin_user is None and 'domainAdminUser' in kwargs:
+            domain_admin_user = kwargs['domainAdminUser']
+        if full_name is None and 'fullName' in kwargs:
+            full_name = kwargs['fullName']
+        if join_domain is None and 'joinDomain' in kwargs:
+            join_domain = kwargs['joinDomain']
+        if organization_name is None and 'organizationName' in kwargs:
+            organization_name = kwargs['organizationName']
+        if product_key is None and 'productKey' in kwargs:
+            product_key = kwargs['productKey']
+        if run_once_command_lists is None and 'runOnceCommandLists' in kwargs:
+            run_once_command_lists = kwargs['runOnceCommandLists']
+        if time_zone is None and 'timeZone' in kwargs:
+            time_zone = kwargs['timeZone']
+
         _setter("computer_name", computer_name)
         if admin_password is not None:
             _setter("admin_password", admin_password)
@@ -1507,7 +1629,7 @@ class VirtualMachineDiskArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             label: pulumi.Input[str],
+             label: Optional[pulumi.Input[str]] = None,
              attach: Optional[pulumi.Input[bool]] = None,
              controller_type: Optional[pulumi.Input[str]] = None,
              datastore_id: Optional[pulumi.Input[str]] = None,
@@ -1528,7 +1650,41 @@ class VirtualMachineDiskArgs:
              unit_number: Optional[pulumi.Input[int]] = None,
              uuid: Optional[pulumi.Input[str]] = None,
              write_through: Optional[pulumi.Input[bool]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if label is None:
+            raise TypeError("Missing 'label' argument")
+        if controller_type is None and 'controllerType' in kwargs:
+            controller_type = kwargs['controllerType']
+        if datastore_id is None and 'datastoreId' in kwargs:
+            datastore_id = kwargs['datastoreId']
+        if device_address is None and 'deviceAddress' in kwargs:
+            device_address = kwargs['deviceAddress']
+        if disk_mode is None and 'diskMode' in kwargs:
+            disk_mode = kwargs['diskMode']
+        if disk_sharing is None and 'diskSharing' in kwargs:
+            disk_sharing = kwargs['diskSharing']
+        if eagerly_scrub is None and 'eagerlyScrub' in kwargs:
+            eagerly_scrub = kwargs['eagerlyScrub']
+        if io_limit is None and 'ioLimit' in kwargs:
+            io_limit = kwargs['ioLimit']
+        if io_reservation is None and 'ioReservation' in kwargs:
+            io_reservation = kwargs['ioReservation']
+        if io_share_count is None and 'ioShareCount' in kwargs:
+            io_share_count = kwargs['ioShareCount']
+        if io_share_level is None and 'ioShareLevel' in kwargs:
+            io_share_level = kwargs['ioShareLevel']
+        if keep_on_remove is None and 'keepOnRemove' in kwargs:
+            keep_on_remove = kwargs['keepOnRemove']
+        if storage_policy_id is None and 'storagePolicyId' in kwargs:
+            storage_policy_id = kwargs['storagePolicyId']
+        if thin_provisioned is None and 'thinProvisioned' in kwargs:
+            thin_provisioned = kwargs['thinProvisioned']
+        if unit_number is None and 'unitNumber' in kwargs:
+            unit_number = kwargs['unitNumber']
+        if write_through is None and 'writeThrough' in kwargs:
+            write_through = kwargs['writeThrough']
+
         _setter("label", label)
         if attach is not None:
             _setter("attach", attach)
@@ -1871,7 +2027,7 @@ class VirtualMachineNetworkInterfaceArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             network_id: pulumi.Input[str],
+             network_id: Optional[pulumi.Input[str]] = None,
              adapter_type: Optional[pulumi.Input[str]] = None,
              bandwidth_limit: Optional[pulumi.Input[int]] = None,
              bandwidth_reservation: Optional[pulumi.Input[int]] = None,
@@ -1882,7 +2038,31 @@ class VirtualMachineNetworkInterfaceArgs:
              mac_address: Optional[pulumi.Input[str]] = None,
              ovf_mapping: Optional[pulumi.Input[str]] = None,
              use_static_mac: Optional[pulumi.Input[bool]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if network_id is None and 'networkId' in kwargs:
+            network_id = kwargs['networkId']
+        if network_id is None:
+            raise TypeError("Missing 'network_id' argument")
+        if adapter_type is None and 'adapterType' in kwargs:
+            adapter_type = kwargs['adapterType']
+        if bandwidth_limit is None and 'bandwidthLimit' in kwargs:
+            bandwidth_limit = kwargs['bandwidthLimit']
+        if bandwidth_reservation is None and 'bandwidthReservation' in kwargs:
+            bandwidth_reservation = kwargs['bandwidthReservation']
+        if bandwidth_share_count is None and 'bandwidthShareCount' in kwargs:
+            bandwidth_share_count = kwargs['bandwidthShareCount']
+        if bandwidth_share_level is None and 'bandwidthShareLevel' in kwargs:
+            bandwidth_share_level = kwargs['bandwidthShareLevel']
+        if device_address is None and 'deviceAddress' in kwargs:
+            device_address = kwargs['deviceAddress']
+        if mac_address is None and 'macAddress' in kwargs:
+            mac_address = kwargs['macAddress']
+        if ovf_mapping is None and 'ovfMapping' in kwargs:
+            ovf_mapping = kwargs['ovfMapping']
+        if use_static_mac is None and 'useStaticMac' in kwargs:
+            use_static_mac = kwargs['useStaticMac']
+
         _setter("network_id", network_id)
         if adapter_type is not None:
             _setter("adapter_type", adapter_type)
@@ -2071,7 +2251,27 @@ class VirtualMachineOvfDeployArgs:
              local_ovf_path: Optional[pulumi.Input[str]] = None,
              ovf_network_map: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
              remote_ovf_url: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if allow_unverified_ssl_cert is None and 'allowUnverifiedSslCert' in kwargs:
+            allow_unverified_ssl_cert = kwargs['allowUnverifiedSslCert']
+        if deployment_option is None and 'deploymentOption' in kwargs:
+            deployment_option = kwargs['deploymentOption']
+        if disk_provisioning is None and 'diskProvisioning' in kwargs:
+            disk_provisioning = kwargs['diskProvisioning']
+        if enable_hidden_properties is None and 'enableHiddenProperties' in kwargs:
+            enable_hidden_properties = kwargs['enableHiddenProperties']
+        if ip_allocation_policy is None and 'ipAllocationPolicy' in kwargs:
+            ip_allocation_policy = kwargs['ipAllocationPolicy']
+        if ip_protocol is None and 'ipProtocol' in kwargs:
+            ip_protocol = kwargs['ipProtocol']
+        if local_ovf_path is None and 'localOvfPath' in kwargs:
+            local_ovf_path = kwargs['localOvfPath']
+        if ovf_network_map is None and 'ovfNetworkMap' in kwargs:
+            ovf_network_map = kwargs['ovfNetworkMap']
+        if remote_ovf_url is None and 'remoteOvfUrl' in kwargs:
+            remote_ovf_url = kwargs['remoteOvfUrl']
+
         if allow_unverified_ssl_cert is not None:
             _setter("allow_unverified_ssl_cert", allow_unverified_ssl_cert)
         if deployment_option is not None:
@@ -2185,7 +2385,9 @@ class VirtualMachineVappArgs:
     def _configure(
              _setter: Callable[[Any, Any], None],
              properties: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+
         if properties is not None:
             _setter("properties", properties)
 
@@ -2219,10 +2421,20 @@ class VmStoragePolicyTagRuleArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             tag_category: pulumi.Input[str],
-             tags: pulumi.Input[Sequence[pulumi.Input[str]]],
+             tag_category: Optional[pulumi.Input[str]] = None,
+             tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
              include_datastores_with_tags: Optional[pulumi.Input[bool]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if tag_category is None and 'tagCategory' in kwargs:
+            tag_category = kwargs['tagCategory']
+        if tag_category is None:
+            raise TypeError("Missing 'tag_category' argument")
+        if tags is None:
+            raise TypeError("Missing 'tags' argument")
+        if include_datastores_with_tags is None and 'includeDatastoresWithTags' in kwargs:
+            include_datastores_with_tags = kwargs['includeDatastoresWithTags']
+
         _setter("tag_category", tag_category)
         _setter("tags", tags)
         if include_datastores_with_tags is not None:
@@ -2292,7 +2504,9 @@ class VnicIpv4Args:
              gw: Optional[pulumi.Input[str]] = None,
              ip: Optional[pulumi.Input[str]] = None,
              netmask: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+
         if dhcp is not None:
             _setter("dhcp", dhcp)
         if gw is not None:
@@ -2378,7 +2592,9 @@ class VnicIpv6Args:
              autoconfig: Optional[pulumi.Input[bool]] = None,
              dhcp: Optional[pulumi.Input[bool]] = None,
              gw: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+
         if addresses is not None:
             _setter("addresses", addresses)
         if autoconfig is not None:
@@ -2449,7 +2665,9 @@ class GetVirtualMachineVappArgs:
     def _configure(
              _setter: Callable[[Any, Any], None],
              properties: Optional[Mapping[str, str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+
         if properties is not None:
             _setter("properties", properties)
 

pulumi_vsphere/_utilities.py

@@ -246,5 +246,24 @@ def lift_output_func(func: typing.Any) -> typing.Callable[[_F], _F]:
 
     return (lambda _: lifted_func)
 
+
+def configure(val, cls: type, input: bool):
+    def _apply(v):
+        if isinstance(v, typing.Mapping):
+            def _setter(key, value):
+                v[key] = value
+            cls._configure(_setter, **v)
+        return v
+
+    # Check that cls has a static _configure method. External classes may
+    # not have it if it was generated with older codegen.
+    if hasattr(cls, "_configure"):
+        if isinstance(val, typing.Mapping):
+            return _apply(val)
+        elif input and val is not None and not isinstance(val, cls):
+            return pulumi.Output.from_input(val).apply(_apply)
+
+    return val
+
 def get_plugin_download_url():
 	return None