auth0.getActionModuleVersion

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

// Example: Retrieve a specific version of an 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 all versions to find the version ID
const myModuleVersions = auth0.getActionModuleVersionsOutput({
    moduleId: myModule.id,
});
// Retrieve a specific version by its ID
const myModuleVersion = pulumi.all([myModule.id, myModuleVersions]).apply(([id, myModuleVersions]) => auth0.getActionModuleVersionOutput({
    moduleId: id,
    versionId: myModuleVersions.versions?.[0]?.id,
}));
export const versionNumber = myModuleVersion.apply(myModuleVersion => myModuleVersion.versionNumber);
export const versionCode = myModuleVersion.apply(myModuleVersion => myModuleVersion.code);
export const versionCreatedAt = myModuleVersion.apply(myModuleVersion => myModuleVersion.createdAt);

import pulumi
import pulumi_auth0 as auth0

# Example: Retrieve a specific version of an 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 all versions to find the version ID
my_module_versions = auth0.get_action_module_versions_output(module_id=my_module.id)
# Retrieve a specific version by its ID
my_module_version = pulumi.Output.all(
    id=my_module.id,
    my_module_versions=my_module_versions
).apply(lambda resolved_outputs: auth0.get_action_module_version_output(module_id=resolved_outputs['id'],
    version_id=my_module_versions.versions[0].id))

pulumi.export("versionNumber", my_module_version.version_number)
pulumi.export("versionCode", my_module_version.code)
pulumi.export("versionCreatedAt", my_module_version.created_at)

package main

