proxmoxve.SDNZone.getVlan

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

const example = proxmoxve.SDNZone.getVlan({
    id: "vlan1",
});
export const dataProxmoxVirtualEnvironmentSdnZoneVlan = {
    id: example.then(example => example.id),
    nodes: example.then(example => example.nodes),
    bridge: example.then(example => example.bridge),
    mtu: example.then(example => example.mtu),
    dns: example.then(example => example.dns),
    dns_zone: example.then(example => example.dnsZone),
    ipam: example.then(example => example.ipam),
    reverse_dns: example.then(example => example.reverseDns),
};

import pulumi
import pulumi_proxmoxve as proxmoxve

example = proxmoxve.SDNZone.get_vlan(id="vlan1")
pulumi.export("dataProxmoxVirtualEnvironmentSdnZoneVlan", {
    "id": example.id,
    "nodes": example.nodes,
    "bridge": example.bridge,
    "mtu": example.mtu,
    "dns": example.dns,
    "dns_zone": example.dns_zone,
    "ipam": example.ipam,
    "reverse_dns": example.reverse_dns,
})

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := sdnzone.GetVlan(ctx, &sdnzone.GetVlanArgs{
			Id: "vlan1",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("dataProxmoxVirtualEnvironmentSdnZoneVlan", pulumi.Map{
			"id":          example.Id,
			"nodes":       example.Nodes,
			"bridge":      example.Bridge,
			"mtu":         example.Mtu,
			"dns":         example.Dns,
			"dns_zone":    example.DnsZone,
			"ipam":        example.Ipam,
			"reverse_dns": example.ReverseDns,
		})
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = ProxmoxVE.SDNZone.GetVlan.Invoke(new()
    {
        Id = "vlan1",
    });

    return new Dictionary<string, object?>
    {
        ["dataProxmoxVirtualEnvironmentSdnZoneVlan"] = 
        {
            { "id", example.Apply(getVlanResult => getVlanResult.Id) },
            { "nodes", example.Apply(getVlanResult => getVlanResult.Nodes) },
            { "bridge", example.Apply(getVlanResult => getVlanResult.Bridge) },
            { "mtu", example.Apply(getVlanResult => getVlanResult.Mtu) },
            { "dns", example.Apply(getVlanResult => getVlanResult.Dns) },
            { "dns_zone", example.Apply(getVlanResult => getVlanResult.DnsZone) },
            { "ipam", example.Apply(getVlanResult => getVlanResult.Ipam) },
            { "reverse_dns", example.Apply(getVlanResult => getVlanResult.ReverseDns) },
        },
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.proxmoxve.SDNZone.SDNZoneFunctions;
import com.pulumi.proxmoxve.SDNZone.inputs.GetVlanArgs;
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 = SDNZoneFunctions.getVlan(GetVlanArgs.builder()
            .id("vlan1")
            .build());

        ctx.export("dataProxmoxVirtualEnvironmentSdnZoneVlan", Map.ofEntries(
            Map.entry("id", example.id()),
            Map.entry("nodes", example.nodes()),
            Map.entry("bridge", example.bridge()),
            Map.entry("mtu", example.mtu()),
            Map.entry("dns", example.dns()),
            Map.entry("dns_zone", example.dnsZone()),
            Map.entry("ipam", example.ipam()),
            Map.entry("reverse_dns", example.reverseDns())
        ));
    }
}

variables:
  example:
    fn::invoke:
      function: proxmoxve:SDNZone:getVlan
      arguments:
        id: vlan1
outputs:
  dataProxmoxVirtualEnvironmentSdnZoneVlan:
    id: ${example.id}
    nodes: ${example.nodes}
    bridge: ${example.bridge}
    mtu: ${example.mtu}
    dns: ${example.dns}
    dns_zone: ${example.dnsZone}
    ipam: ${example.ipam}
    reverse_dns: ${example.reverseDns}

function getVlan(args: GetVlanArgs, opts?: InvokeOptions): Promise<GetVlanResult>
function getVlanOutput(args: GetVlanOutputArgs, opts?: InvokeOptions): Output<GetVlanResult>

def get_vlan(id: Optional[str] = None,
             opts: Optional[InvokeOptions] = None) -> GetVlanResult
def get_vlan_output(id: Optional[pulumi.Input[str]] = None,
             opts: Optional[InvokeOptions] = None) -> Output[GetVlanResult]

func LookupVlan(ctx *Context, args *LookupVlanArgs, opts ...InvokeOption) (*LookupVlanResult, error)
func LookupVlanOutput(ctx *Context, args *LookupVlanOutputArgs, opts ...InvokeOption) LookupVlanResultOutput

public static class GetVlan 
{
    public static Task<GetVlanResult> InvokeAsync(GetVlanArgs args, InvokeOptions? opts = null)
    public static Output<GetVlanResult> Invoke(GetVlanInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetVlanResult> getVlan(GetVlanArgs args, InvokeOptions options)
public static Output<GetVlanResult> getVlan(GetVlanArgs args, InvokeOptions options)

fn::invoke:
  function: proxmoxve:SDNZone/getVlan:getVlan
  arguments:
    # arguments dictionary