repositoryCollaborator.go

// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package github

import (
	"context"
	"reflect"

	"github.com/pkg/errors"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

// Provides a GitHub repository collaborator resource.
//
// This resource allows you to add/remove collaborators from repositories in your
// organization or personal account. For organization repositories, collaborators can
// have explicit (and differing levels of) read, write, or administrator access to
// specific repositories, without giving the user full organization membership.
// For personal repositories, collaborators can only be granted write
// (implictly includes read) permission.
//
// When applied, an invitation will be sent to the user to become a collaborator
// on a repository. When destroyed, either the invitation will be cancelled or the
// collaborator will be removed from the repository.
//
// Further documentation on GitHub collaborators:
//
// - [Adding outside collaborators to your personal repositories](https://help.github.com/en/github/setting-up-and-managing-your-github-user-account/managing-access-to-your-personal-repositories)
// - [Adding outside collaborators to repositories in your organization](https://help.github.com/articles/adding-outside-collaborators-to-repositories-in-your-organization/)
// - [Converting an organization member to an outside collaborator](https://help.github.com/articles/converting-an-organization-member-to-an-outside-collaborator/)
//
// ## Example Usage
//
// ```go
// 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.NewRepositoryCollaborator(ctx, "aRepoCollaborator", &github.RepositoryCollaboratorArgs{
//				Permission: pulumi.String("admin"),
//				Repository: pulumi.String("our-cool-repo"),
//				Username:   pulumi.String("SomeUser"),
//			})
//			if err != nil {
//				return err
//			}
//			return nil
//		})
//	}
//
// ```
//
// ## Import
//
// GitHub Repository Collaborators can be imported using an ID made up of `repository:username`, e.g.
//
// ```sh
//
//	$ pulumi import github:index/repositoryCollaborator:RepositoryCollaborator collaborator terraform:someuser
//
// ```
type RepositoryCollaborator struct {
	pulumi.CustomResourceState

	// ID of the invitation to be used in `UserInvitationAccepter`
	InvitationId pulumi.StringOutput `pulumi:"invitationId"`
	// The permission of the outside collaborator for the repository.
	// Must be one of `pull`, `push`, `maintain`, `triage` or `admin` for organization-owned repositories.
	// Must be `push` for personal repositories. Defaults to `push`.
	Permission pulumi.StringPtrOutput `pulumi:"permission"`
	// Suppress plan diffs for `triage` and `maintain`.  Defaults to `false`.
	PermissionDiffSuppression pulumi.BoolPtrOutput `pulumi:"permissionDiffSuppression"`
	// The GitHub repository
	Repository pulumi.StringOutput `pulumi:"repository"`
	// The user to add to the repository as a collaborator.
	Username pulumi.StringOutput `pulumi:"username"`
}

// NewRepositoryCollaborator registers a new resource with the given unique name, arguments, and options.
func NewRepositoryCollaborator(ctx *pulumi.Context,
	name string, args *RepositoryCollaboratorArgs, opts ...pulumi.ResourceOption) (*RepositoryCollaborator, error) {
	if args == nil {
		return nil, errors.New("missing one or more required arguments")
	}

	if args.Repository == nil {
		return nil, errors.New("invalid value for required argument 'Repository'")
	}
	if args.Username == nil {
		return nil, errors.New("invalid value for required argument 'Username'")
	}
	var resource RepositoryCollaborator
	err := ctx.RegisterResource("github:index/repositoryCollaborator:RepositoryCollaborator", name, args, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// GetRepositoryCollaborator gets an existing RepositoryCollaborator resource's state with the given name, ID, and optional
// state properties that are used to uniquely qualify the lookup (nil if not required).
func GetRepositoryCollaborator(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RepositoryCollaboratorState, opts ...pulumi.ResourceOption) (*RepositoryCollaborator, error) {
	var resource RepositoryCollaborator
	err := ctx.ReadResource("github:index/repositoryCollaborator:RepositoryCollaborator", name, id, state, &resource, opts...)
	if err != nil {
		return nil, err
	}
	return &resource, nil
}

// Input properties used for looking up and filtering RepositoryCollaborator resources.
type repositoryCollaboratorState struct {
	// ID of the invitation to be used in `UserInvitationAccepter`
	InvitationId *string `pulumi:"invitationId"`
	// The permission of the outside collaborator for the repository.
	// Must be one of `pull`, `push`, `maintain`, `triage` or `admin` for organization-owned repositories.
	// Must be `push` for personal repositories. Defaults to `push`.
	Permission *string `pulumi:"permission"`
	// Suppress plan diffs for `triage` and `maintain`.  Defaults to `false`.
	PermissionDiffSuppression *bool `pulumi:"permissionDiffSuppression"`
	// The GitHub repository
	Repository *string `pulumi:"repository"`
	// The user to add to the repository as a collaborator.
	Username *string `pulumi:"username"`
}

type RepositoryCollaboratorState struct {
	// ID of the invitation to be used in `UserInvitationAccepter`
	InvitationId pulumi.StringPtrInput
	// The permission of the outside collaborator for the repository.
	// Must be one of `pull`, `push`, `maintain`, `triage` or `admin` for organization-owned repositories.
	// Must be `push` for personal repositories. Defaults to `push`.
	Permission pulumi.StringPtrInput
	// Suppress plan diffs for `triage` and `maintain`.  Defaults to `false`.
	PermissionDiffSuppression pulumi.BoolPtrInput
	// The GitHub repository
	Repository pulumi.StringPtrInput
	// The user to add to the repository as a collaborator.
	Username pulumi.StringPtrInput
}

func (RepositoryCollaboratorState) ElementType() reflect.Type {
	return reflect.TypeOf((*repositoryCollaboratorState)(nil)).Elem()
}

type repositoryCollaboratorArgs struct {
	// The permission of the outside collaborator for the repository.
	// Must be one of `pull`, `push`, `maintain`, `triage` or `admin` for organization-owned repositories.
	// Must be `push` for personal repositories. Defaults to `push`.
	Permission *string `pulumi:"permission"`
	// Suppress plan diffs for `triage` and `maintain`.  Defaults to `false`.
	PermissionDiffSuppression *bool `pulumi:"permissionDiffSuppression"`
	// The GitHub repository
	Repository string `pulumi:"repository"`
	// The user to add to the repository as a collaborator.
	Username string `pulumi:"username"`
}

// The set of arguments for constructing a RepositoryCollaborator resource.
type RepositoryCollaboratorArgs struct {
	// The permission of the outside collaborator for the repository.
	// Must be one of `pull`, `push`, `maintain`, `triage` or `admin` for organization-owned repositories.
	// Must be `push` for personal repositories. Defaults to `push`.
	Permission pulumi.StringPtrInput
	// Suppress plan diffs for `triage` and `maintain`.  Defaults to `false`.
	PermissionDiffSuppression pulumi.BoolPtrInput
	// The GitHub repository
	Repository pulumi.StringInput
	// The user to add to the repository as a collaborator.
	Username pulumi.StringInput
}

func (RepositoryCollaboratorArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*repositoryCollaboratorArgs)(nil)).Elem()
}

type RepositoryCollaboratorInput interface {
	pulumi.Input

	ToRepositoryCollaboratorOutput() RepositoryCollaboratorOutput
	ToRepositoryCollaboratorOutputWithContext(ctx context.Context) RepositoryCollaboratorOutput
}

func (*RepositoryCollaborator) ElementType() reflect.Type {
	return reflect.TypeOf((**RepositoryCollaborator)(nil)).Elem()
}

func (i *RepositoryCollaborator) ToRepositoryCollaboratorOutput() RepositoryCollaboratorOutput {
	return i.ToRepositoryCollaboratorOutputWithContext(context.Background())
}

func (i *RepositoryCollaborator) ToRepositoryCollaboratorOutputWithContext(ctx context.Context) RepositoryCollaboratorOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RepositoryCollaboratorOutput)
}

