hpegl.getMetalAvailableImages

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

const centos = hpegl.getMetalAvailableImages({
    filters: [
        {
            name: "flavor",
            values: ["(?i)centos"],
        },
        {
            name: "version",
            values: ["7.6.*"],
        },
    ],
});
export const images = data.hpegl_metal_available_images.ubuntu.images;

import pulumi
import pulumi_hpegl as hpegl

centos = hpegl.get_metal_available_images(filters=[
    {
        "name": "flavor",
        "values": ["(?i)centos"],
    },
    {
        "name": "version",
        "values": ["7.6.*"],
    },
])
pulumi.export("images", data["hpegl_metal_available_images"]["ubuntu"]["images"])

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 {
		_, err := hpegl.GetMetalAvailableImages(ctx, &hpegl.GetMetalAvailableImagesArgs{
			Filters: []hpegl.GetMetalAvailableImagesFilter{
				{
					Name: "flavor",
					Values: []string{
						"(?i)centos",
					},
				},
				{
					Name: "version",
					Values: []string{
						"7.6.*",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("images", data.Hpegl_metal_available_images.Ubuntu.Images)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var centos = Hpegl.GetMetalAvailableImages.Invoke(new()
    {
        Filters = new[]
        {
            new Hpegl.Inputs.GetMetalAvailableImagesFilterInputArgs
            {
                Name = "flavor",
                Values = new[]
                {
                    "(?i)centos",
                },
            },
            new Hpegl.Inputs.GetMetalAvailableImagesFilterInputArgs
            {
                Name = "version",
                Values = new[]
                {
                    "7.6.*",
                },
            },
        },
    });

    return new Dictionary<string, object?>
    {
        ["images"] = data.Hpegl_metal_available_images.Ubuntu.Images,
    };
});

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.GetMetalAvailableImagesArgs;
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 centos = HpeglFunctions.getMetalAvailableImages(GetMetalAvailableImagesArgs.builder()
            .filters(            
                GetMetalAvailableImagesFilterArgs.builder()
                    .name("flavor")
                    .values("(?i)centos")
                    .build(),
                GetMetalAvailableImagesFilterArgs.builder()
                    .name("version")
                    .values("7.6.*")
                    .build())
            .build());

        ctx.export("images", data.hpegl_metal_available_images().ubuntu().images());
    }
}

variables:
  centos:
    fn::invoke:
      function: hpegl:getMetalAvailableImages
      arguments:
        filters:
          - name: flavor
            values:
              - (?i)centos
          - name: version
            values:
              - 7.6.*
outputs:
  images: ${data.hpegl_metal_available_images.ubuntu.images}

function getMetalAvailableImages(args: GetMetalAvailableImagesArgs, opts?: InvokeOptions): Promise<GetMetalAvailableImagesResult>
function getMetalAvailableImagesOutput(args: GetMetalAvailableImagesOutputArgs, opts?: InvokeOptions): Output<GetMetalAvailableImagesResult>

def get_metal_available_images(filters: Optional[Sequence[GetMetalAvailableImagesFilter]] = None,
                               id: Optional[str] = None,
                               opts: Optional[InvokeOptions] = None) -> GetMetalAvailableImagesResult
def get_metal_available_images_output(filters: Optional[pulumi.Input[Sequence[pulumi.Input[GetMetalAvailableImagesFilterArgs]]]] = None,
                               id: Optional[pulumi.Input[str]] = None,
                               opts: Optional[InvokeOptions] = None) -> Output[GetMetalAvailableImagesResult]

func GetMetalAvailableImages(ctx *Context, args *GetMetalAvailableImagesArgs, opts ...InvokeOption) (*GetMetalAvailableImagesResult, error)
func GetMetalAvailableImagesOutput(ctx *Context, args *GetMetalAvailableImagesOutputArgs, opts ...InvokeOption) GetMetalAvailableImagesResultOutput

public static class GetMetalAvailableImages 
{
    public static Task<GetMetalAvailableImagesResult> InvokeAsync(GetMetalAvailableImagesArgs args, InvokeOptions? opts = null)
    public static Output<GetMetalAvailableImagesResult> Invoke(GetMetalAvailableImagesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetMetalAvailableImagesResult> getMetalAvailableImages(GetMetalAvailableImagesArgs args, InvokeOptions options)
public static Output<GetMetalAvailableImagesResult> getMetalAvailableImages(GetMetalAvailableImagesArgs args, InvokeOptions options)

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