talos.imageFactory.getExtensionsVersions

import * as pulumi from "@pulumi/pulumi";
import * as talos from "@pulumiverse/talos";

const _this = talos.imageFactory.getExtensionsVersions({
    talosVersion: "v1.7.5",
    filters: {
        names: [
            "amdgpu",
            "tailscale",
        ],
    },
});

import pulumi
import pulumi_talos as talos

this = talos.imageFactory.get_extensions_versions(talos_version="v1.7.5",
    filters={
        "names": [
            "amdgpu",
            "tailscale",
        ],
    })

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-talos/sdk/go/talos/imagefactory"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := imagefactory.GetExtensionsVersions(ctx, &imagefactory.GetExtensionsVersionsArgs{
			TalosVersion: "v1.7.5",
			Filters: imagefactory.GetExtensionsVersionsFilters{
				Names: []string{
					"amdgpu",
					"tailscale",
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var @this = Talos.ImageFactory.GetExtensionsVersions.Invoke(new()
    {
        TalosVersion = "v1.7.5",
        Filters = new Talos.ImageFactory.Inputs.GetExtensionsVersionsFiltersInputArgs
        {
            Names = new[]
            {
                "amdgpu",
                "tailscale",
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.talos.imageFactory.ImageFactoryFunctions;
import com.pulumi.talos.imageFactory.inputs.GetExtensionsVersionsArgs;
import com.pulumi.talos.imageFactory.inputs.GetExtensionsVersionsFiltersArgs;
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 this = ImageFactoryFunctions.getExtensionsVersions(GetExtensionsVersionsArgs.builder()
            .talosVersion("v1.7.5")
            .filters(GetExtensionsVersionsFiltersArgs.builder()
                .names(                
                    "amdgpu",
                    "tailscale")
                .build())
            .build());

    }
}

variables:
  this:
    fn::invoke:
      function: talos:imageFactory:getExtensionsVersions
      arguments:
        talosVersion: v1.7.5
        filters:
          names:
            - amdgpu
            - tailscale

function getExtensionsVersions(args: GetExtensionsVersionsArgs, opts?: InvokeOptions): Promise<GetExtensionsVersionsResult>
function getExtensionsVersionsOutput(args: GetExtensionsVersionsOutputArgs, opts?: InvokeOptions): Output<GetExtensionsVersionsResult>

def get_extensions_versions(exact_filters: Optional[GetExtensionsVersionsExactFilters] = None,
                            filters: Optional[GetExtensionsVersionsFilters] = None,
                            talos_version: Optional[str] = None,
                            opts: Optional[InvokeOptions] = None) -> GetExtensionsVersionsResult
def get_extensions_versions_output(exact_filters: Optional[pulumi.Input[GetExtensionsVersionsExactFiltersArgs]] = None,
                            filters: Optional[pulumi.Input[GetExtensionsVersionsFiltersArgs]] = None,
                            talos_version: Optional[pulumi.Input[str]] = None,
                            opts: Optional[InvokeOptions] = None) -> Output[GetExtensionsVersionsResult]

func GetExtensionsVersions(ctx *Context, args *GetExtensionsVersionsArgs, opts ...InvokeOption) (*GetExtensionsVersionsResult, error)
func GetExtensionsVersionsOutput(ctx *Context, args *GetExtensionsVersionsOutputArgs, opts ...InvokeOption) GetExtensionsVersionsResultOutput

public static class GetExtensionsVersions 
{
    public static Task<GetExtensionsVersionsResult> InvokeAsync(GetExtensionsVersionsArgs args, InvokeOptions? opts = null)
    public static Output<GetExtensionsVersionsResult> Invoke(GetExtensionsVersionsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetExtensionsVersionsResult> getExtensionsVersions(GetExtensionsVersionsArgs args, InvokeOptions options)
public static Output<GetExtensionsVersionsResult> getExtensionsVersions(GetExtensionsVersionsArgs args, InvokeOptions options)

fn::invoke:
  function: talos:imageFactory/getExtensionsVersions:getExtensionsVersions
  arguments:
    # arguments dictionary