cockroach.getPersonUser

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

const config = new pulumi.Config();
const emailAddress = config.require("emailAddress");
const cockroach = cockroach.getPersonUser({
    email: emailAddress,
});

import pulumi
import pulumi_cockroach as cockroach

config = pulumi.Config()
email_address = config.require("emailAddress")
cockroach = cockroach.get_person_user(email=email_address)

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
	"github.com/pulumiverse/pulumi-cockroach/sdk/go/cockroach"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		cfg := config.New(ctx, "")
		emailAddress := cfg.Require("emailAddress")
		_, err := cockroach.GetPersonUser(ctx, &cockroach.GetPersonUserArgs{
			Email: emailAddress,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var config = new Config();
    var emailAddress = config.Require("emailAddress");
    var cockroach = Cockroach.GetPersonUser.Invoke(new()
    {
        Email = emailAddress,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.cockroach.CockroachFunctions;
import com.pulumi.cockroach.inputs.GetPersonUserArgs;
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 config = ctx.config();
        final var emailAddress = config.get("emailAddress");
        final var cockroach = CockroachFunctions.getPersonUser(GetPersonUserArgs.builder()
            .email(emailAddress)
            .build());

    }
}

configuration:
  emailAddress:
    type: string
variables:
  cockroach:
    fn::invoke:
      Function: cockroach:getPersonUser
      Arguments:
        email: ${emailAddress}

function getPersonUser(args: GetPersonUserArgs, opts?: InvokeOptions): Promise<GetPersonUserResult>
function getPersonUserOutput(args: GetPersonUserOutputArgs, opts?: InvokeOptions): Output<GetPersonUserResult>

def get_person_user(email: Optional[str] = None,
                    opts: Optional[InvokeOptions] = None) -> GetPersonUserResult
def get_person_user_output(email: Optional[pulumi.Input[str]] = None,
                    opts: Optional[InvokeOptions] = None) -> Output[GetPersonUserResult]

func GetPersonUser(ctx *Context, args *GetPersonUserArgs, opts ...InvokeOption) (*GetPersonUserResult, error)
func GetPersonUserOutput(ctx *Context, args *GetPersonUserOutputArgs, opts ...InvokeOption) GetPersonUserResultOutput

public static class GetPersonUser 
{
    public static Task<GetPersonUserResult> InvokeAsync(GetPersonUserArgs args, InvokeOptions? opts = null)
    public static Output<GetPersonUserResult> Invoke(GetPersonUserInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetPersonUserResult> getPersonUser(GetPersonUserArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: cockroach:index/getPersonUser:getPersonUser
  arguments:
    # arguments dictionary