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

// Example:
const myFlow = new auth0.Flow("my_flow", {
    actions: JSON.stringify([{
        action: "UPDATE_USER",
        alias: "user meta data",
        allow_failure: false,
        id: "update_user_PmSa",
        mask_output: false,
        params: {
            changes: {
                user_metadata: {
                    full_name: "{{fields.full_name}}",
                },
            },
            connection_id: "<vault_connection_id>",
            user_id: "{{context.user.user_id}}",
        },
        type: "AUTH0",
    }]),
    name: "Flow KYC update data",
});

import pulumi
import json
import pulumi_auth0 as auth0

# Example:
my_flow = auth0.Flow("my_flow",
    actions=json.dumps([{
        "action": "UPDATE_USER",
        "alias": "user meta data",
        "allow_failure": False,
        "id": "update_user_PmSa",
        "mask_output": False,
        "params": {
            "changes": {
                "user_metadata": {
                    "full_name": "{{fields.full_name}}",
                },
            },
            "connection_id": "<vault_connection_id>",
            "user_id": "{{context.user.user_id}}",
        },
        "type": "AUTH0",
    }]),
    name="Flow KYC update data")

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-auth0/sdk/v3/go/auth0"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal([]map[string]interface{}{
			map[string]interface{}{
				"action":        "UPDATE_USER",
				"alias":         "user meta data",
				"allow_failure": false,
				"id":            "update_user_PmSa",
				"mask_output":   false,
				"params": map[string]interface{}{
					"changes": map[string]interface{}{
						"user_metadata": map[string]interface{}{
							"full_name": "{{fields.full_name}}",
						},
					},
					"connection_id": "<vault_connection_id>",
					"user_id":       "{{context.user.user_id}}",
				},
				"type": "AUTH0",
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		// Example:
		_, err = auth0.NewFlow(ctx, "my_flow", &auth0.FlowArgs{
			Actions: pulumi.String(json0),
			Name:    pulumi.String("Flow KYC update data"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Auth0 = Pulumi.Auth0;

return await Deployment.RunAsync(() => 
{
    // Example:
    var myFlow = new Auth0.Flow("my_flow", new()
    {
        Actions = JsonSerializer.Serialize(new[]
        {
            new Dictionary<string, object?>
            {
                ["action"] = "UPDATE_USER",
                ["alias"] = "user meta data",
                ["allow_failure"] = false,
                ["id"] = "update_user_PmSa",
                ["mask_output"] = false,
                ["params"] = new Dictionary<string, object?>
                {
                    ["changes"] = new Dictionary<string, object?>
                    {
                        ["user_metadata"] = new Dictionary<string, object?>
                        {
                            ["full_name"] = "{{fields.full_name}}",
                        },
                    },
                    ["connection_id"] = "<vault_connection_id>",
                    ["user_id"] = "{{context.user.user_id}}",
                },
                ["type"] = "AUTH0",
            },
        }),
        Name = "Flow KYC update data",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.auth0.Flow;
import com.pulumi.auth0.FlowArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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) {
        // Example:
        var myFlow = new Flow("myFlow", FlowArgs.builder()
            .actions(serializeJson(
                jsonArray(jsonObject(
                    jsonProperty("action", "UPDATE_USER"),
                    jsonProperty("alias", "user meta data"),
                    jsonProperty("allow_failure", false),
                    jsonProperty("id", "update_user_PmSa"),
                    jsonProperty("mask_output", false),
                    jsonProperty("params", jsonObject(
                        jsonProperty("changes", jsonObject(
                            jsonProperty("user_metadata", jsonObject(
                                jsonProperty("full_name", "{{fields.full_name}}")
                            ))
                        )),
                        jsonProperty("connection_id", "<vault_connection_id>"),
                        jsonProperty("user_id", "{{context.user.user_id}}")
                    )),
                    jsonProperty("type", "AUTH0")
                ))))
            .name("Flow KYC update data")
            .build());

    }
}

resources:
  # Example:
  myFlow:
    type: auth0:Flow
    name: my_flow
    properties:
      actions:
        fn::toJSON:
          - action: UPDATE_USER
            alias: user meta data
            allow_failure: false
            id: update_user_PmSa
            mask_output: false
            params:
              changes:
                user_metadata:
                  full_name: '{{fields.full_name}}'
              connection_id: <vault_connection_id>
              user_id: '{{context.user.user_id}}'
            type: AUTH0
      name: Flow KYC update data

var flowResource = new Auth0.Flow("flowResource", new()
{
    Actions = "string",
    Name = "string",
});

example, err := auth0.NewFlow(ctx, "flowResource", &auth0.FlowArgs{
	Actions: pulumi.String("string"),
	Name:    pulumi.String("string"),
})

var flowResource = new Flow("flowResource", FlowArgs.builder()
    .actions("string")
    .name("string")
    .build());

flow_resource = auth0.Flow("flowResource",
    actions="string",
    name="string")

const flowResource = new auth0.Flow("flowResource", {
    actions: "string",
    name: "string",
});

type: auth0:Flow
properties:
    actions: string
    name: string