proxmoxve.Sdn.getVnet

import * as pulumi from "@pulumi/pulumi";
import * as proxmoxve from "@muhlba91/pulumi-proxmoxve";

const example = proxmoxve.Sdn.getVnet({
    id: "vnet1",
});
export const dataProxmoxVirtualEnvironmentSdnVnet = {
    id: example.then(example => example.id),
    zone: example.then(example => example.zone),
    alias: example.then(example => example.alias),
    isolatePorts: example.then(example => example.isolatePorts),
    tag: example.then(example => example.tag),
    vlanAware: example.then(example => example.vlanAware),
};

import pulumi
import pulumi_proxmoxve as proxmoxve

example = proxmoxve.Sdn.get_vnet(id="vnet1")
pulumi.export("dataProxmoxVirtualEnvironmentSdnVnet", {
    "id": example.id,
    "zone": example.zone,
    "alias": example.alias,
    "isolatePorts": example.isolate_ports,
    "tag": example.tag,
    "vlanAware": example.vlan_aware,
})

package main

import (
	"github.com/muhlba91/pulumi-proxmoxve/sdk/v7/go/proxmoxve/sdn"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := sdn.GetVnet(ctx, &sdn.GetVnetArgs{
			Id: "vnet1",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("dataProxmoxVirtualEnvironmentSdnVnet", pulumi.Map{
			"id":           example.Id,
			"zone":         example.Zone,
			"alias":        example.Alias,
			"isolatePorts": example.IsolatePorts,
			"tag":          example.Tag,
			"vlanAware":    example.VlanAware,
		})
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = ProxmoxVE.Sdn.GetVnet.Invoke(new()
    {
        Id = "vnet1",
    });

    return new Dictionary<string, object?>
    {
        ["dataProxmoxVirtualEnvironmentSdnVnet"] = 
        {
            { "id", example.Apply(getVnetResult => getVnetResult.Id) },
            { "zone", example.Apply(getVnetResult => getVnetResult.Zone) },
            { "alias", example.Apply(getVnetResult => getVnetResult.Alias) },
            { "isolatePorts", example.Apply(getVnetResult => getVnetResult.IsolatePorts) },
            { "tag", example.Apply(getVnetResult => getVnetResult.Tag) },
            { "vlanAware", example.Apply(getVnetResult => getVnetResult.VlanAware) },
        },
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.proxmoxve.Sdn.SdnFunctions;
import com.pulumi.proxmoxve.Sdn.inputs.GetVnetArgs;
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 example = SdnFunctions.getVnet(GetVnetArgs.builder()
            .id("vnet1")
            .build());

        ctx.export("dataProxmoxVirtualEnvironmentSdnVnet", Map.ofEntries(
            Map.entry("id", example.id()),
            Map.entry("zone", example.zone()),
            Map.entry("alias", example.alias()),
            Map.entry("isolatePorts", example.isolatePorts()),
            Map.entry("tag", example.tag()),
            Map.entry("vlanAware", example.vlanAware())
        ));
    }
}

variables:
  example:
    fn::invoke:
      function: proxmoxve:Sdn:getVnet
      arguments:
        id: vnet1
outputs:
  dataProxmoxVirtualEnvironmentSdnVnet:
    id: ${example.id}
    zone: ${example.zone}
    alias: ${example.alias}
    isolatePorts: ${example.isolatePorts}
    tag: ${example.tag}
    vlanAware: ${example.vlanAware}

function getVnet(args: GetVnetArgs, opts?: InvokeOptions): Promise<GetVnetResult>
function getVnetOutput(args: GetVnetOutputArgs, opts?: InvokeOptions): Output<GetVnetResult>

def get_vnet(id: Optional[str] = None,
             opts: Optional[InvokeOptions] = None) -> GetVnetResult
def get_vnet_output(id: Optional[pulumi.Input[str]] = None,
             opts: Optional[InvokeOptions] = None) -> Output[GetVnetResult]

func LookupVnet(ctx *Context, args *LookupVnetArgs, opts ...InvokeOption) (*LookupVnetResult, error)
func LookupVnetOutput(ctx *Context, args *LookupVnetOutputArgs, opts ...InvokeOption) LookupVnetResultOutput

public static class GetVnet 
{
    public static Task<GetVnetResult> InvokeAsync(GetVnetArgs args, InvokeOptions? opts = null)
    public static Output<GetVnetResult> Invoke(GetVnetInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetVnetResult> getVnet(GetVnetArgs args, InvokeOptions options)
public static Output<GetVnetResult> getVnet(GetVnetArgs args, InvokeOptions options)

fn::invoke:
  function: proxmoxve:Sdn/getVnet:getVnet
  arguments:
    # arguments dictionary