okta.app.getToken

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

const example = okta.app.getToken({
    clientId: "0oardd5r32PWsF4421d7",
    id: "oar1godmqw4QUiX4C1d7",
});
export const tokenStatus = example.then(example => example.status);
export const tokenUser = example.then(example => example.userId);

import pulumi
import pulumi_okta as okta

example = okta.app.get_token(client_id="0oardd5r32PWsF4421d7",
    id="oar1godmqw4QUiX4C1d7")
pulumi.export("tokenStatus", example.status)
pulumi.export("tokenUser", example.user_id)

package main

import (
	"github.com/pulumi/pulumi-okta/sdk/v6/go/okta/app"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := app.LookupToken(ctx, &app.LookupTokenArgs{
			ClientId: "0oardd5r32PWsF4421d7",
			Id:       "oar1godmqw4QUiX4C1d7",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("tokenStatus", example.Status)
		ctx.Export("tokenUser", example.UserId)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = Okta.App.GetToken.Invoke(new()
    {
        ClientId = "0oardd5r32PWsF4421d7",
        Id = "oar1godmqw4QUiX4C1d7",
    });

    return new Dictionary<string, object?>
    {
        ["tokenStatus"] = example.Apply(getTokenResult => getTokenResult.Status),
        ["tokenUser"] = example.Apply(getTokenResult => getTokenResult.UserId),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.okta.app.AppFunctions;
import com.pulumi.okta.app.inputs.GetTokenArgs;
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 example = AppFunctions.getToken(GetTokenArgs.builder()
            .clientId("0oardd5r32PWsF4421d7")
            .id("oar1godmqw4QUiX4C1d7")
            .build());

        ctx.export("tokenStatus", example.status());
        ctx.export("tokenUser", example.userId());
    }
}

variables:
  example:
    fn::invoke:
      function: okta:app:getToken
      arguments:
        clientId: 0oardd5r32PWsF4421d7
        id: oar1godmqw4QUiX4C1d7
outputs:
  tokenStatus: ${example.status}
  tokenUser: ${example.userId}

function getToken(args: GetTokenArgs, opts?: InvokeOptions): Promise<GetTokenResult>
function getTokenOutput(args: GetTokenOutputArgs, opts?: InvokeOptions): Output<GetTokenResult>

def get_token(client_id: Optional[str] = None,
              id: Optional[str] = None,
              opts: Optional[InvokeOptions] = None) -> GetTokenResult
def get_token_output(client_id: Optional[pulumi.Input[str]] = None,
              id: Optional[pulumi.Input[str]] = None,
              opts: Optional[InvokeOptions] = None) -> Output[GetTokenResult]

func LookupToken(ctx *Context, args *LookupTokenArgs, opts ...InvokeOption) (*LookupTokenResult, error)
func LookupTokenOutput(ctx *Context, args *LookupTokenOutputArgs, opts ...InvokeOption) LookupTokenResultOutput

public static class GetToken 
{
    public static Task<GetTokenResult> InvokeAsync(GetTokenArgs args, InvokeOptions? opts = null)
    public static Output<GetTokenResult> Invoke(GetTokenInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetTokenResult> getToken(GetTokenArgs args, InvokeOptions options)
public static Output<GetTokenResult> getToken(GetTokenArgs args, InvokeOptions options)

fn::invoke:
  function: okta:app/getToken:getToken
  arguments:
    # arguments dictionary