pulumi-github-kotlin/com.pulumi.github.kotlin/TeamMembershipArgs

TeamMembershipArgs

data class TeamMembershipArgs(val role: Output<String>? = null, val teamId: Output<String>? = null, val username: Output<String>? = null) : ConvertibleToJava<TeamMembershipArgs>

Provides a GitHub team membership resource. This resource allows you to add/remove users from teams in your organization. When applied, the user will be added to the team. If the user hasn't accepted their invitation to the organization, they won't be part of the team until they do. When destroyed, the user will be removed from the team.

Note This resource is not compatible with github.TeamMembers. Use either github.TeamMembers or github.TeamMembership. Note Organization owners may not be set as "members" of a team; they may only be set as "maintainers". Attempting to set an organization owner as a "member" of a team may result in a pulumi preview diff that changes their status back to "maintainer".

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as github from "@pulumi/github";
// Add a user to the organization
const membershipForSomeUser = new github.Membership("membership_for_some_user", {
    username: "SomeUser",
    role: "member",
});
const someTeam = new github.Team("some_team", {
    name: "SomeTeam",
    description: "Some cool team",
});
const someTeamMembership = new github.TeamMembership("some_team_membership", {
    teamId: someTeam.id,
    username: "SomeUser",
    role: "member",
});

import pulumi
import pulumi_github as github
# Add a user to the organization
membership_for_some_user = github.Membership("membership_for_some_user",
    username="SomeUser",
    role="member")
some_team = github.Team("some_team",
    name="SomeTeam",
    description="Some cool team")
some_team_membership = github.TeamMembership("some_team_membership",
    team_id=some_team.id,
    username="SomeUser",
    role="member")

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Github = Pulumi.Github;
return await Deployment.RunAsync(() =>
{
    // Add a user to the organization
    var membershipForSomeUser = new Github.Membership("membership_for_some_user", new()
    {
        Username = "SomeUser",
        Role = "member",
    });
    var someTeam = new Github.Team("some_team", new()
    {
        Name = "SomeTeam",
        Description = "Some cool team",
    });
    var someTeamMembership = new Github.TeamMembership("some_team_membership", new()
    {
        TeamId = someTeam.Id,
        Username = "SomeUser",
        Role = "member",
    });
});

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 user to the organization
		_, err := github.NewMembership(ctx, "membership_for_some_user", &github.MembershipArgs{
			Username: pulumi.String("SomeUser"),
			Role:     pulumi.String("member"),
		})
		if err != nil {
			return err
		}
		someTeam, err := github.NewTeam(ctx, "some_team", &github.TeamArgs{
			Name:        pulumi.String("SomeTeam"),
			Description: pulumi.String("Some cool team"),
		})
		if err != nil {
			return err
		}
		_, err = github.NewTeamMembership(ctx, "some_team_membership", &github.TeamMembershipArgs{
			TeamId:   someTeam.ID(),
			Username: pulumi.String("SomeUser"),
			Role:     pulumi.String("member"),
		})
		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.Membership;
import com.pulumi.github.MembershipArgs;
import com.pulumi.github.Team;
import com.pulumi.github.TeamArgs;
import com.pulumi.github.TeamMembership;
import com.pulumi.github.TeamMembershipArgs;
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) {
        // Add a user to the organization
        var membershipForSomeUser = new Membership("membershipForSomeUser", MembershipArgs.builder()
            .username("SomeUser")
            .role("member")
            .build());
        var someTeam = new Team("someTeam", TeamArgs.builder()
            .name("SomeTeam")
            .description("Some cool team")
            .build());
        var someTeamMembership = new TeamMembership("someTeamMembership", TeamMembershipArgs.builder()
            .teamId(someTeam.id())
            .username("SomeUser")
            .role("member")
            .build());
    }
}

resources:
  # Add a user to the organization
  membershipForSomeUser:
    type: github:Membership
    name: membership_for_some_user
    properties:
      username: SomeUser
      role: member
  someTeam:
    type: github:Team
    name: some_team
    properties:
      name: SomeTeam
      description: Some cool team
  someTeamMembership:
    type: github:TeamMembership
    name: some_team_membership
    properties:
      teamId: ${someTeam.id}
      username: SomeUser
      role: member

Import

GitHub Team Membership can be imported using an ID made up of teamid:username or teamname:username, e.g.

$ pulumi import github:index/teamMembership:TeamMembership member 1234567:someuser

$ pulumi import github:index/teamMembership:TeamMembership member Administrators:someuser

Constructors

TeamMembershipArgs

constructor(role: Output<String>? = null, teamId: Output<String>? = null, username: Output<String>? = null)

Properties

role

val role: Output<String>? = null

The role of the user within the team. Must be one of member or maintainer. Defaults to member.

teamId

val teamId: Output<String>? = null

The GitHub team id or the GitHub team slug

username

val username: Output<String>? = null

The user to add to the team.

Functions

toJava

open override fun toJava(): TeamMembershipArgs