vercel.getConnectApplication

import * as pulumi from "@pulumi/pulumi";
import * as vercel from "@pulumiverse/vercel";

const passport = vercel.getConnectApplication({
    teamId: "team_...",
    uid: "oauth/company-sso",
});
const internalApp = new vercel.Project("internal_app", {
    teamId: passport.then(passport => passport.teamId),
    name: "internal-app",
    passport: {
        connectorId: passport.then(passport => passport.id),
    },
});

import pulumi
import pulumi_vercel as vercel
import pulumiverse_vercel as vercel

passport = vercel.get_connect_application(team_id="team_...",
    uid="oauth/company-sso")
internal_app = vercel.Project("internal_app",
    team_id=passport.team_id,
    name="internal-app",
    passport={
        "connector_id": passport.id,
    })

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumiverse/pulumi-vercel/sdk/v5/go/vercel"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		passport, err := vercel.GetConnectApplication(ctx, &vercel.GetConnectApplicationArgs{
			TeamId: pulumi.StringRef("team_..."),
			Uid:    pulumi.StringRef("oauth/company-sso"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = vercel.NewProject(ctx, "internal_app", &vercel.ProjectArgs{
			TeamId: pulumi.String(passport.TeamId),
			Name:   pulumi.String("internal-app"),
			Passport: &vercel.ProjectPassportArgs{
				ConnectorId: pulumi.String(passport.Id),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Vercel = Pulumiverse.Vercel;

return await Deployment.RunAsync(() => 
{
    var passport = Vercel.GetConnectApplication.Invoke(new()
    {
        TeamId = "team_...",
        Uid = "oauth/company-sso",
    });

    var internalApp = new Vercel.Project("internal_app", new()
    {
        TeamId = passport.Apply(getConnectApplicationResult => getConnectApplicationResult.TeamId),
        Name = "internal-app",
        Passport = new Vercel.Inputs.ProjectPassportArgs
        {
            ConnectorId = passport.Apply(getConnectApplicationResult => getConnectApplicationResult.Id),
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.vercel.VercelFunctions;
import com.pulumi.vercel.inputs.GetConnectApplicationArgs;
import com.pulumiverse.vercel.Project;
import com.pulumiverse.vercel.ProjectArgs;
import com.pulumi.vercel.inputs.ProjectPassportArgs;
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 passport = VercelFunctions.getConnectApplication(GetConnectApplicationArgs.builder()
            .teamId("team_...")
            .uid("oauth/company-sso")
            .build());

        var internalApp = new Project("internalApp", ProjectArgs.builder()
            .teamId(passport.teamId())
            .name("internal-app")
            .passport(ProjectPassportArgs.builder()
                .connectorId(passport.id())
                .build())
            .build());

    }
}

resources:
  internalApp:
    type: vercel:Project
    name: internal_app
    properties:
      teamId: ${passport.teamId}
      name: internal-app
      passport:
        connectorId: ${passport.id}
variables:
  passport:
    fn::invoke:
      function: vercel:getConnectApplication
      arguments:
        teamId: team_...
        uid: oauth/company-sso

function getConnectApplication(args: GetConnectApplicationArgs, opts?: InvokeOptions): Promise<GetConnectApplicationResult>
function getConnectApplicationOutput(args: GetConnectApplicationOutputArgs, opts?: InvokeOutputOptions): Output<GetConnectApplicationResult>

def get_connect_application(id: Optional[str] = None,
                            team_id: Optional[str] = None,
                            uid: Optional[str] = None,
                            opts: Optional[InvokeOptions] = None) -> GetConnectApplicationResult
def get_connect_application_output(id: pulumi.Input[Optional[str]] = None,
                            team_id: pulumi.Input[Optional[str]] = None,
                            uid: pulumi.Input[Optional[str]] = None,
                            opts: Optional[InvokeOutputOptions] = None) -> Output[GetConnectApplicationResult]

func GetConnectApplication(ctx *Context, args *GetConnectApplicationArgs, opts ...InvokeOption) (*GetConnectApplicationResult, error)
func GetConnectApplicationOutput(ctx *Context, args *GetConnectApplicationOutputArgs, opts ...InvokeOption) GetConnectApplicationResultOutput

public static class GetConnectApplication 
{
    public static Task<GetConnectApplicationResult> InvokeAsync(GetConnectApplicationArgs args, InvokeOptions? opts = null)
    public static Output<GetConnectApplicationResult> Invoke(GetConnectApplicationInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetConnectApplicationResult> Invoke(GetConnectApplicationInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetConnectApplicationResult> getConnectApplication(GetConnectApplicationArgs args, InvokeOptions options)
public static Output<GetConnectApplicationResult> getConnectApplication(GetConnectApplicationArgs args, InvokeOptions options)
public static Output<GetConnectApplicationResult> getConnectApplication(GetConnectApplicationArgs args, InvokeOutputOptions options)

fn::invoke:
  function: vercel:index/getConnectApplication:getConnectApplication
  arguments:
    # arguments dictionary

data "vercel_get_connect_application" "name" {
    # arguments
}