auth0.Action

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

const myAction = new auth0.Action("my_action", {
    name: std.format({
        input: "Test Action %s",
        args: [std.timestamp({}).result],
    }).result,
    runtime: "node22",
    deploy: true,
    code: `/**
 * Handler that will be called during the execution of a PostLogin flow.
 *
 * @param {Event} event - Details about the user and the context in which they are logging in.
 * @param {PostLoginAPI} api - Interface whose methods can be used to change the behavior of the login.
 */
 exports.onExecutePostLogin = async (event, api) => {
   console.log(event);
 };
`,
    supportedTriggers: {
        id: "post-login",
        version: "v3",
    },
    dependencies: [
        {
            name: "lodash",
            version: "latest",
        },
        {
            name: "request",
            version: "latest",
        },
    ],
    secrets: [
        {
            name: "FOO",
            value: "Foo",
        },
        {
            name: "BAR",
            value: "Bar",
        },
    ],
});
const config = new pulumi.Config();
// API key passed to the post-login action.
const actionApiKey = config.require("actionApiKey");
const mySecureAction = new auth0.Action("my_secure_action", {
    name: std.format({
        input: "Secure Action %s",
        args: [std.timestamp({}).result],
    }).result,
    runtime: "node22",
    deploy: true,
    code: `exports.onExecutePostLogin = async (event, api) => {
  console.log(event);
};
`,
    supportedTriggers: {
        id: "post-login",
        version: "v3",
    },
    secretsWos: [{
        name: "API_KEY",
        value: actionApiKey,
    }],
    secretsWoVersion: 1,
});

import pulumi
import pulumi_auth0 as auth0
import pulumi_std as std

my_action = auth0.Action("my_action",
    name=std.format(input="Test Action %s",
        args=[std.timestamp()["result"]])["result"],
    runtime="node22",
    deploy=True,
    code="""/**
 * Handler that will be called during the execution of a PostLogin flow.
 *
 * @param {Event} event - Details about the user and the context in which they are logging in.
 * @param {PostLoginAPI} api - Interface whose methods can be used to change the behavior of the login.
 */
 exports.onExecutePostLogin = async (event, api) => {
   console.log(event);
 };
""",
    supported_triggers={
        "id": "post-login",
        "version": "v3",
    },
    dependencies=[
        {
            "name": "lodash",
            "version": "latest",
        },
        {
            "name": "request",
            "version": "latest",
        },
    ],
    secrets=[
        {
            "name": "FOO",
            "value": "Foo",
        },
        {
            "name": "BAR",
            "value": "Bar",
        },
    ])
config = pulumi.Config()
# API key passed to the post-login action.
action_api_key = config.require("actionApiKey")
my_secure_action = auth0.Action("my_secure_action",
    name=std.format(input="Secure Action %s",
        args=[std.timestamp()["result"]])["result"],
    runtime="node22",
    deploy=True,
    code="""exports.onExecutePostLogin = async (event, api) => {
  console.log(event);
};
""",
    supported_triggers={
        "id": "post-login",
        "version": "v3",
    },
    secrets_wos=[{
        "name": "API_KEY",
        "value": action_api_key,
    }],
    secrets_wo_version=1)

package main

