github.TeamSettings

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

// Add a repository to the team
const someTeam = new github.Team("someTeam", {description: "Some cool team"});
const codeReviewSettings = new github.TeamSettings("codeReviewSettings", {
    teamId: someTeam.id,
    reviewRequestDelegation: {
        algorithm: "ROUND_ROBIN",
        memberCount: 1,
        notify: true,
    },
});

import pulumi
import pulumi_github as github

# Add a repository to the team
some_team = github.Team("someTeam", description="Some cool team")
code_review_settings = github.TeamSettings("codeReviewSettings",
    team_id=some_team.id,
    review_request_delegation=github.TeamSettingsReviewRequestDelegationArgs(
        algorithm="ROUND_ROBIN",
        member_count=1,
        notify=True,
    ))

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Add a repository to the team
		someTeam, err := github.NewTeam(ctx, "someTeam", &github.TeamArgs{
			Description: pulumi.String("Some cool team"),
		})
		if err != nil {
			return err
		}
		_, err = github.NewTeamSettings(ctx, "codeReviewSettings", &github.TeamSettingsArgs{
			TeamId: someTeam.ID(),
			ReviewRequestDelegation: &github.TeamSettingsReviewRequestDelegationArgs{
				Algorithm:   pulumi.String("ROUND_ROBIN"),
				MemberCount: pulumi.Int(1),
				Notify:      pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Add a repository to the team
    var someTeam = new Github.Team("someTeam", new()
    {
        Description = "Some cool team",
    });

    var codeReviewSettings = new Github.TeamSettings("codeReviewSettings", new()
    {
        TeamId = someTeam.Id,
        ReviewRequestDelegation = new Github.Inputs.TeamSettingsReviewRequestDelegationArgs
        {
            Algorithm = "ROUND_ROBIN",
            MemberCount = 1,
            Notify = true,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.github.Team;
import com.pulumi.github.TeamArgs;
import com.pulumi.github.TeamSettings;
import com.pulumi.github.TeamSettingsArgs;
import com.pulumi.github.inputs.TeamSettingsReviewRequestDelegationArgs;
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 someTeam = new Team("someTeam", TeamArgs.builder()        
            .description("Some cool team")
            .build());

        var codeReviewSettings = new TeamSettings("codeReviewSettings", TeamSettingsArgs.builder()        
            .teamId(someTeam.id())
            .reviewRequestDelegation(TeamSettingsReviewRequestDelegationArgs.builder()
                .algorithm("ROUND_ROBIN")
                .memberCount(1)
                .notify(true)
                .build())
            .build());

    }
}

resources:
  # Add a repository to the team
  someTeam:
    type: github:Team
    properties:
      description: Some cool team
  codeReviewSettings:
    type: github:TeamSettings
    properties:
      teamId: ${someTeam.id}
      reviewRequestDelegation:
        algorithm: ROUND_ROBIN
        memberCount: 1
        notify: true

var teamSettingsResource = new Github.TeamSettings("teamSettingsResource", new()
{
    TeamId = "string",
    ReviewRequestDelegation = new Github.Inputs.TeamSettingsReviewRequestDelegationArgs
    {
        Algorithm = "string",
        MemberCount = 0,
        Notify = false,
    },
});

example, err := github.NewTeamSettings(ctx, "teamSettingsResource", &github.TeamSettingsArgs{
	TeamId: pulumi.String("string"),
	ReviewRequestDelegation: &github.TeamSettingsReviewRequestDelegationArgs{
		Algorithm:   pulumi.String("string"),
		MemberCount: pulumi.Int(0),
		Notify:      pulumi.Bool(false),
	},
})

var teamSettingsResource = new TeamSettings("teamSettingsResource", TeamSettingsArgs.builder()        
    .teamId("string")
    .reviewRequestDelegation(TeamSettingsReviewRequestDelegationArgs.builder()
        .algorithm("string")
        .memberCount(0)
        .notify(false)
        .build())
    .build());

team_settings_resource = github.TeamSettings("teamSettingsResource",
    team_id="string",
    review_request_delegation=github.TeamSettingsReviewRequestDelegationArgs(
        algorithm="string",
        member_count=0,
        notify=False,
    ))

const teamSettingsResource = new github.TeamSettings("teamSettingsResource", {
    teamId: "string",
    reviewRequestDelegation: {
        algorithm: "string",
        memberCount: 0,
        notify: false,
    },
});

type: github:TeamSettings
properties:
    reviewRequestDelegation:
        algorithm: string
        memberCount: 0
        notify: false
    teamId: string