import (
	"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 {
		// Example: Retrieve a specific version of an action module
		// Create and publish an action module
		myModule, err := auth0.NewActionModule(ctx, "my_module", &auth0.ActionModuleArgs{
			Name:    pulumi.String("My Shared Module"),
			Publish: pulumi.Bool(true),
			Code: pulumi.String(`module.exports = {
  greet: function(name) {
    return \"Hello, \" + name + \"!\";
  }
};
`),
		})
		if err != nil {
			return err
		}
		// Get all versions to find the version ID
		myModuleVersions := auth0.GetActionModuleVersionsOutput(ctx, auth0.GetActionModuleVersionsOutputArgs{
			ModuleId: myModule.ID(),
		}, nil)
		// Retrieve a specific version by its ID
		myModuleVersion := pulumi.All(myModule.ID(), myModuleVersions).ApplyT(func(_args []interface{}) (auth0.GetActionModuleVersionResult, error) {
			id := _args[0].(string)
			myModuleVersions := _args[1].(auth0.GetActionModuleVersionsResult)
			return auth0.GetActionModuleVersionResult(interface{}(auth0.GetActionModuleVersion(ctx, &auth0.GetActionModuleVersionArgs{
				ModuleId:  id,
				VersionId: myModuleVersions.Versions[0].Id,
			}, nil))), nil
		}).(auth0.GetActionModuleVersionResultOutput)
		ctx.Export("versionNumber", myModuleVersion.ApplyT(func(myModuleVersion auth0.GetActionModuleVersionResult) (*int, error) {
			return &myModuleVersion.VersionNumber, nil
		}).(pulumi.IntPtrOutput))
		ctx.Export("versionCode", myModuleVersion.ApplyT(func(myModuleVersion auth0.GetActionModuleVersionResult) (*string, error) {
			return &myModuleVersion.Code, nil
		}).(pulumi.StringPtrOutput))
		ctx.Export("versionCreatedAt", myModuleVersion.ApplyT(func(myModuleVersion auth0.GetActionModuleVersionResult) (*string, error) {
			return &myModuleVersion.CreatedAt, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Example: Retrieve a specific version of an 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 all versions to find the version ID
    var myModuleVersions = Auth0.GetActionModuleVersions.Invoke(new()
    {
        ModuleId = myModule.Id,
    });

    // Retrieve a specific version by its ID
    var myModuleVersion = Auth0.GetActionModuleVersion.Invoke(new()
    {
        ModuleId = myModule.Id,
        VersionId = myModuleVersions.Apply(getActionModuleVersionsResult => getActionModuleVersionsResult.Versions[0]?.Id),
    });

    return new Dictionary<string, object?>
    {
        ["versionNumber"] = myModuleVersion.Apply(getActionModuleVersionResult => getActionModuleVersionResult.VersionNumber),
        ["versionCode"] = myModuleVersion.Apply(getActionModuleVersionResult => getActionModuleVersionResult.Code),
        ["versionCreatedAt"] = myModuleVersion.Apply(getActionModuleVersionResult => getActionModuleVersionResult.CreatedAt),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.auth0.ActionModule;
import com.pulumi.auth0.ActionModuleArgs;
import com.pulumi.auth0.Auth0Functions;
import com.pulumi.auth0.inputs.GetActionModuleVersionsArgs;
import com.pulumi.auth0.inputs.GetActionModuleVersionArgs;
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: Retrieve a specific version of an action module
        // Create and publish an action module
        var myModule = new ActionModule("myModule", ActionModuleArgs.builder()
            .name("My Shared Module")
            .publish(true)
            .code("""
module.exports = {
  greet: function(name) {
    return \"Hello, \" + name + \"!\";
  }
};
            """)
            .build());

        // Get all versions to find the version ID
        final var myModuleVersions = Auth0Functions.getActionModuleVersions(GetActionModuleVersionsArgs.builder()
            .moduleId(myModule.id())
            .build());

        // Retrieve a specific version by its ID
        final var myModuleVersion = Output.tuple(myModule.id(), myModuleVersions).applyValue(values -> {
            var id = values.t1;
            var myModuleVersions = values.t2;
            return Auth0Functions.getActionModuleVersion(GetActionModuleVersionArgs.builder()
                .moduleId(id)
                .versionId(myModuleVersions.versions()[0].id())
                .build());
        });

        ctx.export("versionNumber", myModuleVersion.applyValue(_myModuleVersion -> _myModuleVersion.versionNumber()));
        ctx.export("versionCode", myModuleVersion.applyValue(_myModuleVersion -> _myModuleVersion.code()));
        ctx.export("versionCreatedAt", myModuleVersion.applyValue(_myModuleVersion -> _myModuleVersion.createdAt()));
    }
}

resources:
  # Example: Retrieve a specific version of an action module

  # Create and publish an action module
  myModule:
    type: auth0:ActionModule
    name: my_module
    properties:
      name: My Shared Module
      publish: true
      code: |
        module.exports = {
          greet: function(name) {
            return \"Hello, \" + name + \"!\";
          }
        };
variables:
  # Get all versions to find the version ID
  myModuleVersions:
    fn::invoke:
      function: auth0:getActionModuleVersions
      arguments:
        moduleId: ${myModule.id}
  # Retrieve a specific version by its ID
  myModuleVersion:
    fn::invoke:
      function: auth0:getActionModuleVersion
      arguments:
        moduleId: ${myModule.id}
        versionId: ${myModuleVersions.versions[0].id}
outputs:
  # Output the version details
  versionNumber: ${myModuleVersion.versionNumber}
  versionCode: ${myModuleVersion.code}
  versionCreatedAt: ${myModuleVersion.createdAt}

function getActionModuleVersion(args: GetActionModuleVersionArgs, opts?: InvokeOptions): Promise<GetActionModuleVersionResult>
function getActionModuleVersionOutput(args: GetActionModuleVersionOutputArgs, opts?: InvokeOptions): Output<GetActionModuleVersionResult>

def get_action_module_version(module_id: Optional[str] = None,
                              version_id: Optional[str] = None,
                              opts: Optional[InvokeOptions] = None) -> GetActionModuleVersionResult
def get_action_module_version_output(module_id: Optional[pulumi.Input[str]] = None,
                              version_id: Optional[pulumi.Input[str]] = None,
                              opts: Optional[InvokeOptions] = None) -> Output[GetActionModuleVersionResult]

func GetActionModuleVersion(ctx *Context, args *GetActionModuleVersionArgs, opts ...InvokeOption) (*GetActionModuleVersionResult, error)
func GetActionModuleVersionOutput(ctx *Context, args *GetActionModuleVersionOutputArgs, opts ...InvokeOption) GetActionModuleVersionResultOutput

public static class GetActionModuleVersion 
{
    public static Task<GetActionModuleVersionResult> InvokeAsync(GetActionModuleVersionArgs args, InvokeOptions? opts = null)
    public static Output<GetActionModuleVersionResult> Invoke(GetActionModuleVersionInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetActionModuleVersionResult> getActionModuleVersion(GetActionModuleVersionArgs args, InvokeOptions options)
public static Output<GetActionModuleVersionResult> getActionModuleVersion(GetActionModuleVersionArgs args, InvokeOptions options)

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