proxmoxve.Hardware.getMappings

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

const example-pci = proxmoxve.Hardware.getMappings({
    checkNode: "pve",
    type: "pci",
});
const example-usb = proxmoxve.Hardware.getMappings({
    checkNode: "pve",
    type: "usb",
});
export const dataProxmoxVirtualEnvironmentHardwareMappingsPci = example_pci;
export const dataProxmoxVirtualEnvironmentHardwareMappingsUsb = example_usb;

import pulumi
import pulumi_proxmoxve as proxmoxve

example_pci = proxmoxve.Hardware.get_mappings(check_node="pve",
    type="pci")
example_usb = proxmoxve.Hardware.get_mappings(check_node="pve",
    type="usb")
pulumi.export("dataProxmoxVirtualEnvironmentHardwareMappingsPci", example_pci)
pulumi.export("dataProxmoxVirtualEnvironmentHardwareMappingsUsb", example_usb)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example_pci, err := Hardware.GetMappings(ctx, &hardware.GetMappingsArgs{
			CheckNode: pulumi.StringRef("pve"),
			Type:      "pci",
		}, nil)
		if err != nil {
			return err
		}
		example_usb, err := Hardware.GetMappings(ctx, &hardware.GetMappingsArgs{
			CheckNode: pulumi.StringRef("pve"),
			Type:      "usb",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("dataProxmoxVirtualEnvironmentHardwareMappingsPci", example_pci)
		ctx.Export("dataProxmoxVirtualEnvironmentHardwareMappingsUsb", example_usb)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example_pci = ProxmoxVE.Hardware.GetMappings.Invoke(new()
    {
        CheckNode = "pve",
        Type = "pci",
    });

    var example_usb = ProxmoxVE.Hardware.GetMappings.Invoke(new()
    {
        CheckNode = "pve",
        Type = "usb",
    });

    return new Dictionary<string, object?>
    {
        ["dataProxmoxVirtualEnvironmentHardwareMappingsPci"] = example_pci,
        ["dataProxmoxVirtualEnvironmentHardwareMappingsUsb"] = example_usb,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.proxmoxve.Hardware.HardwareFunctions;
import com.pulumi.proxmoxve.Hardware.inputs.GetMappingsArgs;
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-pci = HardwareFunctions.getMappings(GetMappingsArgs.builder()
            .checkNode("pve")
            .type("pci")
            .build());

        final var example-usb = HardwareFunctions.getMappings(GetMappingsArgs.builder()
            .checkNode("pve")
            .type("usb")
            .build());

        ctx.export("dataProxmoxVirtualEnvironmentHardwareMappingsPci", example_pci);
        ctx.export("dataProxmoxVirtualEnvironmentHardwareMappingsUsb", example_usb);
    }
}

variables:
  example-pci:
    fn::invoke:
      Function: proxmoxve:Hardware:getMappings
      Arguments:
        checkNode: pve
        type: pci
  example-usb:
    fn::invoke:
      Function: proxmoxve:Hardware:getMappings
      Arguments:
        checkNode: pve
        type: usb
outputs:
  dataProxmoxVirtualEnvironmentHardwareMappingsPci: ${["example-pci"]}
  dataProxmoxVirtualEnvironmentHardwareMappingsUsb: ${["example-usb"]}

function getMappings(args: GetMappingsArgs, opts?: InvokeOptions): Promise<GetMappingsResult>
function getMappingsOutput(args: GetMappingsOutputArgs, opts?: InvokeOptions): Output<GetMappingsResult>

def get_mappings(check_node: Optional[str] = None,
                 type: Optional[str] = None,
                 opts: Optional[InvokeOptions] = None) -> GetMappingsResult
def get_mappings_output(check_node: Optional[pulumi.Input[str]] = None,
                 type: Optional[pulumi.Input[str]] = None,
                 opts: Optional[InvokeOptions] = None) -> Output[GetMappingsResult]

func GetMappings(ctx *Context, args *GetMappingsArgs, opts ...InvokeOption) (*GetMappingsResult, error)
func GetMappingsOutput(ctx *Context, args *GetMappingsOutputArgs, opts ...InvokeOption) GetMappingsResultOutput

public static class GetMappings 
{
    public static Task<GetMappingsResult> InvokeAsync(GetMappingsArgs args, InvokeOptions? opts = null)
    public static Output<GetMappingsResult> Invoke(GetMappingsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetMappingsResult> getMappings(GetMappingsArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: proxmoxve:Hardware/getMappings:getMappings
  arguments:
    # arguments dictionary