auth0.getActionModuleActions

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

// Example: Retrieve all actions using a specific action module
// Create and publish an action module
const myModule = new auth0.ActionModule("my_module", {
    name: "My Shared Module",
    publish: true,
    code: `module.exports = {
  greet: function(name) {
    return \\"Hello, \\" + name + \\"!\\";
  }
};
`,
});
// Get the published versions of the module
const myModuleVersions = auth0.getActionModuleVersionsOutput({
    moduleId: myModule.id,
});
// Create an action that uses the module
const myAction1 = new auth0.Action("my_action_1", {
    name: "My Action Using Module 1",
    deploy: true,
    code: `const myModule = require('my-module');
exports.onExecutePostLogin = async (event, api) => {
  console.log(myModule.greet(event.user.name));
};
`,
    supportedTriggers: {
        id: "post-login",
        version: "v3",
    },
    modules: [{
        moduleId: myModule.id,
        moduleVersionId: myModuleVersions.apply(myModuleVersions => myModuleVersions.versions?.[0]?.id),
    }],
});
// Create another action that uses the same module
const myAction2 = new auth0.Action("my_action_2", {
    name: "My Action Using Module 2",
    deploy: true,
    code: `const myModule = require('my-module');
exports.onExecutePostLogin = async (event, api) => {
  api.idToken.setCustomClaim(\\"greeting\\", myModule.greet(event.user.name));
};
`,
    supportedTriggers: {
        id: "post-login",
        version: "v3",
    },
    modules: [{
        moduleId: myModule.id,
        moduleVersionId: myModuleVersions.apply(myModuleVersions => myModuleVersions.versions?.[0]?.id),
    }],
});
// Retrieve all actions that are using this module
const myModuleActions = auth0.getActionModuleActionsOutput({
    moduleId: myModule.id,
});
export const actionsUsingModule = myModuleActions.apply(myModuleActions => myModuleActions.total);
export const actionNames = myModuleActions.apply(myModuleActions => .map(action => (action.actionName)));

import pulumi
import pulumi_auth0 as auth0

# Example: Retrieve all actions using a specific action module
# Create and publish an action module
my_module = auth0.ActionModule("my_module",
    name="My Shared Module",
    publish=True,
    code="""module.exports = {
  greet: function(name) {
    return \"Hello, \" + name + \"!\";
  }
};
""")
# Get the published versions of the module
my_module_versions = auth0.get_action_module_versions_output(module_id=my_module.id)
# Create an action that uses the module
my_action1 = auth0.Action("my_action_1",
    name="My Action Using Module 1",
    deploy=True,
    code="""const myModule = require('my-module');
exports.onExecutePostLogin = async (event, api) => {
  console.log(myModule.greet(event.user.name));
};
""",
    supported_triggers={
        "id": "post-login",
        "version": "v3",
    },
    modules=[{
        "module_id": my_module.id,
        "module_version_id": my_module_versions.versions[0].id,
    }])
# Create another action that uses the same module
my_action2 = auth0.Action("my_action_2",
    name="My Action Using Module 2",
    deploy=True,
    code="""const myModule = require('my-module');
exports.onExecutePostLogin = async (event, api) => {
  api.idToken.setCustomClaim(\"greeting\", myModule.greet(event.user.name));
};
""",
    supported_triggers={
        "id": "post-login",
        "version": "v3",
    },
    modules=[{
        "module_id": my_module.id,
        "module_version_id": my_module_versions.versions[0].id,
    }])
# Retrieve all actions that are using this module
my_module_actions = auth0.get_action_module_actions_output(module_id=my_module.id)
pulumi.export("actionsUsingModule", my_module_actions.total)
pulumi.export("actionNames", my_module_actions.apply(lambda my_module_actions: [action.action_name for action in my_module_actions.actions]))

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

