proxmoxve.SDNZone.getSimple

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

const example = proxmoxve.SDNZone.getSimple({
    id: "simple1",
});
export const dataProxmoxVirtualEnvironmentSdnZoneSimple = {
    id: example.then(example => example.id),
    nodes: example.then(example => example.nodes),
    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_simple(id="simple1")
pulumi.export("dataProxmoxVirtualEnvironmentSdnZoneSimple", {
    "id": example.id,
    "nodes": example.nodes,
    "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.GetSimple(ctx, &sdnzone.GetSimpleArgs{
			Id: "simple1",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("dataProxmoxVirtualEnvironmentSdnZoneSimple", pulumi.Map{
			"id":          example.Id,
			"nodes":       example.Nodes,
			"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.GetSimple.Invoke(new()
    {
        Id = "simple1",
    });

    return new Dictionary<string, object?>
    {
        ["dataProxmoxVirtualEnvironmentSdnZoneSimple"] = 
        {
            { "id", example.Apply(getSimpleResult => getSimpleResult.Id) },
            { "nodes", example.Apply(getSimpleResult => getSimpleResult.Nodes) },
            { "mtu", example.Apply(getSimpleResult => getSimpleResult.Mtu) },
            { "dns", example.Apply(getSimpleResult => getSimpleResult.Dns) },
            { "dns_zone", example.Apply(getSimpleResult => getSimpleResult.DnsZone) },
            { "ipam", example.Apply(getSimpleResult => getSimpleResult.Ipam) },
            { "reverse_dns", example.Apply(getSimpleResult => getSimpleResult.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.GetSimpleArgs;
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.getSimple(GetSimpleArgs.builder()
            .id("simple1")
            .build());

        ctx.export("dataProxmoxVirtualEnvironmentSdnZoneSimple", Map.ofEntries(
            Map.entry("id", example.id()),
            Map.entry("nodes", example.nodes()),
            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:getSimple
      arguments:
        id: simple1
outputs:
  dataProxmoxVirtualEnvironmentSdnZoneSimple:
    id: ${example.id}
    nodes: ${example.nodes}
    mtu: ${example.mtu}
    dns: ${example.dns}
    dns_zone: ${example.dnsZone}
    ipam: ${example.ipam}
    reverse_dns: ${example.reverseDns}

function getSimple(args: GetSimpleArgs, opts?: InvokeOptions): Promise<GetSimpleResult>
function getSimpleOutput(args: GetSimpleOutputArgs, opts?: InvokeOptions): Output<GetSimpleResult>

def get_simple(id: Optional[str] = None,
               opts: Optional[InvokeOptions] = None) -> GetSimpleResult
def get_simple_output(id: Optional[pulumi.Input[str]] = None,
               opts: Optional[InvokeOptions] = None) -> Output[GetSimpleResult]

func LookupSimple(ctx *Context, args *LookupSimpleArgs, opts ...InvokeOption) (*LookupSimpleResult, error)
func LookupSimpleOutput(ctx *Context, args *LookupSimpleOutputArgs, opts ...InvokeOption) LookupSimpleResultOutput

public static class GetSimple 
{
    public static Task<GetSimpleResult> InvokeAsync(GetSimpleArgs args, InvokeOptions? opts = null)
    public static Output<GetSimpleResult> Invoke(GetSimpleInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetSimpleResult> getSimple(GetSimpleArgs args, InvokeOptions options)
public static Output<GetSimpleResult> getSimple(GetSimpleArgs args, InvokeOptions options)

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