// RepositoryCollaboratorArrayInput is an input type that accepts RepositoryCollaboratorArray and RepositoryCollaboratorArrayOutput values.
// You can construct a concrete instance of `RepositoryCollaboratorArrayInput` via:
//
//	RepositoryCollaboratorArray{ RepositoryCollaboratorArgs{...} }
type RepositoryCollaboratorArrayInput interface {
	pulumi.Input

	ToRepositoryCollaboratorArrayOutput() RepositoryCollaboratorArrayOutput
	ToRepositoryCollaboratorArrayOutputWithContext(context.Context) RepositoryCollaboratorArrayOutput
}

type RepositoryCollaboratorArray []RepositoryCollaboratorInput

func (RepositoryCollaboratorArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*RepositoryCollaborator)(nil)).Elem()
}

func (i RepositoryCollaboratorArray) ToRepositoryCollaboratorArrayOutput() RepositoryCollaboratorArrayOutput {
	return i.ToRepositoryCollaboratorArrayOutputWithContext(context.Background())
}

func (i RepositoryCollaboratorArray) ToRepositoryCollaboratorArrayOutputWithContext(ctx context.Context) RepositoryCollaboratorArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RepositoryCollaboratorArrayOutput)
}

// RepositoryCollaboratorMapInput is an input type that accepts RepositoryCollaboratorMap and RepositoryCollaboratorMapOutput values.
// You can construct a concrete instance of `RepositoryCollaboratorMapInput` via:
//
//	RepositoryCollaboratorMap{ "key": RepositoryCollaboratorArgs{...} }
type RepositoryCollaboratorMapInput interface {
	pulumi.Input

	ToRepositoryCollaboratorMapOutput() RepositoryCollaboratorMapOutput
	ToRepositoryCollaboratorMapOutputWithContext(context.Context) RepositoryCollaboratorMapOutput
}

