Upgrade pulumi-terraform-bridge to v3.63.1

provider/go.mod

@@ -11,7 +11,7 @@ replace (
 
 require (
 	github.com/hashicorp/terraform-provider-vsphere v2.3.1+incompatible
-	github.com/pulumi/pulumi-terraform-bridge/v3 v3.63.0
+	github.com/pulumi/pulumi-terraform-bridge/v3 v3.63.1
 	github.com/pulumi/pulumi/sdk/v3 v3.90.1
 )
 

provider/go.sum

@@ -2155,8 +2155,8 @@ github.com/pulumi/pulumi-java/pkg v0.9.8 h1:c8mYsalnRXA2Ibgvv6scefOn6mW1Vb0UT0mc
 github.com/pulumi/pulumi-java/pkg v0.9.8/go.mod h1:c6rSw/+q4O0IImgJ9axxoC6QesbPYWBaG5gimbHouUQ=
 github.com/pulumi/pulumi-terraform-bridge/testing v0.0.1 h1:SCg1gjfY9N4yn8U8peIUYATifjoDABkyR7H9lmefsfc=
 github.com/pulumi/pulumi-terraform-bridge/testing v0.0.1/go.mod h1:7OeUPH8rpt5ipyj9EFcnXpuzQ8SHL0dyqdfa8nOacdk=
-github.com/pulumi/pulumi-terraform-bridge/v3 v3.63.0 h1:otdmkNsMGyZ+proUZClznZo+cEchkSSkmaGcq+Gf+6s=
-github.com/pulumi/pulumi-terraform-bridge/v3 v3.63.0/go.mod h1:6YVbDo019OeHkQWo9MnUbBy6cCgCQeoXZDjmR9SYmUA=
+github.com/pulumi/pulumi-terraform-bridge/v3 v3.63.1 h1:hBgediyT2LdS5yfD5AMiCmBJ/TYP94Xxv6a4TcAfV0g=
+github.com/pulumi/pulumi-terraform-bridge/v3 v3.63.1/go.mod h1:6YVbDo019OeHkQWo9MnUbBy6cCgCQeoXZDjmR9SYmUA=
 github.com/pulumi/pulumi-terraform-bridge/x/muxer v0.0.4 h1:rIzMmtcVpPX8ynaz6/nW5AHNY63DiNfCohqmxWvMpM4=
 github.com/pulumi/pulumi-terraform-bridge/x/muxer v0.0.4/go.mod h1:Kt8RIZWa/N8rW3+0g6NrqCBmF3o+HuIhFaZpssEkG6w=
 github.com/pulumi/pulumi-yaml v1.2.2 h1:W6BeUBLhDrJ2GSU0em1AUVelG9PBI4ABY61DdhJOO3E=

sdk/dotnet/ComputeClusterVmAffinityRule.cs

@@ -31,6 +31,135 @@ namespace Pulumi.VSphere
     /// direct ESXi host connections.
     /// 
     /// > **NOTE:** vSphere DRS requires a vSphere Enterprise Plus license.
+    /// 
+    /// ## Example Usage
+    /// 
+    /// The following example creates two virtual machines in a cluster using the
+    /// `vsphere.VirtualMachine` resource, creating the
+    /// virtual machines in the cluster looked up by the
+    /// `vsphere.ComputeCluster` data source. It
+    /// then creates an affinity rule for these two virtual machines, ensuring they
+    /// will run on the same host whenever possible.
+    /// 
+    /// ```csharp
+    /// using System.Collections.Generic;
+    /// using System.Linq;
+    /// using Pulumi;
+    /// using VSphere = Pulumi.VSphere;
+    /// 
+    /// return await Deployment.RunAsync(() => 
+    /// {
+    ///     var datacenter = VSphere.GetDatacenter.Invoke(new()
+    ///     {
+    ///         Name = "dc-01",
+    ///     });
+    /// 
+    ///     var datastore = VSphere.GetDatastore.Invoke(new()
+    ///     {
+    ///         Name = "datastore-01",
+    ///         DatacenterId = datacenter.Apply(getDatacenterResult => getDatacenterResult.Id),
+    ///     });
+    /// 
+    ///     var cluster = VSphere.GetComputeCluster.Invoke(new()
+    ///     {
+    ///         Name = "cluster-01",
+    ///         DatacenterId = datacenter.Apply(getDatacenterResult => getDatacenterResult.Id),
+    ///     });
+    /// 
+    ///     var network = VSphere.GetNetwork.Invoke(new()
+    ///     {
+    ///         Name = "VM Network",
+    ///         DatacenterId = datacenter.Apply(getDatacenterResult => getDatacenterResult.Id),
+    ///     });
+    /// 
+    ///     var vm = new List<VSphere.VirtualMachine>();
+    ///     for (var rangeIndex = 0; rangeIndex < 2; rangeIndex++)
+    ///     {
+    ///         var range = new { Value = rangeIndex };
+    ///         vm.Add(new VSphere.VirtualMachine($"vm-{range.Value}", new()
+    ///         {
+    ///             ResourcePoolId = cluster.Apply(getComputeClusterResult => getComputeClusterResult.ResourcePoolId),
+    ///             DatastoreId = datastore.Apply(getDatastoreResult => getDatastoreResult.Id),
+    ///             NumCpus = 1,
+    ///             Memory = 1024,
+    ///             GuestId = "otherLinux64Guest",
+    ///             NetworkInterfaces = new[]
+    ///             {
+    ///                 new VSphere.Inputs.VirtualMachineNetworkInterfaceArgs
+    ///                 {
+    ///                     NetworkId = network.Apply(getNetworkResult => getNetworkResult.Id),
+    ///                 },
+    ///             },
+    ///             Disks = new[]
+    ///             {
+    ///                 new VSphere.Inputs.VirtualMachineDiskArgs
+    ///                 {
+    ///                     Label = "disk0",
+    ///                     Size = 20,
+    ///                 },
+    ///             },
+    ///         }));
+    ///     }
+    ///     var vmAffinityRule = new VSphere.ComputeClusterVmAffinityRule("vmAffinityRule", new()
+    ///     {
+    ///         ComputeClusterId = cluster.Apply(getComputeClusterResult => getComputeClusterResult.Id),
+    ///         VirtualMachineIds = vm.Select((value, i) => new { Key = i.ToString(), Value = pair.Value }).Select(v => 
+    ///         {
+    ///             return v.Id;
+    ///         }).ToList(),
+    ///     });
+    /// 
+    /// });
+    /// ```
+    /// 
+    /// The following example creates an affinity rule for a set of virtual machines
+    /// in the cluster by looking up the virtual machine UUIDs from the
+    /// `vsphere.VirtualMachine` data source.
+    /// 
+    /// ```csharp
+    /// using System.Collections.Generic;
+    /// using System.Linq;
+    /// using Pulumi;
+    /// using VSphere = Pulumi.VSphere;
+    /// 
+    /// return await Deployment.RunAsync(() => 
+    /// {
+    ///     var vms = new[]
+    ///     {
+    ///         "foo-0",
+    ///         "foo-1",
+    ///     };
+    /// 
+    ///     var datacenter = VSphere.GetDatacenter.Invoke(new()
+    ///     {
+    ///         Name = "dc-01",
+    ///     });
+    /// 
+    ///     var cluster = VSphere.GetComputeCluster.Invoke(new()
+    ///     {
+    ///         Name = "cluster-01",
+    ///         DatacenterId = datacenter.Apply(getDatacenterResult => getDatacenterResult.Id),
+    ///     });
+    /// 
+    ///     var vmsVirtualMachine = "TODO: Range  range( length(vms)
+    /// ) false".Select(__index => 
+    ///     {
+    ///         return VSphere.GetVirtualMachine.Invoke(new()
+    ///         {
+    ///             Name = vms[__index],
+    ///             DatacenterId = _arg0_.Id,
+    ///         });
+    ///     }).ToList();
+    /// 
+    ///     var vmAffinityRule = new VSphere.ComputeClusterVmAffinityRule("vmAffinityRule", new()
+    ///     {
+    ///         Enabled = true,
+    ///         ComputeClusterId = cluster.Apply(getComputeClusterResult => getComputeClusterResult.Id),
+    ///         VirtualMachineIds = vmsVirtualMachine.Select(__item => __item.Id).ToList(),
+    ///     });
+    /// 
+    /// });
+    /// ```
     /// </summary>
     [VSphereResourceType("vsphere:index/computeClusterVmAffinityRule:ComputeClusterVmAffinityRule")]
     public partial class ComputeClusterVmAffinityRule : global::Pulumi.CustomResource

sdk/dotnet/Datacenter.cs

@@ -14,6 +14,37 @@ namespace Pulumi.VSphere
     /// container of inventory objects such as hosts and virtual machines.
     /// 
     /// ## Example Usage
+    /// ### Create datacenter on the root folder
+    /// 
+    /// ```csharp
+    /// using System.Collections.Generic;
+    /// using System.Linq;
+    /// using Pulumi;
+    /// using VSphere = Pulumi.VSphere;
+    /// 
+    /// return await Deployment.RunAsync(() => 
+    /// {
+    ///     var prodDatacenter = new VSphere.Datacenter("prodDatacenter");
+    /// 
+    /// });
+    /// ```
+    /// ### Create datacenter on a subfolder
+    /// 
+    /// ```csharp
+    /// using System.Collections.Generic;
+    /// using System.Linq;
+    /// using Pulumi;
+    /// using VSphere = Pulumi.VSphere;
+    /// 
+    /// return await Deployment.RunAsync(() => 
+    /// {
+    ///     var researchDatacenter = new VSphere.Datacenter("researchDatacenter", new()
+    ///     {
+    ///         Folder = "/research/",
+    ///     });
+    /// 
+    /// });
+    /// ```
     /// </summary>
     [VSphereResourceType("vsphere:index/datacenter:Datacenter")]
     public partial class Datacenter : global::Pulumi.CustomResource

sdk/dotnet/DistributedVirtualSwitch.cs

@@ -607,6 +607,34 @@ public partial class DistributedVirtualSwitch : global::Pulumi.CustomResource
         /// and `max_vlan` sub-arguments to define the tagged VLAN range. Multiple
         /// `vlan_range` definitions are allowed, but they must not overlap. Example
         /// below:
+        /// 
+        /// ```csharp
+        /// using System.Collections.Generic;
+        /// using System.Linq;
+        /// using Pulumi;
+        /// using VSphere = Pulumi.VSphere;
+        /// 
+        /// return await Deployment.RunAsync(() => 
+        /// {
+        ///     var vds = new VSphere.DistributedVirtualSwitch("vds", new()
+        ///     {
+        ///         VlanRanges = new[]
+        ///         {
+        ///             new VSphere.Inputs.DistributedVirtualSwitchVlanRangeArgs
+        ///             {
+        ///                 MaxVlan = 199,
+        ///                 MinVlan = 100,
+        ///             },
+        ///             new VSphere.Inputs.DistributedVirtualSwitchVlanRangeArgs
+        ///             {
+        ///                 MaxVlan = 399,
+        ///                 MinVlan = 300,
+        ///             },
+        ///         },
+        ///     });
+        /// 
+        /// });
+        /// ```
         /// </summary>
         [Output("vlanRanges")]
         public Output<ImmutableArray<Outputs.DistributedVirtualSwitchVlanRange>> VlanRanges { get; private set; } = null!;
@@ -1338,6 +1366,34 @@ public InputList<string> Uplinks
         /// and `max_vlan` sub-arguments to define the tagged VLAN range. Multiple
         /// `vlan_range` definitions are allowed, but they must not overlap. Example
         /// below:
+        /// 
+        /// ```csharp
+        /// using System.Collections.Generic;
+        /// using System.Linq;
+        /// using Pulumi;
+        /// using VSphere = Pulumi.VSphere;
+        /// 
+        /// return await Deployment.RunAsync(() =&gt; 
+        /// {
+        ///     var vds = new VSphere.DistributedVirtualSwitch("vds", new()
+        ///     {
+        ///         VlanRanges = new[]
+        ///         {
+        ///             new VSphere.Inputs.DistributedVirtualSwitchVlanRangeArgs
+        ///             {
+        ///                 MaxVlan = 199,
+        ///                 MinVlan = 100,
+        ///             },
+        ///             new VSphere.Inputs.DistributedVirtualSwitchVlanRangeArgs
+        ///             {
+        ///                 MaxVlan = 399,
+        ///                 MinVlan = 300,
+        ///             },
+        ///         },
+        ///     });
+        /// 
+        /// });
+        /// ```
         /// </summary>
         public InputList<Inputs.DistributedVirtualSwitchVlanRangeArgs> VlanRanges
         {
@@ -2041,6 +2097,34 @@ public InputList<string> Uplinks
         /// and `max_vlan` sub-arguments to define the tagged VLAN range. Multiple
         /// `vlan_range` definitions are allowed, but they must not overlap. Example
         /// below:
+        /// 
+        /// ```csharp
+        /// using System.Collections.Generic;
+        /// using System.Linq;
+        /// using Pulumi;
+        /// using VSphere = Pulumi.VSphere;
+        /// 
+        /// return await Deployment.RunAsync(() =&gt; 
+        /// {
+        ///     var vds = new VSphere.DistributedVirtualSwitch("vds", new()
+        ///     {
+        ///         VlanRanges = new[]
+        ///         {
+        ///             new VSphere.Inputs.DistributedVirtualSwitchVlanRangeArgs
+        ///             {
+        ///                 MaxVlan = 199,
+        ///                 MinVlan = 100,
+        ///             },
+        ///             new VSphere.Inputs.DistributedVirtualSwitchVlanRangeArgs
+        ///             {
+        ///                 MaxVlan = 399,
+        ///                 MinVlan = 300,
+        ///             },
+        ///         },
+        ///     });
+        /// 
+        /// });
+        /// ```
         /// </summary>
         public InputList<Inputs.DistributedVirtualSwitchVlanRangeGetArgs> VlanRanges
         {

sdk/dotnet/File.cs

@@ -11,6 +11,50 @@ namespace Pulumi.VSphere
 {
     /// <summary>
     /// ## Example Usage
+    /// ### Uploading a File
+    /// 
+    /// ```csharp
+    /// using System.Collections.Generic;
+    /// using System.Linq;
+    /// using Pulumi;
+    /// using VSphere = Pulumi.VSphere;
+    /// 
+    /// return await Deployment.RunAsync(() =&gt; 
+    /// {
+    ///     var ubuntuVmdkUpload = new VSphere.File("ubuntuVmdkUpload", new()
+    ///     {
+    ///         CreateDirectories = true,
+    ///         Datacenter = "dc-01",
+    ///         Datastore = "datastore-01",
+    ///         DestinationFile = "/my/dst/path/custom_ubuntu.vmdk",
+    ///         SourceFile = "/my/src/path/custom_ubuntu.vmdk",
+    ///     });
+    /// 
+    /// });
+    /// ```
+    /// ### Copying a File
+    /// 
+    /// ```csharp
+    /// using System.Collections.Generic;
+    /// using System.Linq;
+    /// using Pulumi;
+    /// using VSphere = Pulumi.VSphere;
+    /// 
+    /// return await Deployment.RunAsync(() =&gt; 
+    /// {
+    ///     var ubuntuCopy = new VSphere.File("ubuntuCopy", new()
+    ///     {
+    ///         CreateDirectories = true,
+    ///         Datacenter = "dc-01",
+    ///         Datastore = "datastore-01",
+    ///         DestinationFile = "/my/dst/path/custom_ubuntu.vmdk",
+    ///         SourceDatacenter = "dc-01",
+    ///         SourceDatastore = "datastore-01",
+    ///         SourceFile = "/my/src/path/custom_ubuntu.vmdk",
+    ///     });
+    /// 
+    /// });
+    /// ```
     /// </summary>
     [VSphereResourceType("vsphere:index/file:File")]
     public partial class File : global::Pulumi.CustomResource