vercel.VcrRepositoryPermission

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

const example = new vercel.Project("example", {name: "example-project-with-vcr-repository"});
const exampleVcrRepository = new vercel.VcrRepository("example", {
    projectId: example.id,
    name: "my-repository",
});
// Share the repository with another team, granting it
// read (pull) access to the repository's images.
const exampleVcrRepositoryPermission = new vercel.VcrRepositoryPermission("example", {
    projectId: example.id,
    repository: exampleVcrRepository.name,
    grantedTeamId: "team_xxxxxxxxxxxxxxxxxxxxxxxx",
});
// The granted team can alternatively be referenced by its slug.
const exampleBySlug = new vercel.VcrRepositoryPermission("example_by_slug", {
    projectId: example.id,
    repository: exampleVcrRepository.name,
    grantedTeamSlug: "my-other-team",
});

import pulumi
import pulumiverse_vercel as vercel

example = vercel.Project("example", name="example-project-with-vcr-repository")
example_vcr_repository = vercel.VcrRepository("example",
    project_id=example.id,
    name="my-repository")
# Share the repository with another team, granting it
# read (pull) access to the repository's images.
example_vcr_repository_permission = vercel.VcrRepositoryPermission("example",
    project_id=example.id,
    repository=example_vcr_repository.name,
    granted_team_id="team_xxxxxxxxxxxxxxxxxxxxxxxx")
