proxmoxve.getReplicationLegacy

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

const example = proxmoxve.getReplicationLegacy({
    id: "100-0",
});
export const dataProxmoxVirtualEnvironmentReplication = {
    id: example.then(example => example.id),
    target: example.then(example => example.target),
    type: example.then(example => example.type),
    jobnum: example.then(example => example.jobnum),
    guest: example.then(example => example.guest),
};

import pulumi
import pulumi_proxmoxve as proxmoxve

example = proxmoxve.get_replication_legacy(id="100-0")
pulumi.export("dataProxmoxVirtualEnvironmentReplication", {
    "id": example.id,
    "target": example.target,
    "type": example.type,
    "jobnum": example.jobnum,
    "guest": example.guest,
})

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := proxmoxve.GetReplicationLegacy(ctx, &proxmoxve.LookupReplicationLegacyArgs{
			Id: "100-0",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("dataProxmoxVirtualEnvironmentReplication", pulumi.Map{
			"id":     example.Id,
			"target": example.Target,
			"type":   example.Type,
			"jobnum": example.Jobnum,
			"guest":  example.Guest,
		})
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = ProxmoxVE.Index.GetReplicationLegacy.Invoke(new()
    {
        Id = "100-0",
    });

    return new Dictionary<string, object?>
    {
        ["dataProxmoxVirtualEnvironmentReplication"] = 
        {
            { "id", example.Apply(getReplicationLegacyResult => getReplicationLegacyResult.Id) },
            { "target", example.Apply(getReplicationLegacyResult => getReplicationLegacyResult.Target) },
            { "type", example.Apply(getReplicationLegacyResult => getReplicationLegacyResult.Type) },
            { "jobnum", example.Apply(getReplicationLegacyResult => getReplicationLegacyResult.Jobnum) },
            { "guest", example.Apply(getReplicationLegacyResult => getReplicationLegacyResult.Guest) },
        },
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.proxmoxve.ProxmoxveFunctions;
import com.pulumi.proxmoxve.inputs.GetReplicationLegacyArgs;
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 = ProxmoxveFunctions.getReplicationLegacy(GetReplicationLegacyArgs.builder()
            .id("100-0")
            .build());

        ctx.export("dataProxmoxVirtualEnvironmentReplication", Map.ofEntries(
            Map.entry("id", example.id()),
            Map.entry("target", example.target()),
            Map.entry("type", example.type()),
            Map.entry("jobnum", example.jobnum()),
            Map.entry("guest", example.guest())
        ));
    }
}

variables:
  example:
    fn::invoke:
      function: proxmoxve:getReplicationLegacy
      arguments:
        id: 100-0
outputs:
  dataProxmoxVirtualEnvironmentReplication:
    id: ${example.id}
    target: ${example.target}
    type: ${example.type}
    jobnum: ${example.jobnum}
    guest: ${example.guest}

function getReplicationLegacy(args: GetReplicationLegacyArgs, opts?: InvokeOptions): Promise<GetReplicationLegacyResult>
function getReplicationLegacyOutput(args: GetReplicationLegacyOutputArgs, opts?: InvokeOptions): Output<GetReplicationLegacyResult>

def get_replication_legacy(id: Optional[str] = None,
                           opts: Optional[InvokeOptions] = None) -> GetReplicationLegacyResult
def get_replication_legacy_output(id: Optional[pulumi.Input[str]] = None,
                           opts: Optional[InvokeOptions] = None) -> Output[GetReplicationLegacyResult]

func LookupReplicationLegacy(ctx *Context, args *LookupReplicationLegacyArgs, opts ...InvokeOption) (*LookupReplicationLegacyResult, error)
func LookupReplicationLegacyOutput(ctx *Context, args *LookupReplicationLegacyOutputArgs, opts ...InvokeOption) LookupReplicationLegacyResultOutput

public static class GetReplicationLegacy 
{
    public static Task<GetReplicationLegacyResult> InvokeAsync(GetReplicationLegacyArgs args, InvokeOptions? opts = null)
    public static Output<GetReplicationLegacyResult> Invoke(GetReplicationLegacyInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetReplicationLegacyResult> getReplicationLegacy(GetReplicationLegacyArgs args, InvokeOptions options)
public static Output<GetReplicationLegacyResult> getReplicationLegacy(GetReplicationLegacyArgs args, InvokeOptions options)

fn::invoke:
  function: proxmoxve:index/getReplicationLegacy:getReplicationLegacy
  arguments:
    # arguments dictionary