github.BranchProtectionV3

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

return await Deployment.RunAsync(() => 
{
    // Protect the main branch of the foo repository. Only allow a specific user to merge to the branch.
    var example = new Github.BranchProtectionV3("example", new()
    {
        Repository = github_repository.Example.Name,
        Branch = "main",
        Restrictions = new Github.Inputs.BranchProtectionV3RestrictionsArgs
        {
            Users = new[]
            {
                "foo-user",
            },
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := github.NewBranchProtectionV3(ctx, "example", &github.BranchProtectionV3Args{
			Repository: pulumi.Any(github_repository.Example.Name),
			Branch:     pulumi.String("main"),
			Restrictions: &BranchProtectionV3RestrictionsArgs{
				Users: pulumi.StringArray{
					pulumi.String("foo-user"),
				},
			},
		})
		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.github.BranchProtectionV3;
import com.pulumi.github.BranchProtectionV3Args;
import com.pulumi.github.inputs.BranchProtectionV3RestrictionsArgs;
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 BranchProtectionV3("example", BranchProtectionV3Args.builder()        
            .repository(github_repository.example().name())
            .branch("main")
            .restrictions(BranchProtectionV3RestrictionsArgs.builder()
                .users("foo-user")
                .build())
            .build());

    }
}

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

// Protect the main branch of the foo repository. Only allow a specific user to merge to the branch.
const example = new github.BranchProtectionV3("example", {
    repository: github_repository.example.name,
    branch: "main",
    restrictions: {
        users: ["foo-user"],
    },
});

import pulumi
import pulumi_github as github

# Protect the main branch of the foo repository. Only allow a specific user to merge to the branch.
example = github.BranchProtectionV3("example",
    repository=github_repository["example"]["name"],
    branch="main",
    restrictions=github.BranchProtectionV3RestrictionsArgs(
        users=["foo-user"],
    ))

resources:
  # Protect the main branch of the foo repository. Only allow a specific user to merge to the branch.
  example:
    type: github:BranchProtectionV3
    properties:
      repository: ${github_repository.example.name}
      branch: main
      restrictions:
        users:
          - foo-user

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

return await Deployment.RunAsync(() => 
{
    var exampleRepository = new Github.Repository("exampleRepository");

    var exampleTeam = new Github.Team("exampleTeam");

    // Protect the main branch of the foo repository. Additionally, require that
    // the "ci/travis" context to be passing and only allow the engineers team merge
    // to the branch.
    var exampleBranchProtectionV3 = new Github.BranchProtectionV3("exampleBranchProtectionV3", new()
    {
        Repository = exampleRepository.Name,
        Branch = "main",
        EnforceAdmins = true,
        RequiredStatusChecks = new Github.Inputs.BranchProtectionV3RequiredStatusChecksArgs
        {
            Strict = false,
            Contexts = new[]
            {
                "ci/travis",
            },
        },
        RequiredPullRequestReviews = new Github.Inputs.BranchProtectionV3RequiredPullRequestReviewsArgs
        {
            DismissStaleReviews = true,
            DismissalUsers = new[]
            {
                "foo-user",
            },
            DismissalTeams = new[]
            {
                exampleTeam.Slug,
            },
        },
        Restrictions = new Github.Inputs.BranchProtectionV3RestrictionsArgs
        {
            Users = new[]
            {
                "foo-user",
            },
            Teams = new[]
            {
                exampleTeam.Slug,
            },
            Apps = new[]
            {
                "foo-app",
            },
        },
    });

    var exampleTeamRepository = new Github.TeamRepository("exampleTeamRepository", new()
    {
        TeamId = exampleTeam.Id,
        Repository = exampleRepository.Name,
        Permission = "pull",
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleRepository, err := github.NewRepository(ctx, "exampleRepository", nil)
		if err != nil {
			return err
		}
		exampleTeam, err := github.NewTeam(ctx, "exampleTeam", nil)
		if err != nil {
			return err
		}
		_, err = github.NewBranchProtectionV3(ctx, "exampleBranchProtectionV3", &github.BranchProtectionV3Args{
			Repository:    exampleRepository.Name,
			Branch:        pulumi.String("main"),
			EnforceAdmins: pulumi.Bool(true),
			RequiredStatusChecks: &BranchProtectionV3RequiredStatusChecksArgs{
				Strict: pulumi.Bool(false),
				Contexts: pulumi.StringArray{
					pulumi.String("ci/travis"),
				},
			},
			RequiredPullRequestReviews: &BranchProtectionV3RequiredPullRequestReviewsArgs{
				DismissStaleReviews: pulumi.Bool(true),
				DismissalUsers: pulumi.StringArray{
					pulumi.String("foo-user"),
				},
				DismissalTeams: pulumi.StringArray{
					exampleTeam.Slug,
				},
			},
			Restrictions: &BranchProtectionV3RestrictionsArgs{
				Users: pulumi.StringArray{
					pulumi.String("foo-user"),
				},
				Teams: pulumi.StringArray{
					exampleTeam.Slug,
				},
				Apps: pulumi.StringArray{
					pulumi.String("foo-app"),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = github.NewTeamRepository(ctx, "exampleTeamRepository", &github.TeamRepositoryArgs{
			TeamId:     exampleTeam.ID(),
			Repository: exampleRepository.Name,
			Permission: pulumi.String("pull"),
		})
		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.github.Repository;
import com.pulumi.github.Team;
import com.pulumi.github.BranchProtectionV3;
import com.pulumi.github.BranchProtectionV3Args;
import com.pulumi.github.inputs.BranchProtectionV3RequiredStatusChecksArgs;
import com.pulumi.github.inputs.BranchProtectionV3RequiredPullRequestReviewsArgs;
import com.pulumi.github.inputs.BranchProtectionV3RestrictionsArgs;
import com.pulumi.github.TeamRepository;
import com.pulumi.github.TeamRepositoryArgs;
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 exampleRepository = new Repository("exampleRepository");

        var exampleTeam = new Team("exampleTeam");

        var exampleBranchProtectionV3 = new BranchProtectionV3("exampleBranchProtectionV3", BranchProtectionV3Args.builder()        
            .repository(exampleRepository.name())
            .branch("main")
            .enforceAdmins(true)
            .requiredStatusChecks(BranchProtectionV3RequiredStatusChecksArgs.builder()
                .strict(false)
                .contexts("ci/travis")
                .build())
            .requiredPullRequestReviews(BranchProtectionV3RequiredPullRequestReviewsArgs.builder()
                .dismissStaleReviews(true)
                .dismissalUsers("foo-user")
                .dismissalTeams(exampleTeam.slug())
                .build())
            .restrictions(BranchProtectionV3RestrictionsArgs.builder()
                .users("foo-user")
                .teams(exampleTeam.slug())
                .apps("foo-app")
                .build())
            .build());

        var exampleTeamRepository = new TeamRepository("exampleTeamRepository", TeamRepositoryArgs.builder()        
            .teamId(exampleTeam.id())
            .repository(exampleRepository.name())
            .permission("pull")
            .build());

    }
}

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

const exampleRepository = new github.Repository("exampleRepository", {});
const exampleTeam = new github.Team("exampleTeam", {});
// Protect the main branch of the foo repository. Additionally, require that
// the "ci/travis" context to be passing and only allow the engineers team merge
// to the branch.
const exampleBranchProtectionV3 = new github.BranchProtectionV3("exampleBranchProtectionV3", {
    repository: exampleRepository.name,
    branch: "main",
    enforceAdmins: true,
    requiredStatusChecks: {
        strict: false,
        contexts: ["ci/travis"],
    },
    requiredPullRequestReviews: {
        dismissStaleReviews: true,
        dismissalUsers: ["foo-user"],
        dismissalTeams: [exampleTeam.slug],
    },
    restrictions: {
        users: ["foo-user"],
        teams: [exampleTeam.slug],
        apps: ["foo-app"],
    },
});
const exampleTeamRepository = new github.TeamRepository("exampleTeamRepository", {
    teamId: exampleTeam.id,
    repository: exampleRepository.name,
    permission: "pull",
});

import pulumi
import pulumi_github as github

example_repository = github.Repository("exampleRepository")
example_team = github.Team("exampleTeam")
# Protect the main branch of the foo repository. Additionally, require that
# the "ci/travis" context to be passing and only allow the engineers team merge
# to the branch.
example_branch_protection_v3 = github.BranchProtectionV3("exampleBranchProtectionV3",
    repository=example_repository.name,
    branch="main",
    enforce_admins=True,
    required_status_checks=github.BranchProtectionV3RequiredStatusChecksArgs(
        strict=False,
        contexts=["ci/travis"],
    ),
    required_pull_request_reviews=github.BranchProtectionV3RequiredPullRequestReviewsArgs(
        dismiss_stale_reviews=True,
        dismissal_users=["foo-user"],
        dismissal_teams=[example_team.slug],
    ),
    restrictions=github.BranchProtectionV3RestrictionsArgs(
        users=["foo-user"],
        teams=[example_team.slug],
        apps=["foo-app"],
    ))
example_team_repository = github.TeamRepository("exampleTeamRepository",
    team_id=example_team.id,
    repository=example_repository.name,
    permission="pull")

resources:
  # Protect the main branch of the foo repository. Additionally, require that
  # the "ci/travis" context to be passing and only allow the engineers team merge
  # to the branch.
  exampleBranchProtectionV3:
    type: github:BranchProtectionV3
    properties:
      repository: ${exampleRepository.name}
      branch: main
      enforceAdmins: true
      requiredStatusChecks:
        strict: false
        contexts:
          - ci/travis
      requiredPullRequestReviews:
        dismissStaleReviews: true
        dismissalUsers:
          - foo-user
        dismissalTeams:
          - ${exampleTeam.slug}
      restrictions:
        users:
          - foo-user
        teams:
          - ${exampleTeam.slug}
        apps:
          - foo-app
  exampleRepository:
    type: github:Repository
  exampleTeam:
    type: github:Team
  exampleTeamRepository:
    type: github:TeamRepository
    properties:
      teamId: ${exampleTeam.id}
      repository: ${exampleRepository.name}
      permission: pull