github.BranchProtection

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

const exampleRepository = new github.Repository("example", {name: "test"});
const example = github.getUser({
    username: "example",
});
const exampleTeam = new github.Team("example", {name: "Example Name"});
// 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 exampleBranchProtection = new github.BranchProtection("example", {
    repositoryId: exampleRepository.nodeId,
    pattern: "main",
    enforceAdmins: true,
    allowsDeletions: true,
    requiredStatusChecks: [{
        strict: false,
        contexts: ["ci/travis"],
    }],
    requiredPullRequestReviews: [{
        dismissStaleReviews: true,
        restrictDismissals: true,
        dismissalRestrictions: [
            example.then(example => example.nodeId),
            exampleTeam.nodeId,
            "/exampleuser",
            "exampleorganization/exampleteam",
        ],
    }],
    restrictPushes: [{
        pushAllowances: [
            example.then(example => example.nodeId),
            "/exampleuser",
            "exampleorganization/exampleteam",
        ],
    }],
    forcePushBypassers: [
        example.then(example => example.nodeId),
        "/exampleuser",
        "exampleorganization/exampleteam",
    ],
});
const exampleTeamRepository = new github.TeamRepository("example", {
    teamId: exampleTeam.id,
    repository: exampleRepository.name,
    permission: "pull",
});

import pulumi
import pulumi_github as github

example_repository = github.Repository("example", name="test")
example = github.get_user(username="example")
example_team = github.Team("example", name="Example Name")
# 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 = github.BranchProtection("example",
    repository_id=example_repository.node_id,
    pattern="main",
    enforce_admins=True,
    allows_deletions=True,
    required_status_checks=[{
        "strict": False,
        "contexts": ["ci/travis"],
    }],
    required_pull_request_reviews=[{
        "dismiss_stale_reviews": True,
        "restrict_dismissals": True,
        "dismissal_restrictions": [
            example.node_id,
            example_team.node_id,
            "/exampleuser",
            "exampleorganization/exampleteam",
        ],
    }],
    restrict_pushes=[{
        "push_allowances": [
            example.node_id,
            "/exampleuser",
            "exampleorganization/exampleteam",
        ],
    }],
    force_push_bypassers=[
        example.node_id,
        "/exampleuser",
        "exampleorganization/exampleteam",
    ])
