azuredevops.CheckApproval

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

return await Deployment.RunAsync(() => 
{
    var exampleProject = new AzureDevOps.Project("exampleProject");

    var exampleEnvironment = new AzureDevOps.Environment("exampleEnvironment", new()
    {
        ProjectId = exampleProject.Id,
    });

    var exampleGroup = new AzureDevOps.Group("exampleGroup", new()
    {
        DisplayName = "some-azdo-group",
    });

    var exampleCheckApproval = new AzureDevOps.CheckApproval("exampleCheckApproval", new()
    {
        ProjectId = exampleProject.Id,
        TargetResourceId = exampleEnvironment.Id,
        TargetResourceType = "environment",
        RequesterCanApprove = true,
        Approvers = new[]
        {
            exampleGroup.OriginId,
        },
    });

});

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 {
		exampleProject, err := azuredevops.NewProject(ctx, "exampleProject", nil)
		if err != nil {
			return err
		}
		exampleEnvironment, err := azuredevops.NewEnvironment(ctx, "exampleEnvironment", &azuredevops.EnvironmentArgs{
			ProjectId: exampleProject.ID(),
		})
		if err != nil {
			return err
		}
		exampleGroup, err := azuredevops.NewGroup(ctx, "exampleGroup", &azuredevops.GroupArgs{
			DisplayName: pulumi.String("some-azdo-group"),
		})
		if err != nil {
			return err
		}
		_, err = azuredevops.NewCheckApproval(ctx, "exampleCheckApproval", &azuredevops.CheckApprovalArgs{
			ProjectId:           exampleProject.ID(),
			TargetResourceId:    exampleEnvironment.ID(),
			TargetResourceType:  pulumi.String("environment"),
			RequesterCanApprove: pulumi.Bool(true),
			Approvers: pulumi.StringArray{
				exampleGroup.OriginId,
			},
		})
		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.Environment;
import com.pulumi.azuredevops.EnvironmentArgs;
import com.pulumi.azuredevops.Group;
import com.pulumi.azuredevops.GroupArgs;
import com.pulumi.azuredevops.CheckApproval;
import com.pulumi.azuredevops.CheckApprovalArgs;
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 exampleProject = new Project("exampleProject");

        var exampleEnvironment = new Environment("exampleEnvironment", EnvironmentArgs.builder()        
            .projectId(exampleProject.id())
            .build());

        var exampleGroup = new Group("exampleGroup", GroupArgs.builder()        
            .displayName("some-azdo-group")
            .build());

        var exampleCheckApproval = new CheckApproval("exampleCheckApproval", CheckApprovalArgs.builder()        
            .projectId(exampleProject.id())
            .targetResourceId(exampleEnvironment.id())
            .targetResourceType("environment")
            .requesterCanApprove(true)
            .approvers(exampleGroup.originId())
            .build());

    }
}

import pulumi
import pulumi_azuredevops as azuredevops

example_project = azuredevops.Project("exampleProject")
example_environment = azuredevops.Environment("exampleEnvironment", project_id=example_project.id)
example_group = azuredevops.Group("exampleGroup", display_name="some-azdo-group")
example_check_approval = azuredevops.CheckApproval("exampleCheckApproval",
    project_id=example_project.id,
    target_resource_id=example_environment.id,
    target_resource_type="environment",
    requester_can_approve=True,
    approvers=[example_group.origin_id])

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

const exampleProject = new azuredevops.Project("exampleProject", {});
const exampleEnvironment = new azuredevops.Environment("exampleEnvironment", {projectId: exampleProject.id});
const exampleGroup = new azuredevops.Group("exampleGroup", {displayName: "some-azdo-group"});
const exampleCheckApproval = new azuredevops.CheckApproval("exampleCheckApproval", {
    projectId: exampleProject.id,
    targetResourceId: exampleEnvironment.id,
    targetResourceType: "environment",
    requesterCanApprove: true,
    approvers: [exampleGroup.originId],
});

resources:
  exampleProject:
    type: azuredevops:Project
  exampleEnvironment:
    type: azuredevops:Environment
    properties:
      projectId: ${exampleProject.id}
  exampleGroup:
    type: azuredevops:Group
    properties:
      displayName: some-azdo-group
  exampleCheckApproval:
    type: azuredevops:CheckApproval
    properties:
      projectId: ${exampleProject.id}
      targetResourceId: ${exampleEnvironment.id}
      targetResourceType: environment
      requesterCanApprove: true
      approvers:
        - ${exampleGroup.originId}