azuredevops.ProjectPermissions

using System.Collections.Generic;
using Pulumi;
using AzureDevOps = Pulumi.AzureDevOps;

return await Deployment.RunAsync(() => 
{
    var example = new AzureDevOps.Project("example", new()
    {
        Visibility = "private",
        VersionControl = "Git",
        WorkItemTemplate = "Agile",
        Description = "Managed by Terraform",
    });

    var example_readers = AzureDevOps.GetGroup.Invoke(new()
    {
        ProjectId = example.Id,
        Name = "Readers",
    });

    var example_permission = new AzureDevOps.ProjectPermissions("example-permission", new()
    {
        ProjectId = example.Id,
        Principal = example_readers.Apply(example_readers => example_readers.Apply(getGroupResult => getGroupResult.Id)),
        Permissions = 
        {
            { "DELETE", "Deny" },
            { "EDIT_BUILD_STATUS", "NotSet" },
            { "WORK_ITEM_MOVE", "Allow" },
            { "DELETE_TEST_RESULTS", "Deny" },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-azuredevops/sdk/v2/go/azuredevops"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := azuredevops.NewProject(ctx, "example", &azuredevops.ProjectArgs{
			Visibility:       pulumi.String("private"),
			VersionControl:   pulumi.String("Git"),
			WorkItemTemplate: pulumi.String("Agile"),
			Description:      pulumi.String("Managed by Terraform"),
		})
		if err != nil {
			return err
		}
		example_readers := azuredevops.LookupGroupOutput(ctx, azuredevops.GetGroupOutputArgs{
			ProjectId: example.ID(),
			Name:      pulumi.String("Readers"),
		}, nil)
		_, err = azuredevops.NewProjectPermissions(ctx, "example-permission", &azuredevops.ProjectPermissionsArgs{
			ProjectId: example.ID(),
			Principal: example_readers.ApplyT(func(example_readers azuredevops.GetGroupResult) (*string, error) {
				return &example_readers.Id, nil
			}).(pulumi.StringPtrOutput),
			Permissions: pulumi.StringMap{
				"DELETE":              pulumi.String("Deny"),
				"EDIT_BUILD_STATUS":   pulumi.String("NotSet"),
				"WORK_ITEM_MOVE":      pulumi.String("Allow"),
				"DELETE_TEST_RESULTS": pulumi.String("Deny"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azuredevops.Project;
import com.pulumi.azuredevops.ProjectArgs;
import com.pulumi.azuredevops.AzuredevopsFunctions;
import com.pulumi.azuredevops.inputs.GetGroupArgs;
import com.pulumi.azuredevops.ProjectPermissions;
import com.pulumi.azuredevops.ProjectPermissionsArgs;
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()        
            .visibility("private")
            .versionControl("Git")
            .workItemTemplate("Agile")
            .description("Managed by Terraform")
            .build());

        final var example-readers = AzuredevopsFunctions.getGroup(GetGroupArgs.builder()
            .projectId(example.id())
            .name("Readers")
            .build());

        var example_permission = new ProjectPermissions("example-permission", ProjectPermissionsArgs.builder()        
            .projectId(example.id())
            .principal(example_readers.applyValue(example_readers -> example_readers.id()))
            .permissions(Map.ofEntries(
                Map.entry("DELETE", "Deny"),
                Map.entry("EDIT_BUILD_STATUS", "NotSet"),
                Map.entry("WORK_ITEM_MOVE", "Allow"),
                Map.entry("DELETE_TEST_RESULTS", "Deny")
            ))
            .build());

    }
}

import pulumi
import pulumi_azuredevops as azuredevops

example = azuredevops.Project("example",
    visibility="private",
    version_control="Git",
    work_item_template="Agile",
    description="Managed by Terraform")
example_readers = azuredevops.get_group_output(project_id=example.id,
    name="Readers")
example_permission = azuredevops.ProjectPermissions("example-permission",
    project_id=example.id,
    principal=example_readers.id,
    permissions={
        "DELETE": "Deny",
        "EDIT_BUILD_STATUS": "NotSet",
        "WORK_ITEM_MOVE": "Allow",
        "DELETE_TEST_RESULTS": "Deny",
    })

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

const example = new azuredevops.Project("example", {
    visibility: "private",
    versionControl: "Git",
    workItemTemplate: "Agile",
    description: "Managed by Terraform",
});
const example-readers = azuredevops.getGroupOutput({
    projectId: example.id,
    name: "Readers",
});
const example_permission = new azuredevops.ProjectPermissions("example-permission", {
    projectId: example.id,
    principal: example_readers.apply(example_readers => example_readers.id),
    permissions: {
        DELETE: "Deny",
        EDIT_BUILD_STATUS: "NotSet",
        WORK_ITEM_MOVE: "Allow",
        DELETE_TEST_RESULTS: "Deny",
    },
});

resources:
  example:
    type: azuredevops:Project
    properties:
      visibility: private
      versionControl: Git
      workItemTemplate: Agile
      description: Managed by Terraform
  example-permission:
    type: azuredevops:ProjectPermissions
    properties:
      projectId: ${example.id}
      principal: ${["example-readers"].id}
      permissions:
        DELETE: Deny
        EDIT_BUILD_STATUS: NotSet
        WORK_ITEM_MOVE: Allow
        DELETE_TEST_RESULTS: Deny
variables:
  example-readers:
    fn::invoke:
      Function: azuredevops:getGroup
      Arguments:
        projectId: ${example.id}
        name: Readers