okta.user.getSubscription

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

const example = okta.user.getSubscription({
    userId: "usr00000000000001",
    id: "APP_IMPORT",
});

import pulumi
import pulumi_okta as okta

example = okta.user.get_subscription(user_id="usr00000000000001",
    id="APP_IMPORT")

package main

import (
	"github.com/pulumi/pulumi-okta/sdk/v7/go/okta/user"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := user.LookupSubscription(ctx, &user.LookupSubscriptionArgs{
			UserId: "usr00000000000001",
			Id:     "APP_IMPORT",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = Okta.User.GetSubscription.Invoke(new()
    {
        UserId = "usr00000000000001",
        Id = "APP_IMPORT",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.okta.user.UserFunctions;
import com.pulumi.okta.user.inputs.GetSubscriptionArgs;
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 example = UserFunctions.getSubscription(GetSubscriptionArgs.builder()
            .userId("usr00000000000001")
            .id("APP_IMPORT")
            .build());

    }
}

variables:
  example:
    fn::invoke:
      function: okta:user:getSubscription
      arguments:
        userId: usr00000000000001
        id: APP_IMPORT

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

data "okta_user_getsubscription" "example" {
  user_id = "usr00000000000001"
  id      = "APP_IMPORT"
}

function getSubscription(args: GetSubscriptionArgs, opts?: InvokeOptions): Promise<GetSubscriptionResult>
function getSubscriptionOutput(args: GetSubscriptionOutputArgs, opts?: InvokeOutputOptions): Output<GetSubscriptionResult>

def get_subscription(id: Optional[str] = None,
                     user_id: Optional[str] = None,
                     opts: Optional[InvokeOptions] = None) -> GetSubscriptionResult
def get_subscription_output(id: pulumi.Input[Optional[str]] = None,
                     user_id: pulumi.Input[Optional[str]] = None,
                     opts: Optional[InvokeOutputOptions] = None) -> Output[GetSubscriptionResult]

func LookupSubscription(ctx *Context, args *LookupSubscriptionArgs, opts ...InvokeOption) (*LookupSubscriptionResult, error)
func LookupSubscriptionOutput(ctx *Context, args *LookupSubscriptionOutputArgs, opts ...InvokeOption) LookupSubscriptionResultOutput

public static class GetSubscription 
{
    public static Task<GetSubscriptionResult> InvokeAsync(GetSubscriptionArgs args, InvokeOptions? opts = null)
    public static Output<GetSubscriptionResult> Invoke(GetSubscriptionInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetSubscriptionResult> Invoke(GetSubscriptionInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetSubscriptionResult> getSubscription(GetSubscriptionArgs args, InvokeOptions options)
public static Output<GetSubscriptionResult> getSubscription(GetSubscriptionArgs args, InvokeOptions options)
public static Output<GetSubscriptionResult> getSubscription(GetSubscriptionArgs args, InvokeOutputOptions options)

fn::invoke:
  function: okta:user/getSubscription:getSubscription
  arguments:
    # arguments dictionary

data "okta_user_get_subscription" "name" {
    # arguments
}