proxmoxve.sdn.getVnetLegacy

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

const example = proxmoxve.sdn.getVnetLegacy({
    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_legacy(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/v8/go/proxmoxve/sdn"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := sdn.LookupVnetLegacy(ctx, &sdn.LookupVnetLegacyArgs{
			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.GetVnetLegacy.Invoke(new()
    {
        Id = "vnet1",
    });

    return new Dictionary<string, object?>
    {
        ["dataProxmoxVirtualEnvironmentSdnVnet"] = 
        {
            { "id", example.Apply(getVnetLegacyResult => getVnetLegacyResult.Id) },
            { "zone", example.Apply(getVnetLegacyResult => getVnetLegacyResult.Zone) },
            { "alias", example.Apply(getVnetLegacyResult => getVnetLegacyResult.Alias) },
            { "isolatePorts", example.Apply(getVnetLegacyResult => getVnetLegacyResult.IsolatePorts) },
            { "tag", example.Apply(getVnetLegacyResult => getVnetLegacyResult.Tag) },
            { "vlanAware", example.Apply(getVnetLegacyResult => getVnetLegacyResult.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.GetVnetLegacyArgs;
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.getVnetLegacy(GetVnetLegacyArgs.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:getVnetLegacy
      arguments:
        id: vnet1
outputs:
  dataProxmoxVirtualEnvironmentSdnVnet:
    id: ${example.id}
    zone: ${example.zone}
    alias: ${example.alias}
    isolatePorts: ${example.isolatePorts}
    tag: ${example.tag}
    vlanAware: ${example.vlanAware}

function getVnetLegacy(args: GetVnetLegacyArgs, opts?: InvokeOptions): Promise<GetVnetLegacyResult>
function getVnetLegacyOutput(args: GetVnetLegacyOutputArgs, opts?: InvokeOptions): Output<GetVnetLegacyResult>

def get_vnet_legacy(id: Optional[str] = None,
                    opts: Optional[InvokeOptions] = None) -> GetVnetLegacyResult
def get_vnet_legacy_output(id: Optional[pulumi.Input[str]] = None,
                    opts: Optional[InvokeOptions] = None) -> Output[GetVnetLegacyResult]

func LookupVnetLegacy(ctx *Context, args *LookupVnetLegacyArgs, opts ...InvokeOption) (*LookupVnetLegacyResult, error)
func LookupVnetLegacyOutput(ctx *Context, args *LookupVnetLegacyOutputArgs, opts ...InvokeOption) LookupVnetLegacyResultOutput

public static class GetVnetLegacy 
{
    public static Task<GetVnetLegacyResult> InvokeAsync(GetVnetLegacyArgs args, InvokeOptions? opts = null)
    public static Output<GetVnetLegacyResult> Invoke(GetVnetLegacyInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetVnetLegacyResult> getVnetLegacy(GetVnetLegacyArgs args, InvokeOptions options)
public static Output<GetVnetLegacyResult> getVnetLegacy(GetVnetLegacyArgs args, InvokeOptions options)

fn::invoke:
  function: proxmoxve:sdn/getVnetLegacy:getVnetLegacy
  arguments:
    # arguments dictionary