return await Deployment.RunAsync(() => 
{
    // Example: Retrieve all actions using a specific action module
    // Create and publish an action module
    var myModule = new Auth0.ActionModule("my_module", new()
    {
        Name = "My Shared Module",
        Publish = true,
        Code = @"module.exports = {
  greet: function(name) {
    return \""Hello, \"" + name + \""!\"";
  }
};
",
    });

    // Get the published versions of the module
    var myModuleVersions = Auth0.GetActionModuleVersions.Invoke(new()
    {
        ModuleId = myModule.Id,
    });

    // Create an action that uses the module
    var myAction1 = new Auth0.Action("my_action_1", new()
    {
        Name = "My Action Using Module 1",
        Deploy = true,
        Code = @"const myModule = require('my-module');
exports.onExecutePostLogin = async (event, api) => {
  console.log(myModule.greet(event.user.name));
};
",
        SupportedTriggers = new Auth0.Inputs.ActionSupportedTriggersArgs
        {
            Id = "post-login",
            Version = "v3",
        },
        Modules = new[]
        {
            new Auth0.Inputs.ActionModuleArgs
            {
                ModuleId = myModule.Id,
                ModuleVersionId = myModuleVersions.Apply(getActionModuleVersionsResult => getActionModuleVersionsResult.Versions[0]?.Id),
            },
        },
    });

    // Create another action that uses the same module
    var myAction2 = new Auth0.Action("my_action_2", new()
    {
        Name = "My Action Using Module 2",
        Deploy = true,
        Code = @"const myModule = require('my-module');
exports.onExecutePostLogin = async (event, api) => {
  api.idToken.setCustomClaim(\""greeting\"", myModule.greet(event.user.name));
};
",
        SupportedTriggers = new Auth0.Inputs.ActionSupportedTriggersArgs
        {
            Id = "post-login",
            Version = "v3",
        },
        Modules = new[]
        {
            new Auth0.Inputs.ActionModuleArgs
            {
                ModuleId = myModule.Id,
                ModuleVersionId = myModuleVersions.Apply(getActionModuleVersionsResult => getActionModuleVersionsResult.Versions[0]?.Id),
            },
        },
    });

    // Retrieve all actions that are using this module
    var myModuleActions = Auth0.GetActionModuleActions.Invoke(new()
    {
        ModuleId = myModule.Id,
    });

    return new Dictionary<string, object?>
    {
        ["actionsUsingModule"] = myModuleActions.Apply(getActionModuleActionsResult => getActionModuleActionsResult.Total),
        ["actionNames"] = .Select(action => 
        {
            return action.ActionName;
        }).ToList(),
    };
});

function getActionModuleActions(args: GetActionModuleActionsArgs, opts?: InvokeOptions): Promise<GetActionModuleActionsResult>
function getActionModuleActionsOutput(args: GetActionModuleActionsOutputArgs, opts?: InvokeOptions): Output<GetActionModuleActionsResult>

def get_action_module_actions(module_id: Optional[str] = None,
                              opts: Optional[InvokeOptions] = None) -> GetActionModuleActionsResult
def get_action_module_actions_output(module_id: Optional[pulumi.Input[str]] = None,
                              opts: Optional[InvokeOptions] = None) -> Output[GetActionModuleActionsResult]

func GetActionModuleActions(ctx *Context, args *GetActionModuleActionsArgs, opts ...InvokeOption) (*GetActionModuleActionsResult, error)
func GetActionModuleActionsOutput(ctx *Context, args *GetActionModuleActionsOutputArgs, opts ...InvokeOption) GetActionModuleActionsResultOutput

public static class GetActionModuleActions 
{
    public static Task<GetActionModuleActionsResult> InvokeAsync(GetActionModuleActionsArgs args, InvokeOptions? opts = null)
    public static Output<GetActionModuleActionsResult> Invoke(GetActionModuleActionsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetActionModuleActionsResult> getActionModuleActions(GetActionModuleActionsArgs args, InvokeOptions options)
public static Output<GetActionModuleActionsResult> getActionModuleActions(GetActionModuleActionsArgs args, InvokeOptions options)

fn::invoke:
  function: auth0:index/getActionModuleActions:getActionModuleActions
  arguments:
    # arguments dictionary