# The granted team can alternatively be referenced by its slug.
example_by_slug = vercel.VcrRepositoryPermission("example_by_slug",
    project_id=example.id,
    repository=example_vcr_repository.name,
    granted_team_slug="my-other-team")

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 {
		example, err := vercel.NewProject(ctx, "example", &vercel.ProjectArgs{
			Name: pulumi.String("example-project-with-vcr-repository"),
		})
		if err != nil {
			return err
		}
		exampleVcrRepository, err := vercel.NewVcrRepository(ctx, "example", &vercel.VcrRepositoryArgs{
			ProjectId: example.ID(),
			Name:      pulumi.String("my-repository"),
		})
		if err != nil {
			return err
		}
		// Share the repository with another team, granting it
		// read (pull) access to the repository's images.
		_, err = vercel.NewVcrRepositoryPermission(ctx, "example", &vercel.VcrRepositoryPermissionArgs{
			ProjectId:     example.ID(),
			Repository:    exampleVcrRepository.Name,
			GrantedTeamId: pulumi.String("team_xxxxxxxxxxxxxxxxxxxxxxxx"),
		})
		if err != nil {
			return err
		}
		// The granted team can alternatively be referenced by its slug.
		_, err = vercel.NewVcrRepositoryPermission(ctx, "example_by_slug", &vercel.VcrRepositoryPermissionArgs{
			ProjectId:       example.ID(),
			Repository:      exampleVcrRepository.Name,
			GrantedTeamSlug: pulumi.String("my-other-team"),
		})
		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 example = new Vercel.Project("example", new()
    {
        Name = "example-project-with-vcr-repository",
    });

    var exampleVcrRepository = new Vercel.VcrRepository("example", new()
    {
        ProjectId = example.Id,
        Name = "my-repository",
    });

    // Share the repository with another team, granting it
    // read (pull) access to the repository's images.
    var exampleVcrRepositoryPermission = new Vercel.VcrRepositoryPermission("example", new()
    {
        ProjectId = example.Id,
        Repository = exampleVcrRepository.Name,
        GrantedTeamId = "team_xxxxxxxxxxxxxxxxxxxxxxxx",
    });

    // The granted team can alternatively be referenced by its slug.
    var exampleBySlug = new Vercel.VcrRepositoryPermission("example_by_slug", new()
    {
        ProjectId = example.Id,
        Repository = exampleVcrRepository.Name,
        GrantedTeamSlug = "my-other-team",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumiverse.vercel.Project;
import com.pulumiverse.vercel.ProjectArgs;
import com.pulumiverse.vercel.VcrRepository;
import com.pulumiverse.vercel.VcrRepositoryArgs;
import com.pulumiverse.vercel.VcrRepositoryPermission;
import com.pulumiverse.vercel.VcrRepositoryPermissionArgs;
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) {
        var example = new Project("example", ProjectArgs.builder()
            .name("example-project-with-vcr-repository")
            .build());

        var exampleVcrRepository = new VcrRepository("exampleVcrRepository", VcrRepositoryArgs.builder()
            .projectId(example.id())
            .name("my-repository")
            .build());

        // Share the repository with another team, granting it
        // read (pull) access to the repository's images.
        var exampleVcrRepositoryPermission = new VcrRepositoryPermission("exampleVcrRepositoryPermission", VcrRepositoryPermissionArgs.builder()
            .projectId(example.id())
            .repository(exampleVcrRepository.name())
            .grantedTeamId("team_xxxxxxxxxxxxxxxxxxxxxxxx")
            .build());

        // The granted team can alternatively be referenced by its slug.
        var exampleBySlug = new VcrRepositoryPermission("exampleBySlug", VcrRepositoryPermissionArgs.builder()
            .projectId(example.id())
            .repository(exampleVcrRepository.name())
            .grantedTeamSlug("my-other-team")
            .build());

    }
}

resources:
  example:
    type: vercel:Project
    properties:
      name: example-project-with-vcr-repository
  exampleVcrRepository:
    type: vercel:VcrRepository
    name: example
    properties:
      projectId: ${example.id}
      name: my-repository
  # Share the repository with another team, granting it
  # read (pull) access to the repository's images.
  exampleVcrRepositoryPermission:
    type: vercel:VcrRepositoryPermission
    name: example
    properties:
      projectId: ${example.id}
      repository: ${exampleVcrRepository.name}
      grantedTeamId: team_xxxxxxxxxxxxxxxxxxxxxxxx
  # The granted team can alternatively be referenced by its slug.
  exampleBySlug:
    type: vercel:VcrRepositoryPermission
    name: example_by_slug
    properties:
      projectId: ${example.id}
      repository: ${exampleVcrRepository.name}
      grantedTeamSlug: my-other-team

var vcrRepositoryPermissionResource = new Vercel.VcrRepositoryPermission("vcrRepositoryPermissionResource", new()
{
    ProjectId = "string",
    Repository = "string",
    GrantedTeamId = "string",
    GrantedTeamSlug = "string",
    TeamId = "string",
});

example, err := vercel.NewVcrRepositoryPermission(ctx, "vcrRepositoryPermissionResource", &vercel.VcrRepositoryPermissionArgs{
	ProjectId:       pulumi.String("string"),
	Repository:      pulumi.String("string"),
	GrantedTeamId:   pulumi.String("string"),
	GrantedTeamSlug: pulumi.String("string"),
	TeamId:          pulumi.String("string"),
})

resource "vercel_vcr_repository_permission" "vcrRepositoryPermissionResource" {
  lifecycle {
    create_before_destroy = true
  }
  project_id        = "string"
  repository        = "string"
  granted_team_id   = "string"
  granted_team_slug = "string"
  team_id           = "string"
}

var vcrRepositoryPermissionResource = new VcrRepositoryPermission("vcrRepositoryPermissionResource", VcrRepositoryPermissionArgs.builder()
    .projectId("string")
    .repository("string")
    .grantedTeamId("string")
    .grantedTeamSlug("string")
    .teamId("string")
    .build());

vcr_repository_permission_resource = vercel.VcrRepositoryPermission("vcrRepositoryPermissionResource",
    project_id="string",
    repository="string",
    granted_team_id="string",
    granted_team_slug="string",
    team_id="string")

const vcrRepositoryPermissionResource = new vercel.VcrRepositoryPermission("vcrRepositoryPermissionResource", {
    projectId: "string",
    repository: "string",
    grantedTeamId: "string",
    grantedTeamSlug: "string",
    teamId: "string",
});

type: vercel:VcrRepositoryPermission
properties:
    grantedTeamId: string
    grantedTeamSlug: string
    projectId: string
    repository: string
    teamId: string