proxmoxve.getReplication

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

const example = proxmoxve.getReplication({
    id: "100-0",
});
export const dataProxmoxReplication = {
    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(id="100-0")
pulumi.export("dataProxmoxReplication", {
    "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.GetReplication(ctx, &proxmoxve.LookupReplicationArgs{
			Id: "100-0",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("dataProxmoxReplication", 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.GetReplication.Invoke(new()
    {
        Id = "100-0",
    });

    return new Dictionary<string, object?>
    {
        ["dataProxmoxReplication"] = 
        {
            { "id", example.Apply(getReplicationResult => getReplicationResult.Id) },
            { "target", example.Apply(getReplicationResult => getReplicationResult.Target) },
            { "type", example.Apply(getReplicationResult => getReplicationResult.Type) },
            { "jobnum", example.Apply(getReplicationResult => getReplicationResult.Jobnum) },
            { "guest", example.Apply(getReplicationResult => getReplicationResult.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.GetReplicationArgs;
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.getReplication(GetReplicationArgs.builder()
            .id("100-0")
            .build());

        ctx.export("dataProxmoxReplication", 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:getReplication
      arguments:
        id: 100-0
outputs:
  dataProxmoxReplication:
    id: ${example.id}
    target: ${example.target}
    type: ${example.type}
    jobnum: ${example.jobnum}
    guest: ${example.guest}

function getReplication(args: GetReplicationArgs, opts?: InvokeOptions): Promise<GetReplicationResult>
function getReplicationOutput(args: GetReplicationOutputArgs, opts?: InvokeOptions): Output<GetReplicationResult>

def get_replication(id: Optional[str] = None,
                    opts: Optional[InvokeOptions] = None) -> GetReplicationResult
def get_replication_output(id: Optional[pulumi.Input[str]] = None,
                    opts: Optional[InvokeOptions] = None) -> Output[GetReplicationResult]

func LookupReplication(ctx *Context, args *LookupReplicationArgs, opts ...InvokeOption) (*LookupReplicationResult, error)
func LookupReplicationOutput(ctx *Context, args *LookupReplicationOutputArgs, opts ...InvokeOption) LookupReplicationResultOutput

public static class GetReplication 
{
    public static Task<GetReplicationResult> InvokeAsync(GetReplicationArgs args, InvokeOptions? opts = null)
    public static Output<GetReplicationResult> Invoke(GetReplicationInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetReplicationResult> getReplication(GetReplicationArgs args, InvokeOptions options)
public static Output<GetReplicationResult> getReplication(GetReplicationArgs args, InvokeOptions options)

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