import (
	"github.com/pulumi/pulumi-auth0/sdk/v3/go/auth0"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		invokeFormat, err := std.Format(ctx, map[string]interface{}{
			"input": "Test Action %s",
			"args": []interface{}{
				std.Timestamp(ctx, map[string]interface{}{}, nil).Result,
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = auth0.NewAction(ctx, "my_action", &auth0.ActionArgs{
			Name:    invokeFormat.Result,
			Runtime: pulumi.String("node22"),
			Deploy:  pulumi.Bool(true),
			Code: pulumi.String(`/**
 * Handler that will be called during the execution of a PostLogin flow.
 *
 * @param {Event} event - Details about the user and the context in which they are logging in.
 * @param {PostLoginAPI} api - Interface whose methods can be used to change the behavior of the login.
 */
 exports.onExecutePostLogin = async (event, api) => {
   console.log(event);
 };
`),
			SupportedTriggers: &auth0.ActionSupportedTriggersArgs{
				Id:      pulumi.String("post-login"),
				Version: pulumi.String("v3"),
			},
			Dependencies: auth0.ActionDependencyArray{
				&auth0.ActionDependencyArgs{
					Name:    pulumi.String("lodash"),
					Version: pulumi.String("latest"),
				},
				&auth0.ActionDependencyArgs{
					Name:    pulumi.String("request"),
					Version: pulumi.String("latest"),
				},
			},
			Secrets: auth0.ActionSecretArray{
				&auth0.ActionSecretArgs{
					Name:  pulumi.String("FOO"),
					Value: pulumi.String("Foo"),
				},
				&auth0.ActionSecretArgs{
					Name:  pulumi.String("BAR"),
					Value: pulumi.String("Bar"),
				},
			},
		})
		if err != nil {
			return err
		}
		cfg := config.New(ctx, "")
		// API key passed to the post-login action.
		actionApiKey := cfg.Require("actionApiKey")
		invokeFormat1, err := std.Format(ctx, map[string]interface{}{
			"input": "Secure Action %s",
			"args": []interface{}{
				std.Timestamp(ctx, map[string]interface{}{}, nil).Result,
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = auth0.NewAction(ctx, "my_secure_action", &auth0.ActionArgs{
			Name:    invokeFormat1.Result,
			Runtime: pulumi.String("node22"),
			Deploy:  pulumi.Bool(true),
			Code:    pulumi.String("exports.onExecutePostLogin = async (event, api) => {\n  console.log(event);\n};\n"),
			SupportedTriggers: &auth0.ActionSupportedTriggersArgs{
				Id:      pulumi.String("post-login"),
				Version: pulumi.String("v3"),
			},
			SecretsWos: auth0.ActionSecretsWoArray{
				&auth0.ActionSecretsWoArgs{
					Name:  pulumi.String("API_KEY"),
					Value: pulumi.String(actionApiKey),
				},
			},
			SecretsWoVersion: pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Auth0 = Pulumi.Auth0;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var myAction = new Auth0.Action("my_action", new()
    {
        Name = Std.Format.Invoke(new()
        {
            Input = "Test Action %s",
            Args = new[]
            {
                Std.Timestamp.Invoke().Result,
            },
        }).Result,
        Runtime = "node22",
        Deploy = true,
        Code = @"/**
 * Handler that will be called during the execution of a PostLogin flow.
 *
 * @param {Event} event - Details about the user and the context in which they are logging in.
 * @param {PostLoginAPI} api - Interface whose methods can be used to change the behavior of the login.
 */
 exports.onExecutePostLogin = async (event, api) => {
   console.log(event);
 };
",
        SupportedTriggers = new Auth0.Inputs.ActionSupportedTriggersArgs
        {
            Id = "post-login",
            Version = "v3",
        },
        Dependencies = new[]
        {
            new Auth0.Inputs.ActionDependencyArgs
            {
                Name = "lodash",
                Version = "latest",
            },
            new Auth0.Inputs.ActionDependencyArgs
            {
                Name = "request",
                Version = "latest",
            },
        },
        Secrets = new[]
        {
            new Auth0.Inputs.ActionSecretArgs
            {
                Name = "FOO",
                Value = "Foo",
            },
            new Auth0.Inputs.ActionSecretArgs
            {
                Name = "BAR",
                Value = "Bar",
            },
        },
    });

    var config = new Config();
    // API key passed to the post-login action.
    var actionApiKey = config.Require("actionApiKey");
    var mySecureAction = new Auth0.Action("my_secure_action", new()
    {
        Name = Std.Format.Invoke(new()
        {
            Input = "Secure Action %s",
            Args = new[]
            {
                Std.Timestamp.Invoke().Result,
            },
        }).Result,
        Runtime = "node22",
        Deploy = true,
        Code = @"exports.onExecutePostLogin = async (event, api) => {
  console.log(event);
};
",
        SupportedTriggers = new Auth0.Inputs.ActionSupportedTriggersArgs
        {
            Id = "post-login",
            Version = "v3",
        },
        SecretsWos = new[]
        {
            new Auth0.Inputs.ActionSecretsWoArgs
            {
                Name = "API_KEY",
                Value = actionApiKey,
            },
        },
        SecretsWoVersion = 1,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.auth0.Action;
import com.pulumi.auth0.ActionArgs;
import com.pulumi.auth0.inputs.ActionSupportedTriggersArgs;
import com.pulumi.auth0.inputs.ActionDependencyArgs;
import com.pulumi.auth0.inputs.ActionSecretArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.auth0.inputs.ActionSecretsWoArgs;
import java.util.ArrayList;
import java.util.Arrays;
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 config = ctx.config();
        var myAction = new Action("myAction", ActionArgs.builder()
            .name(StdFunctions.format(Map.ofEntries(
                Map.entry("input", "Test Action %s"),
                Map.entry("args", Arrays.asList(StdFunctions.timestamp(Map.ofEntries(
                )).result()))
            )).result())
            .runtime("node22")
            .deploy(true)
            .code("""
/**
 * Handler that will be called during the execution of a PostLogin flow.
 *
 * @param {Event} event - Details about the user and the context in which they are logging in.
 * @param {PostLoginAPI} api - Interface whose methods can be used to change the behavior of the login.
 */
 exports.onExecutePostLogin = async (event, api) => {
   console.log(event);
 };
            """)
            .supportedTriggers(ActionSupportedTriggersArgs.builder()
                .id("post-login")
                .version("v3")
                .build())
            .dependencies(            
                ActionDependencyArgs.builder()
                    .name("lodash")
                    .version("latest")
                    .build(),
                ActionDependencyArgs.builder()
                    .name("request")
                    .version("latest")
                    .build())
            .secrets(            
                ActionSecretArgs.builder()
                    .name("FOO")
                    .value("Foo")
                    .build(),
                ActionSecretArgs.builder()
                    .name("BAR")
                    .value("Bar")
                    .build())
            .build());

        final var actionApiKey = config.require("actionApiKey");
        var mySecureAction = new Action("mySecureAction", ActionArgs.builder()
            .name(StdFunctions.format(Map.ofEntries(
                Map.entry("input", "Secure Action %s"),
                Map.entry("args", Arrays.asList(StdFunctions.timestamp(Map.ofEntries(
                )).result()))
            )).result())
            .runtime("node22")
            .deploy(true)
            .code("""
exports.onExecutePostLogin = async (event, api) => {
  console.log(event);
};
            """)
            .supportedTriggers(ActionSupportedTriggersArgs.builder()
                .id("post-login")
                .version("v3")
                .build())
            .secretsWos(ActionSecretsWoArgs.builder()
                .name("API_KEY")
                .value(actionApiKey)
                .build())
            .secretsWoVersion(1)
            .build());

    }
}

configuration:
  # Creates an action with write-only secrets (recommended for security).
  # Secret values are never stored in Terraform state. They can be supplied via
  # regular sensitive variables or via ephemeral variables/resources.
  actionApiKey:
    type: string
resources:
  myAction:
    type: auth0:Action
    name: my_action
    properties:
      name:
        fn::invoke:
          function: std:format
          arguments:
            input: Test Action %s
            args:
              - fn::invoke:
                  function: std:timestamp
                  arguments: {}
                  return: result
          return: result
      runtime: node22
      deploy: true
      code: |
        /**
         * Handler that will be called during the execution of a PostLogin flow.
         *
         * @param {Event} event - Details about the user and the context in which they are logging in.
         * @param {PostLoginAPI} api - Interface whose methods can be used to change the behavior of the login.
         */
         exports.onExecutePostLogin = async (event, api) => {
           console.log(event);
         };
      supportedTriggers:
        id: post-login
        version: v3
      dependencies:
        - name: lodash
          version: latest
        - name: request
          version: latest
      secrets:
        - name: FOO
          value: Foo
        - name: BAR
          value: Bar
  mySecureAction:
    type: auth0:Action
    name: my_secure_action
    properties:
      name:
        fn::invoke:
          function: std:format
          arguments:
            input: Secure Action %s
            args:
              - fn::invoke:
                  function: std:timestamp
                  arguments: {}
                  return: result
          return: result
      runtime: node22
      deploy: true
      code: |
        exports.onExecutePostLogin = async (event, api) => {
          console.log(event);
        };
      supportedTriggers:
        id: post-login
        version: v3
      secretsWos:
        - name: API_KEY
          value: ${actionApiKey}
      secretsWoVersion: 1

pulumi {
  required_providers {
    auth0 = {
      source = "pulumi/auth0"
    }
  }
}

data "std_format" "invoke_0" {
  input = "Test Action %s"
  args  = [timestamp()]
}
data "std_format" "invoke_1" {
  input = "Secure Action %s"
  args  = [timestamp()]
}

resource "auth0_action" "my_action" {
  name    = data.std_format.invoke_0.result
  runtime = "node22"
  deploy  = true
  code    = "/**\n * Handler that will be called during the execution of a PostLogin flow.\n *\n * @param {Event} event - Details about the user and the context in which they are logging in.\n * @param {PostLoginAPI} api - Interface whose methods can be used to change the behavior of the login.\n */\n exports.onExecutePostLogin = async (event, api) => {\n   console.log(event);\n };\n"
  supported_triggers = {
    id      = "post-login"
    version = "v3"
  }
  dependencies {
    name    = "lodash"
    version = "latest"
  }
  dependencies {
    name    = "request"
    version = "latest"
  }
  secrets {
    name  = "FOO"
    value = "Foo"
  }
  secrets {
    name  = "BAR"
    value = "Bar"
  }
}
resource "auth0_action" "my_secure_action" {
  name    = data.std_format.invoke_1.result
  runtime = "node22"
  deploy  = true
  code    = "exports.onExecutePostLogin = async (event, api) => {\n  console.log(event);\n};\n"
  supported_triggers = {
    id      = "post-login"
    version = "v3"
  }
  secrets_wos {
    name  = "API_KEY"
    value = var.actionApiKey
  }
  secrets_wo_version = 1
}
# Creates an action with write-only secrets (recommended for security).
# Secret values are never stored in Terraform state. They can be supplied via
# regular sensitive variables or via ephemeral variables/resources.
variable "actionApiKey" {
  type        = string
  description = "API key passed to the post-login action."
}

var actionResource = new Auth0.Action("actionResource", new()
{
    Code = "string",
    SupportedTriggers = new Auth0.Inputs.ActionSupportedTriggersArgs
    {
        Id = "string",
        Version = "string",
    },
    Dependencies = new[]
    {
        new Auth0.Inputs.ActionDependencyArgs
        {
            Name = "string",
            Version = "string",
        },
    },
    Deploy = false,
    Modules = new[]
    {
        new Auth0.Inputs.ActionModuleArgs
        {
            ModuleId = "string",
            ModuleVersionId = "string",
            ModuleName = "string",
            ModuleVersionNumber = 0,
        },
    },
    Name = "string",
    Runtime = "string",
    Secrets = new[]
    {
        new Auth0.Inputs.ActionSecretArgs
        {
            Name = "string",
            Value = "string",
        },
    },
    SecretsWoVersion = 0,
    SecretsWos = new[]
    {
        new Auth0.Inputs.ActionSecretsWoArgs
        {
            Name = "string",
            Value = "string",
        },
    },
});

example, err := auth0.NewAction(ctx, "actionResource", &auth0.ActionArgs{
	Code: pulumi.String("string"),
	SupportedTriggers: &auth0.ActionSupportedTriggersArgs{
		Id:      pulumi.String("string"),
		Version: pulumi.String("string"),
	},
	Dependencies: auth0.ActionDependencyArray{
		&auth0.ActionDependencyArgs{
			Name:    pulumi.String("string"),
			Version: pulumi.String("string"),
		},
	},
	Deploy: pulumi.Bool(false),
	Modules: auth0.ActionModuleTypeArray{
		&auth0.ActionModuleTypeArgs{
			ModuleId:            pulumi.String("string"),
			ModuleVersionId:     pulumi.String("string"),
			ModuleName:          pulumi.String("string"),
			ModuleVersionNumber: pulumi.Int(0),
		},
	},
	Name:    pulumi.String("string"),
	Runtime: pulumi.String("string"),
	Secrets: auth0.ActionSecretArray{
		&auth0.ActionSecretArgs{
			Name:  pulumi.String("string"),
			Value: pulumi.String("string"),
		},
	},
	SecretsWoVersion: pulumi.Int(0),
	SecretsWos: auth0.ActionSecretsWoArray{
		&auth0.ActionSecretsWoArgs{
			Name:  pulumi.String("string"),
			Value: pulumi.String("string"),
		},
	},
})

resource "auth0_action" "actionResource" {
  lifecycle {
    create_before_destroy = true
  }
  code = "string"
  supported_triggers = {
    id      = "string"
    version = "string"
  }
  dependencies {
    name    = "string"
    version = "string"
  }
  deploy = false
  modules {
    module_id             = "string"
    module_version_id     = "string"
    module_name           = "string"
    module_version_number = 0
  }
  name    = "string"
  runtime = "string"
  secrets {
    name  = "string"
    value = "string"
  }
  secrets_wo_version = 0
  secrets_wos {
    name  = "string"
    value = "string"
  }
}

var actionResource = new Action("actionResource", ActionArgs.builder()
    .code("string")
    .supportedTriggers(ActionSupportedTriggersArgs.builder()
        .id("string")
        .version("string")
        .build())
    .dependencies(ActionDependencyArgs.builder()
        .name("string")
        .version("string")
        .build())
    .deploy(false)
    .modules(com.pulumi.auth0.inputs.ActionModuleArgs.builder()
        .moduleId("string")
        .moduleVersionId("string")
        .moduleName("string")
        .moduleVersionNumber(0)
        .build())
    .name("string")
    .runtime("string")
    .secrets(ActionSecretArgs.builder()
        .name("string")
        .value("string")
        .build())
    .secretsWoVersion(0)
    .secretsWos(ActionSecretsWoArgs.builder()
        .name("string")
        .value("string")
        .build())
    .build());

action_resource = auth0.Action("actionResource",
    code="string",
    supported_triggers={
        "id": "string",
        "version": "string",
    },
    dependencies=[{
        "name": "string",
        "version": "string",
    }],
    deploy=False,
    modules=[{
        "module_id": "string",
        "module_version_id": "string",
        "module_name": "string",
        "module_version_number": 0,
    }],
    name="string",
    runtime="string",
    secrets=[{
        "name": "string",
        "value": "string",
    }],
    secrets_wo_version=0,
    secrets_wos=[{
        "name": "string",
        "value": "string",
    }])

const actionResource = new auth0.Action("actionResource", {
    code: "string",
    supportedTriggers: {
        id: "string",
        version: "string",
    },
    dependencies: [{
        name: "string",
        version: "string",
    }],
    deploy: false,
    modules: [{
        moduleId: "string",
        moduleVersionId: "string",
        moduleName: "string",
        moduleVersionNumber: 0,
    }],
    name: "string",
    runtime: "string",
    secrets: [{
        name: "string",
        value: "string",
    }],
    secretsWoVersion: 0,
    secretsWos: [{
        name: "string",
        value: "string",
    }],
});

type: auth0:Action
properties:
    code: string
    dependencies:
        - name: string
          version: string
    deploy: false
    modules:
        - moduleId: string
          moduleName: string
          moduleVersionId: string
          moduleVersionNumber: 0
    name: string
    runtime: string
    secrets:
        - name: string
          value: string
    secretsWoVersion: 0
    secretsWos:
        - name: string
          value: string
    supportedTriggers:
        id: string
        version: string