proxmoxve.Network.getVersion

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

const example = proxmoxve.Network.getVersion({});
export const dataProxmoxVirtualEnvironmentVersion = {
    release: example.then(example => example.release),
    repository_id: example.then(example => example.repositoryId),
    version: example.then(example => example.version),
};

import pulumi
import pulumi_proxmoxve as proxmoxve

example = proxmoxve.Network.get_version()
pulumi.export("dataProxmoxVirtualEnvironmentVersion", {
    "release": example.release,
    "repository_id": example.repository_id,
    "version": example.version,
})

package main

import (
	"github.com/muhlba91/pulumi-proxmoxve/sdk/v6/go/proxmoxve/Network"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := Network.GetVersion(ctx, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		ctx.Export("dataProxmoxVirtualEnvironmentVersion", pulumi.StringMap{
			"release":       example.Release,
			"repository_id": example.RepositoryId,
			"version":       example.Version,
		})
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = ProxmoxVE.Network.GetVersion.Invoke();

    return new Dictionary<string, object?>
    {
        ["dataProxmoxVirtualEnvironmentVersion"] = 
        {
            { "release", example.Apply(getVersionResult => getVersionResult.Release) },
            { "repository_id", example.Apply(getVersionResult => getVersionResult.RepositoryId) },
            { "version", example.Apply(getVersionResult => getVersionResult.Version) },
        },
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.proxmoxve.Network.NetworkFunctions;
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 = NetworkFunctions.getVersion();

        ctx.export("dataProxmoxVirtualEnvironmentVersion", %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference));
    }
}

variables:
  example:
    fn::invoke:
      Function: proxmoxve:Network:getVersion
      Arguments: {}
outputs:
  dataProxmoxVirtualEnvironmentVersion:
    release: ${example.release}
    repository_id: ${example.repositoryId}
    version: ${example.version}

function getVersion(opts?: InvokeOptions): Promise<GetVersionResult>
function getVersionOutput(opts?: InvokeOptions): Output<GetVersionResult>

def get_version(opts: Optional[InvokeOptions] = None) -> GetVersionResult
def get_version_output(opts: Optional[InvokeOptions] = None) -> Output[GetVersionResult]

func GetVersion(ctx *Context, opts ...InvokeOption) (*GetVersionResult, error)
func GetVersionOutput(ctx *Context, opts ...InvokeOption) GetVersionResultOutput

public static class GetVersion 
{
    public static Task<GetVersionResult> InvokeAsync(InvokeOptions? opts = null)
    public static Output<GetVersionResult> Invoke(InvokeOptions? opts = null)
}

public static CompletableFuture<GetVersionResult> getVersion(InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: proxmoxve:Network/getVersion:getVersion
  arguments:
    # arguments dictionary