hpegl.getMetalAvailableResources

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

export = async () => {
    const physical = await hpegl.getMetalAvailableResources({});
    return {
        locations: physical.locations,
        images: physical.images,
        "ssh-keys": physical.sshKeys,
        networks: .filter(net => net.location == _var.location).map(net => (net)),
        volumes: .filter(vol => vol.location == _var.location).map(vol => (vol)),
        "volume-flavors": physical.volumeFlavors,
        "machine-sizes": physical.machineSizes,
        "storage-pools": physical.storagePools,
        "volume-collections": physical.volumeCollections,
    };
}

import pulumi
import pulumi_hpegl as hpegl

physical = hpegl.get_metal_available_resources()
pulumi.export("locations", physical.locations)
pulumi.export("images", physical.images)
pulumi.export("ssh-keys", physical.ssh_keys)
pulumi.export("networks", [net for net in physical.networks if net.location == var["location"]])
pulumi.export("volumes", [vol for vol in physical.volumes if vol.location == var["location"]])
pulumi.export("volume-flavors", physical.volume_flavors)
pulumi.export("machine-sizes", physical.machine_sizes)
pulumi.export("storage-pools", physical.storage_pools)
pulumi.export("volume-collections", physical.volume_collections)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/hpegl/hpegl"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		physical, err := hpegl.GetMetalAvailableResources(ctx, &hpegl.GetMetalAvailableResourcesArgs{}, nil)
		if err != nil {
			return err
		}
		ctx.Export("locations", physical.Locations)
		ctx.Export("images", physical.Images)
		ctx.Export("ssh-keys", physical.SshKeys)
		ctx.Export("networks", []hpegl.GetMetalAvailableResourcesNetwork("TODO: For expression"))
		ctx.Export("volumes", []hpegl.GetMetalAvailableResourcesVolume("TODO: For expression"))
		ctx.Export("volume-flavors", physical.VolumeFlavors)
		ctx.Export("machine-sizes", physical.MachineSizes)
		ctx.Export("storage-pools", physical.StoragePools)
		ctx.Export("volume-collections", physical.VolumeCollections)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var physical = Hpegl.GetMetalAvailableResources.Invoke();

    return new Dictionary<string, object?>
    {
        ["locations"] = physical.Apply(getMetalAvailableResourcesResult => getMetalAvailableResourcesResult.Locations),
        ["images"] = physical.Apply(getMetalAvailableResourcesResult => getMetalAvailableResourcesResult.Images),
        ["ssh-keys"] = physical.Apply(getMetalAvailableResourcesResult => getMetalAvailableResourcesResult.SshKeys),
        ["networks"] = .Where(net => net.Location == @var.Location).Select(net => 
        {
            return net;
        }).ToList(),
        ["volumes"] = .Where(vol => vol.Location == @var.Location).Select(vol => 
        {
            return vol;
        }).ToList(),
        ["volume-flavors"] = physical.Apply(getMetalAvailableResourcesResult => getMetalAvailableResourcesResult.VolumeFlavors),
        ["machine-sizes"] = physical.Apply(getMetalAvailableResourcesResult => getMetalAvailableResourcesResult.MachineSizes),
        ["storage-pools"] = physical.Apply(getMetalAvailableResourcesResult => getMetalAvailableResourcesResult.StoragePools),
        ["volume-collections"] = physical.Apply(getMetalAvailableResourcesResult => getMetalAvailableResourcesResult.VolumeCollections),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.hpegl.HpeglFunctions;
import com.pulumi.hpegl.inputs.GetMetalAvailableResourcesArgs;
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 physical = HpeglFunctions.getMetalAvailableResources();

        ctx.export("locations", physical.applyValue(getMetalAvailableResourcesResult -> getMetalAvailableResourcesResult.locations()));
        ctx.export("images", physical.applyValue(getMetalAvailableResourcesResult -> getMetalAvailableResourcesResult.images()));
        ctx.export("ssh-keys", physical.applyValue(getMetalAvailableResourcesResult -> getMetalAvailableResourcesResult.sshKeys()));
        ctx.export("networks", "TODO: ForExpression");
        ctx.export("volumes", "TODO: ForExpression");
        ctx.export("volume-flavors", physical.applyValue(getMetalAvailableResourcesResult -> getMetalAvailableResourcesResult.volumeFlavors()));
        ctx.export("machine-sizes", physical.applyValue(getMetalAvailableResourcesResult -> getMetalAvailableResourcesResult.machineSizes()));
        ctx.export("storage-pools", physical.applyValue(getMetalAvailableResourcesResult -> getMetalAvailableResourcesResult.storagePools()));
        ctx.export("volume-collections", physical.applyValue(getMetalAvailableResourcesResult -> getMetalAvailableResourcesResult.volumeCollections()));
    }
}

function getMetalAvailableResources(args: GetMetalAvailableResourcesArgs, opts?: InvokeOptions): Promise<GetMetalAvailableResourcesResult>
function getMetalAvailableResourcesOutput(args: GetMetalAvailableResourcesOutputArgs, opts?: InvokeOptions): Output<GetMetalAvailableResourcesResult>

def get_metal_available_resources(filters: Optional[Sequence[GetMetalAvailableResourcesFilter]] = None,
                                  id: Optional[str] = None,
                                  opts: Optional[InvokeOptions] = None) -> GetMetalAvailableResourcesResult
def get_metal_available_resources_output(filters: Optional[pulumi.Input[Sequence[pulumi.Input[GetMetalAvailableResourcesFilterArgs]]]] = None,
                                  id: Optional[pulumi.Input[str]] = None,
                                  opts: Optional[InvokeOptions] = None) -> Output[GetMetalAvailableResourcesResult]

func GetMetalAvailableResources(ctx *Context, args *GetMetalAvailableResourcesArgs, opts ...InvokeOption) (*GetMetalAvailableResourcesResult, error)
func GetMetalAvailableResourcesOutput(ctx *Context, args *GetMetalAvailableResourcesOutputArgs, opts ...InvokeOption) GetMetalAvailableResourcesResultOutput

public static class GetMetalAvailableResources 
{
    public static Task<GetMetalAvailableResourcesResult> InvokeAsync(GetMetalAvailableResourcesArgs args, InvokeOptions? opts = null)
    public static Output<GetMetalAvailableResourcesResult> Invoke(GetMetalAvailableResourcesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetMetalAvailableResourcesResult> getMetalAvailableResources(GetMetalAvailableResourcesArgs args, InvokeOptions options)
public static Output<GetMetalAvailableResourcesResult> getMetalAvailableResources(GetMetalAvailableResourcesArgs args, InvokeOptions options)

fn::invoke:
  function: hpegl:index/getMetalAvailableResources:getMetalAvailableResources
  arguments:
    # arguments dictionary