example_team_repository = github.TeamRepository("example",
    team_id=example_team.id,
    repository=example_repository.name,
    permission="pull")

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 {
		exampleRepository, err := github.NewRepository(ctx, "example", &github.RepositoryArgs{
			Name: pulumi.String("test"),
		})
		if err != nil {
			return err
		}
		example, err := github.GetUser(ctx, &github.GetUserArgs{
			Username: "example",
		}, nil)
		if err != nil {
			return err
		}
		exampleTeam, err := github.NewTeam(ctx, "example", &github.TeamArgs{
			Name: pulumi.String("Example Name"),
		})
		if err != nil {
			return err
		}
		// 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.
		_, err = github.NewBranchProtection(ctx, "example", &github.BranchProtectionArgs{
			RepositoryId:    exampleRepository.NodeId,
			Pattern:         pulumi.String("main"),
			EnforceAdmins:   pulumi.Bool(true),
			AllowsDeletions: pulumi.Bool(true),
			RequiredStatusChecks: github.BranchProtectionRequiredStatusCheckArray{
				&github.BranchProtectionRequiredStatusCheckArgs{
					Strict: pulumi.Bool(false),
					Contexts: pulumi.StringArray{
						pulumi.String("ci/travis"),
					},
				},
			},
			RequiredPullRequestReviews: github.BranchProtectionRequiredPullRequestReviewArray{
				&github.BranchProtectionRequiredPullRequestReviewArgs{
					DismissStaleReviews: pulumi.Bool(true),
					RestrictDismissals:  pulumi.Bool(true),
					DismissalRestrictions: pulumi.StringArray{
						pulumi.String(example.NodeId),
						exampleTeam.NodeId,
						pulumi.String("/exampleuser"),
						pulumi.String("exampleorganization/exampleteam"),
					},
				},
			},
			RestrictPushes: github.BranchProtectionRestrictPushArray{
				&github.BranchProtectionRestrictPushArgs{
					PushAllowances: pulumi.StringArray{
						pulumi.String(example.NodeId),
						pulumi.String("/exampleuser"),
						pulumi.String("exampleorganization/exampleteam"),
					},
				},
			},
			ForcePushBypassers: pulumi.StringArray{
				pulumi.String(example.NodeId),
				pulumi.String("/exampleuser"),
				pulumi.String("exampleorganization/exampleteam"),
			},
		})
		if err != nil {
			return err
		}
		_, err = github.NewTeamRepository(ctx, "example", &github.TeamRepositoryArgs{
			TeamId:     exampleTeam.ID(),
			Repository: exampleRepository.Name,
			Permission: pulumi.String("pull"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var exampleRepository = new Github.Repository("example", new()
    {
        Name = "test",
    });

    var example = Github.GetUser.Invoke(new()
    {
        Username = "example",
    });

    var exampleTeam = new Github.Team("example", new()
    {
        Name = "Example Name",
    });

    // 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 exampleBranchProtection = new Github.BranchProtection("example", new()
    {
        RepositoryId = exampleRepository.NodeId,
        Pattern = "main",
        EnforceAdmins = true,
        AllowsDeletions = true,
        RequiredStatusChecks = new[]
        {
            new Github.Inputs.BranchProtectionRequiredStatusCheckArgs
            {
                Strict = false,
                Contexts = new[]
                {
                    "ci/travis",
                },
            },
        },
        RequiredPullRequestReviews = new[]
        {
            new Github.Inputs.BranchProtectionRequiredPullRequestReviewArgs
            {
                DismissStaleReviews = true,
                RestrictDismissals = true,
                DismissalRestrictions = new[]
                {
                    example.Apply(getUserResult => getUserResult.NodeId),
                    exampleTeam.NodeId,
                    "/exampleuser",
                    "exampleorganization/exampleteam",
                },
            },
        },
        RestrictPushes = new[]
        {
            new Github.Inputs.BranchProtectionRestrictPushArgs
            {
                PushAllowances = new[]
                {
                    example.Apply(getUserResult => getUserResult.NodeId),
                    "/exampleuser",
                    "exampleorganization/exampleteam",
                },
            },
        },
        ForcePushBypassers = new[]
        {
            example.Apply(getUserResult => getUserResult.NodeId),
            "/exampleuser",
            "exampleorganization/exampleteam",
        },
    });

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

});

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.RepositoryArgs;
import com.pulumi.github.GithubFunctions;
import com.pulumi.github.inputs.GetUserArgs;
import com.pulumi.github.Team;
import com.pulumi.github.TeamArgs;
import com.pulumi.github.BranchProtection;
import com.pulumi.github.BranchProtectionArgs;
import com.pulumi.github.inputs.BranchProtectionRequiredStatusCheckArgs;
import com.pulumi.github.inputs.BranchProtectionRequiredPullRequestReviewArgs;
import com.pulumi.github.inputs.BranchProtectionRestrictPushArgs;
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", RepositoryArgs.builder()
            .name("test")
            .build());

        final var example = GithubFunctions.getUser(GetUserArgs.builder()
            .username("example")
            .build());

        var exampleTeam = new Team("exampleTeam", TeamArgs.builder()
            .name("Example Name")
            .build());

        // 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 exampleBranchProtection = new BranchProtection("exampleBranchProtection", BranchProtectionArgs.builder()
            .repositoryId(exampleRepository.nodeId())
            .pattern("main")
            .enforceAdmins(true)
            .allowsDeletions(true)
            .requiredStatusChecks(BranchProtectionRequiredStatusCheckArgs.builder()
                .strict(false)
                .contexts("ci/travis")
                .build())
            .requiredPullRequestReviews(BranchProtectionRequiredPullRequestReviewArgs.builder()
                .dismissStaleReviews(true)
                .restrictDismissals(true)
                .dismissalRestrictions(                
                    example.applyValue(getUserResult -> getUserResult.nodeId()),
                    exampleTeam.nodeId(),
                    "/exampleuser",
                    "exampleorganization/exampleteam")
                .build())
            .restrictPushes(BranchProtectionRestrictPushArgs.builder()
                .pushAllowances(                
                    example.applyValue(getUserResult -> getUserResult.nodeId()),
                    "/exampleuser",
                    "exampleorganization/exampleteam")
                .build())
            .forcePushBypassers(            
                example.applyValue(getUserResult -> getUserResult.nodeId()),
                "/exampleuser",
                "exampleorganization/exampleteam")
            .build());

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

    }
}

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.
  exampleBranchProtection:
    type: github:BranchProtection
    name: example
    properties:
      repositoryId: ${exampleRepository.nodeId}
      pattern: main
      enforceAdmins: true
      allowsDeletions: true
      requiredStatusChecks:
        - strict: false
          contexts:
            - ci/travis
      requiredPullRequestReviews:
        - dismissStaleReviews: true
          restrictDismissals: true
          dismissalRestrictions:
            - ${example.nodeId}
            - ${exampleTeam.nodeId}
            - /exampleuser
            - exampleorganization/exampleteam
      restrictPushes:
        - pushAllowances:
            - ${example.nodeId}
            - /exampleuser
            - exampleorganization/exampleteam
      forcePushBypassers:
        - ${example.nodeId}
        - /exampleuser
        - exampleorganization/exampleteam
  exampleRepository:
    type: github:Repository
    name: example
    properties:
      name: test
  exampleTeam:
    type: github:Team
    name: example
    properties:
      name: Example Name
  exampleTeamRepository:
    type: github:TeamRepository
    name: example
    properties:
      teamId: ${exampleTeam.id}
      repository: ${exampleRepository.name}
      permission: pull
