vkcs.getKubernetesClustertemplates

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

const templates = vkcs.getKubernetesClustertemplates({});
export const availableTemplatesByName = templates.then(templates => .map(template => ({
    name: template.name,
    version: template.version,
})));

import pulumi
import pulumi_vkcs as vkcs

templates = vkcs.get_kubernetes_clustertemplates()
pulumi.export("availableTemplatesByName", [{
    "name": template.name,
    "version": template.version,
} for template in templates.cluster_templates])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		templates, err := vkcs.GetKubernetesClustertemplates(ctx, &vkcs.GetKubernetesClustertemplatesArgs{}, nil)
		if err != nil {
			return err
		}
		ctx.Export("availableTemplatesByName", pulumi.StringMapArray("TODO: For expression"))
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var templates = Vkcs.GetKubernetesClustertemplates.Invoke();

    return new Dictionary<string, object?>
    {
        ["availableTemplatesByName"] = .Select(template => 
        {
            return 
            {
                { "name", template.Name },
                { "version", template.Version },
            };
        }).ToList(),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vkcs.VkcsFunctions;
import com.pulumi.vkcs.inputs.GetKubernetesClustertemplatesArgs;
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 templates = VkcsFunctions.getKubernetesClustertemplates();

        ctx.export("availableTemplatesByName", "TODO: ForExpression");
    }
}

function getKubernetesClustertemplates(args: GetKubernetesClustertemplatesArgs, opts?: InvokeOptions): Promise<GetKubernetesClustertemplatesResult>
function getKubernetesClustertemplatesOutput(args: GetKubernetesClustertemplatesOutputArgs, opts?: InvokeOptions): Output<GetKubernetesClustertemplatesResult>

def get_kubernetes_clustertemplates(region: Optional[str] = None,
                                    opts: Optional[InvokeOptions] = None) -> GetKubernetesClustertemplatesResult
def get_kubernetes_clustertemplates_output(region: Optional[pulumi.Input[str]] = None,
                                    opts: Optional[InvokeOptions] = None) -> Output[GetKubernetesClustertemplatesResult]

func GetKubernetesClustertemplates(ctx *Context, args *GetKubernetesClustertemplatesArgs, opts ...InvokeOption) (*GetKubernetesClustertemplatesResult, error)
func GetKubernetesClustertemplatesOutput(ctx *Context, args *GetKubernetesClustertemplatesOutputArgs, opts ...InvokeOption) GetKubernetesClustertemplatesResultOutput

public static class GetKubernetesClustertemplates 
{
    public static Task<GetKubernetesClustertemplatesResult> InvokeAsync(GetKubernetesClustertemplatesArgs args, InvokeOptions? opts = null)
    public static Output<GetKubernetesClustertemplatesResult> Invoke(GetKubernetesClustertemplatesInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetKubernetesClustertemplatesResult> getKubernetesClustertemplates(GetKubernetesClustertemplatesArgs args, InvokeOptions options)
public static Output<GetKubernetesClustertemplatesResult> getKubernetesClustertemplates(GetKubernetesClustertemplatesArgs args, InvokeOptions options)

fn::invoke:
  function: vkcs:index/getKubernetesClustertemplates:getKubernetesClustertemplates
  arguments:
    # arguments dictionary