vra.getRegionEnumeration

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

const _this = vra.getRegionEnumerationVsphere({
    acceptSelfSignedCert: false,
    dcId: _var.vra_data_collector_id,
    hostname: _var.hostname,
    password: _var.password,
    username: _var.username,
});

import pulumi
import pulumi_vra as vra

this = vra.get_region_enumeration_vsphere(accept_self_signed_cert=False,
    dc_id=var["vra_data_collector_id"],
    hostname=var["hostname"],
    password=var["password"],
    username=var["username"])

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/vra/vra"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := vra.GetRegionEnumerationVsphere(ctx, &vra.GetRegionEnumerationVsphereArgs{
			AcceptSelfSignedCert: pulumi.BoolRef(false),
			DcId:                 pulumi.StringRef(_var.Vra_data_collector_id),
			Hostname:             _var.Hostname,
			Password:             _var.Password,
			Username:             _var.Username,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var @this = Vra.GetRegionEnumerationVsphere.Invoke(new()
    {
        AcceptSelfSignedCert = false,
        DcId = @var.Vra_data_collector_id,
        Hostname = @var.Hostname,
        Password = @var.Password,
        Username = @var.Username,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vra.VraFunctions;
import com.pulumi.vra.inputs.GetRegionEnumerationVsphereArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        final var this = VraFunctions.getRegionEnumerationVsphere(GetRegionEnumerationVsphereArgs.builder()
            .acceptSelfSignedCert(false)
            .dcId(var_.vra_data_collector_id())
            .hostname(var_.hostname())
            .password(var_.password())
            .username(var_.username())
            .build());

    }
}

variables:
  this:
    fn::invoke:
      function: vra:getRegionEnumerationVsphere
      arguments:
        acceptSelfSignedCert: false
        dcId: ${var.vra_data_collector_id}
        hostname: ${var.hostname}
        password: ${var.password}
        username: ${var.username}

function getRegionEnumeration(args: GetRegionEnumerationArgs, opts?: InvokeOptions): Promise<GetRegionEnumerationResult>
function getRegionEnumerationOutput(args: GetRegionEnumerationOutputArgs, opts?: InvokeOptions): Output<GetRegionEnumerationResult>

def get_region_enumeration(accept_self_signed_cert: Optional[bool] = None,
                           dc_id: Optional[str] = None,
                           hostname: Optional[str] = None,
                           id: Optional[str] = None,
                           password: Optional[str] = None,
                           username: Optional[str] = None,
                           opts: Optional[InvokeOptions] = None) -> GetRegionEnumerationResult
def get_region_enumeration_output(accept_self_signed_cert: Optional[pulumi.Input[bool]] = None,
                           dc_id: Optional[pulumi.Input[str]] = None,
                           hostname: Optional[pulumi.Input[str]] = None,
                           id: Optional[pulumi.Input[str]] = None,
                           password: Optional[pulumi.Input[str]] = None,
                           username: Optional[pulumi.Input[str]] = None,
                           opts: Optional[InvokeOptions] = None) -> Output[GetRegionEnumerationResult]

func GetRegionEnumeration(ctx *Context, args *GetRegionEnumerationArgs, opts ...InvokeOption) (*GetRegionEnumerationResult, error)
func GetRegionEnumerationOutput(ctx *Context, args *GetRegionEnumerationOutputArgs, opts ...InvokeOption) GetRegionEnumerationResultOutput

public static class GetRegionEnumeration 
{
    public static Task<GetRegionEnumerationResult> InvokeAsync(GetRegionEnumerationArgs args, InvokeOptions? opts = null)
    public static Output<GetRegionEnumerationResult> Invoke(GetRegionEnumerationInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetRegionEnumerationResult> getRegionEnumeration(GetRegionEnumerationArgs args, InvokeOptions options)
public static Output<GetRegionEnumerationResult> getRegionEnumeration(GetRegionEnumerationArgs args, InvokeOptions options)

fn::invoke:
  function: vra:index/getRegionEnumeration:getRegionEnumeration
  arguments:
    # arguments dictionary