variables:
  example:
    fn::invoke:
      function: github:getUser
      arguments:
        username: example

var branchProtectionResource = new Github.BranchProtection("branchProtectionResource", new()
{
    Pattern = "string",
    RepositoryId = "string",
    ForcePushBypassers = new[]
    {
        "string",
    },
    AllowsDeletions = false,
    LockBranch = false,
    EnforceAdmins = false,
    AllowsForcePushes = false,
    RequireConversationResolution = false,
    RequireSignedCommits = false,
    RequiredLinearHistory = false,
    RequiredPullRequestReviews = new[]
    {
        new Github.Inputs.BranchProtectionRequiredPullRequestReviewArgs
        {
            DismissStaleReviews = false,
            DismissalRestrictions = new[]
            {
                "string",
            },
            PullRequestBypassers = new[]
            {
                "string",
            },
            RequireCodeOwnerReviews = false,
            RequireLastPushApproval = false,
            RequiredApprovingReviewCount = 0,
            RestrictDismissals = false,
        },
    },
    RequiredStatusChecks = new[]
    {
        new Github.Inputs.BranchProtectionRequiredStatusCheckArgs
        {
            Contexts = new[]
            {
                "string",
            },
            Strict = false,
        },
    },
    RestrictPushes = new[]
    {
        new Github.Inputs.BranchProtectionRestrictPushArgs
        {
            BlocksCreations = false,
            PushAllowances = new[]
            {
                "string",
            },
        },
    },
});

example, err := github.NewBranchProtection(ctx, "branchProtectionResource", &github.BranchProtectionArgs{
	Pattern:      pulumi.String("string"),
	RepositoryId: pulumi.String("string"),
	ForcePushBypassers: pulumi.StringArray{
		pulumi.String("string"),
	},
	AllowsDeletions:               pulumi.Bool(false),
	LockBranch:                    pulumi.Bool(false),
	EnforceAdmins:                 pulumi.Bool(false),
	AllowsForcePushes:             pulumi.Bool(false),
	RequireConversationResolution: pulumi.Bool(false),
	RequireSignedCommits:          pulumi.Bool(false),
	RequiredLinearHistory:         pulumi.Bool(false),
	RequiredPullRequestReviews: github.BranchProtectionRequiredPullRequestReviewArray{
		&github.BranchProtectionRequiredPullRequestReviewArgs{
			DismissStaleReviews: pulumi.Bool(false),
			DismissalRestrictions: pulumi.StringArray{
				pulumi.String("string"),
			},
			PullRequestBypassers: pulumi.StringArray{
				pulumi.String("string"),
			},
			RequireCodeOwnerReviews:      pulumi.Bool(false),
			RequireLastPushApproval:      pulumi.Bool(false),
			RequiredApprovingReviewCount: pulumi.Int(0),
			RestrictDismissals:           pulumi.Bool(false),
		},
	},
	RequiredStatusChecks: github.BranchProtectionRequiredStatusCheckArray{
		&github.BranchProtectionRequiredStatusCheckArgs{
			Contexts: pulumi.StringArray{
				pulumi.String("string"),
			},
			Strict: pulumi.Bool(false),
		},
	},
	RestrictPushes: github.BranchProtectionRestrictPushArray{
		&github.BranchProtectionRestrictPushArgs{
			BlocksCreations: pulumi.Bool(false),
			PushAllowances: pulumi.StringArray{
				pulumi.String("string"),
			},
		},
	},
})

