cilium.getHelmValues

import * as pulumi from "@pulumi/pulumi";
import * as cilium from "@littlejo/cilium";
import * as local from "@pulumi/local";

const exampleHelmValues = cilium.getHelmValues({});
const exampleFile = new local.File("exampleFile", {
    content: exampleHelmValues.then(exampleHelmValues => exampleHelmValues.yaml),
    filename: `${path.module}/values.yaml`,
});

import pulumi
import pulumi_cilium as cilium
import pulumi_local as local

example_helm_values = cilium.get_helm_values()
example_file = local.File("exampleFile",
    content=example_helm_values.yaml,
    filename=f"{path['module']}/values.yaml")

package main

import (
	"fmt"

	"github.com/littlejo/pulumi-cilium/sdk/go/cilium"
	"github.com/pulumi/pulumi-local/sdk/go/local"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleHelmValues, err := cilium.GetHelmValues(ctx, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		_, err = local.NewFile(ctx, "exampleFile", &local.FileArgs{
			Content:  pulumi.String(exampleHelmValues.Yaml),
			Filename: pulumi.Sprintf("%v/values.yaml", path.Module),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Cilium = Pulumi.Cilium;
using Local = Pulumi.Local;

return await Deployment.RunAsync(() => 
{
    var exampleHelmValues = Cilium.GetHelmValues.Invoke();

    var exampleFile = new Local.File("exampleFile", new()
    {
        Content = exampleHelmValues.Apply(getHelmValuesResult => getHelmValuesResult.Yaml),
        Filename = $"{path.Module}/values.yaml",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.cilium.CiliumFunctions;
import com.pulumi.local.File;
import com.pulumi.local.FileArgs;
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 exampleHelmValues = CiliumFunctions.getHelmValues(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference);

        var exampleFile = new File("exampleFile", FileArgs.builder()
            .content(exampleHelmValues.yaml())
            .filename(String.format("%s/values.yaml", path.module()))
            .build());

    }
}

resources:
  exampleFile:
    type: local:File
    properties:
      content: ${exampleHelmValues.yaml}
      filename: ${path.module}/values.yaml
variables:
  exampleHelmValues:
    fn::invoke:
      function: cilium:getHelmValues
      arguments: {}

function getHelmValues(opts?: InvokeOptions): Promise<GetHelmValuesResult>
function getHelmValuesOutput(opts?: InvokeOptions): Output<GetHelmValuesResult>

def get_helm_values(opts: Optional[InvokeOptions] = None) -> GetHelmValuesResult
def get_helm_values_output(opts: Optional[InvokeOptions] = None) -> Output[GetHelmValuesResult]

func GetHelmValues(ctx *Context, opts ...InvokeOption) (*GetHelmValuesResult, error)
func GetHelmValuesOutput(ctx *Context, opts ...InvokeOption) GetHelmValuesResultOutput

public static class GetHelmValues 
{
    public static Task<GetHelmValuesResult> InvokeAsync(InvokeOptions? opts = null)
    public static Output<GetHelmValuesResult> Invoke(InvokeOptions? opts = null)
}

public static CompletableFuture<GetHelmValuesResult> getHelmValues(InvokeOptions options)
public static Output<GetHelmValuesResult> getHelmValues(InvokeOptions options)

fn::invoke:
  function: cilium:index/getHelmValues:getHelmValues
  arguments:
    # arguments dictionary