type RepositoryCollaboratorMap map[string]RepositoryCollaboratorInput

func (RepositoryCollaboratorMap) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*RepositoryCollaborator)(nil)).Elem()
}

func (i RepositoryCollaboratorMap) ToRepositoryCollaboratorMapOutput() RepositoryCollaboratorMapOutput {
	return i.ToRepositoryCollaboratorMapOutputWithContext(context.Background())
}

func (i RepositoryCollaboratorMap) ToRepositoryCollaboratorMapOutputWithContext(ctx context.Context) RepositoryCollaboratorMapOutput {
	return pulumi.ToOutputWithContext(ctx, i).(RepositoryCollaboratorMapOutput)
}

type RepositoryCollaboratorOutput struct{ *pulumi.OutputState }

func (RepositoryCollaboratorOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**RepositoryCollaborator)(nil)).Elem()
}

func (o RepositoryCollaboratorOutput) ToRepositoryCollaboratorOutput() RepositoryCollaboratorOutput {
	return o
}

func (o RepositoryCollaboratorOutput) ToRepositoryCollaboratorOutputWithContext(ctx context.Context) RepositoryCollaboratorOutput {
	return o
}

// ID of the invitation to be used in `UserInvitationAccepter`
func (o RepositoryCollaboratorOutput) InvitationId() pulumi.StringOutput {
	return o.ApplyT(func(v *RepositoryCollaborator) pulumi.StringOutput { return v.InvitationId }).(pulumi.StringOutput)
}

// The permission of the outside collaborator for the repository.
// Must be one of `pull`, `push`, `maintain`, `triage` or `admin` for organization-owned repositories.
// Must be `push` for personal repositories. Defaults to `push`.
func (o RepositoryCollaboratorOutput) Permission() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *RepositoryCollaborator) pulumi.StringPtrOutput { return v.Permission }).(pulumi.StringPtrOutput)
}

// Suppress plan diffs for `triage` and `maintain`.  Defaults to `false`.
func (o RepositoryCollaboratorOutput) PermissionDiffSuppression() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *RepositoryCollaborator) pulumi.BoolPtrOutput { return v.PermissionDiffSuppression }).(pulumi.BoolPtrOutput)
}

// The GitHub repository
func (o RepositoryCollaboratorOutput) Repository() pulumi.StringOutput {
	return o.ApplyT(func(v *RepositoryCollaborator) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput)
}

// The user to add to the repository as a collaborator.
func (o RepositoryCollaboratorOutput) Username() pulumi.StringOutput {
	return o.ApplyT(func(v *RepositoryCollaborator) pulumi.StringOutput { return v.Username }).(pulumi.StringOutput)
}

type RepositoryCollaboratorArrayOutput struct{ *pulumi.OutputState }

func (RepositoryCollaboratorArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]*RepositoryCollaborator)(nil)).Elem()
}

func (o RepositoryCollaboratorArrayOutput) ToRepositoryCollaboratorArrayOutput() RepositoryCollaboratorArrayOutput {
	return o
}

func (o RepositoryCollaboratorArrayOutput) ToRepositoryCollaboratorArrayOutputWithContext(ctx context.Context) RepositoryCollaboratorArrayOutput {
	return o
}

func (o RepositoryCollaboratorArrayOutput) Index(i pulumi.IntInput) RepositoryCollaboratorOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryCollaborator {
		return vs[0].([]*RepositoryCollaborator)[vs[1].(int)]
	}).(RepositoryCollaboratorOutput)
}

type RepositoryCollaboratorMapOutput struct{ *pulumi.OutputState }

func (RepositoryCollaboratorMapOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*map[string]*RepositoryCollaborator)(nil)).Elem()
}

func (o RepositoryCollaboratorMapOutput) ToRepositoryCollaboratorMapOutput() RepositoryCollaboratorMapOutput {
	return o
}

func (o RepositoryCollaboratorMapOutput) ToRepositoryCollaboratorMapOutputWithContext(ctx context.Context) RepositoryCollaboratorMapOutput {
	return o
}

func (o RepositoryCollaboratorMapOutput) MapIndex(k pulumi.StringInput) RepositoryCollaboratorOutput {
	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryCollaborator {
		return vs[0].(map[string]*RepositoryCollaborator)[vs[1].(string)]
	}).(RepositoryCollaboratorOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*RepositoryCollaboratorInput)(nil)).Elem(), &RepositoryCollaborator{})
	pulumi.RegisterInputType(reflect.TypeOf((*RepositoryCollaboratorArrayInput)(nil)).Elem(), RepositoryCollaboratorArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*RepositoryCollaboratorMapInput)(nil)).Elem(), RepositoryCollaboratorMap{})
	pulumi.RegisterOutputType(RepositoryCollaboratorOutput{})
	pulumi.RegisterOutputType(RepositoryCollaboratorArrayOutput{})
	pulumi.RegisterOutputType(RepositoryCollaboratorMapOutput{})
}