var branchProtectionResource = new BranchProtection("branchProtectionResource", BranchProtectionArgs.builder()
    .pattern("string")
    .repositoryId("string")
    .forcePushBypassers("string")
    .allowsDeletions(false)
    .lockBranch(false)
    .enforceAdmins(false)
    .allowsForcePushes(false)
    .requireConversationResolution(false)
    .requireSignedCommits(false)
    .requiredLinearHistory(false)
    .requiredPullRequestReviews(BranchProtectionRequiredPullRequestReviewArgs.builder()
        .dismissStaleReviews(false)
        .dismissalRestrictions("string")
        .pullRequestBypassers("string")
        .requireCodeOwnerReviews(false)
        .requireLastPushApproval(false)
        .requiredApprovingReviewCount(0)
        .restrictDismissals(false)
        .build())
    .requiredStatusChecks(BranchProtectionRequiredStatusCheckArgs.builder()
        .contexts("string")
        .strict(false)
        .build())
    .restrictPushes(BranchProtectionRestrictPushArgs.builder()
        .blocksCreations(false)
        .pushAllowances("string")
        .build())
    .build());

branch_protection_resource = github.BranchProtection("branchProtectionResource",
    pattern="string",
    repository_id="string",
    force_push_bypassers=["string"],
    allows_deletions=False,
    lock_branch=False,
    enforce_admins=False,
    allows_force_pushes=False,
    require_conversation_resolution=False,
    require_signed_commits=False,
    required_linear_history=False,
    required_pull_request_reviews=[{
        "dismiss_stale_reviews": False,
        "dismissal_restrictions": ["string"],
        "pull_request_bypassers": ["string"],
        "require_code_owner_reviews": False,
        "require_last_push_approval": False,
        "required_approving_review_count": 0,
        "restrict_dismissals": False,
    }],
    required_status_checks=[{
        "contexts": ["string"],
        "strict": False,
    }],
    restrict_pushes=[{
        "blocks_creations": False,
        "push_allowances": ["string"],
    }])

const branchProtectionResource = new github.BranchProtection("branchProtectionResource", {
    pattern: "string",
    repositoryId: "string",
    forcePushBypassers: ["string"],
    allowsDeletions: false,
    lockBranch: false,
    enforceAdmins: false,
    allowsForcePushes: false,
    requireConversationResolution: false,
    requireSignedCommits: false,
    requiredLinearHistory: false,
    requiredPullRequestReviews: [{
        dismissStaleReviews: false,
        dismissalRestrictions: ["string"],
        pullRequestBypassers: ["string"],
        requireCodeOwnerReviews: false,
        requireLastPushApproval: false,
        requiredApprovingReviewCount: 0,
        restrictDismissals: false,
    }],
    requiredStatusChecks: [{
        contexts: ["string"],
        strict: false,
    }],
    restrictPushes: [{
        blocksCreations: false,
        pushAllowances: ["string"],
    }],
});

type: github:BranchProtection
properties:
    allowsDeletions: false
    allowsForcePushes: false
    enforceAdmins: false
    forcePushBypassers:
        - string
    lockBranch: false
    pattern: string
    repositoryId: string
    requireConversationResolution: false
    requireSignedCommits: false
    requiredLinearHistory: false
    requiredPullRequestReviews:
        - dismissStaleReviews: false
          dismissalRestrictions:
            - string
          pullRequestBypassers:
            - string
          requireCodeOwnerReviews: false
          requireLastPushApproval: false
          requiredApprovingReviewCount: 0
          restrictDismissals: false
    requiredStatusChecks:
        - contexts:
            - string
          strict: false
    restrictPushes:
        - blocksCreations: false
          pushAllowances:
            - string