pulumi-github-kotlin/com.pulumi.github.kotlin/OrganizationSettings

OrganizationSettings

class OrganizationSettings : KotlinCustomResource

This resource allows you to create and manage settings for a GitHub Organization.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as github from "@pulumi/github";
const test = new github.OrganizationSettings("test", {
    billingEmail: "test@example.com",
    company: "Test Company",
    blog: "https://example.com",
    email: "test@example.com",
    twitterUsername: "Test",
    location: "Test Location",
    name: "Test Name",
    description: "Test Description",
    hasOrganizationProjects: true,
    hasRepositoryProjects: true,
    defaultRepositoryPermission: "read",
    membersCanCreateRepositories: true,
    membersCanCreatePublicRepositories: true,
    membersCanCreatePrivateRepositories: true,
    membersCanCreateInternalRepositories: true,
    membersCanCreatePages: true,
    membersCanCreatePublicPages: true,
    membersCanCreatePrivatePages: true,
    membersCanForkPrivateRepositories: true,
    webCommitSignoffRequired: true,
    advancedSecurityEnabledForNewRepositories: false,
    dependabotAlertsEnabledForNewRepositories: false,
    dependabotSecurityUpdatesEnabledForNewRepositories: false,
    dependencyGraphEnabledForNewRepositories: false,
    secretScanningEnabledForNewRepositories: false,
    secretScanningPushProtectionEnabledForNewRepositories: false,
});
Content copied to clipboard
import pulumi
import pulumi_github as github
test = github.OrganizationSettings("test",
    billing_email="test@example.com",
    company="Test Company",
    blog="https://example.com",
    email="test@example.com",
    twitter_username="Test",
    location="Test Location",
    name="Test Name",
    description="Test Description",
    has_organization_projects=True,
    has_repository_projects=True,
    default_repository_permission="read",
    members_can_create_repositories=True,
    members_can_create_public_repositories=True,
    members_can_create_private_repositories=True,
    members_can_create_internal_repositories=True,
    members_can_create_pages=True,
    members_can_create_public_pages=True,
    members_can_create_private_pages=True,
    members_can_fork_private_repositories=True,
    web_commit_signoff_required=True,
    advanced_security_enabled_for_new_repositories=False,
    dependabot_alerts_enabled_for_new_repositories=False,
    dependabot_security_updates_enabled_for_new_repositories=False,
    dependency_graph_enabled_for_new_repositories=False,
    secret_scanning_enabled_for_new_repositories=False,
    secret_scanning_push_protection_enabled_for_new_repositories=False)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Github = Pulumi.Github;
return await Deployment.RunAsync(() =>
{
    var test = new Github.OrganizationSettings("test", new()
    {
        BillingEmail = "test@example.com",
        Company = "Test Company",
        Blog = "https://example.com",
        Email = "test@example.com",
        TwitterUsername = "Test",
        Location = "Test Location",
        Name = "Test Name",
        Description = "Test Description",
        HasOrganizationProjects = true,
        HasRepositoryProjects = true,
        DefaultRepositoryPermission = "read",
        MembersCanCreateRepositories = true,
        MembersCanCreatePublicRepositories = true,
        MembersCanCreatePrivateRepositories = true,
        MembersCanCreateInternalRepositories = true,
        MembersCanCreatePages = true,
        MembersCanCreatePublicPages = true,
        MembersCanCreatePrivatePages = true,
        MembersCanForkPrivateRepositories = true,
        WebCommitSignoffRequired = true,
        AdvancedSecurityEnabledForNewRepositories = false,
        DependabotAlertsEnabledForNewRepositories = false,
        DependabotSecurityUpdatesEnabledForNewRepositories = false,
        DependencyGraphEnabledForNewRepositories = false,
        SecretScanningEnabledForNewRepositories = false,
        SecretScanningPushProtectionEnabledForNewRepositories = false,
    });
});
Content copied to clipboard
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 {
		_, err := github.NewOrganizationSettings(ctx, "test", &github.OrganizationSettingsArgs{
			BillingEmail:                         pulumi.String("test@example.com"),
			Company:                              pulumi.String("Test Company"),
			Blog:                                 pulumi.String("https://example.com"),
			Email:                                pulumi.String("test@example.com"),
			TwitterUsername:                      pulumi.String("Test"),
			Location:                             pulumi.String("Test Location"),
			Name:                                 pulumi.String("Test Name"),
			Description:                          pulumi.String("Test Description"),
			HasOrganizationProjects:              pulumi.Bool(true),
			HasRepositoryProjects:                pulumi.Bool(true),
			DefaultRepositoryPermission:          pulumi.String("read"),
			MembersCanCreateRepositories:         pulumi.Bool(true),
			MembersCanCreatePublicRepositories:   pulumi.Bool(true),
			MembersCanCreatePrivateRepositories:  pulumi.Bool(true),
			MembersCanCreateInternalRepositories: pulumi.Bool(true),
			MembersCanCreatePages:                pulumi.Bool(true),
			MembersCanCreatePublicPages:          pulumi.Bool(true),
			MembersCanCreatePrivatePages:         pulumi.Bool(true),
			MembersCanForkPrivateRepositories:    pulumi.Bool(true),
			WebCommitSignoffRequired:             pulumi.Bool(true),
			AdvancedSecurityEnabledForNewRepositories:             pulumi.Bool(false),
			DependabotAlertsEnabledForNewRepositories:             pulumi.Bool(false),
			DependabotSecurityUpdatesEnabledForNewRepositories:    pulumi.Bool(false),
			DependencyGraphEnabledForNewRepositories:              pulumi.Bool(false),
			SecretScanningEnabledForNewRepositories:               pulumi.Bool(false),
			SecretScanningPushProtectionEnabledForNewRepositories: pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.github.OrganizationSettings;
import com.pulumi.github.OrganizationSettingsArgs;
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 test = new OrganizationSettings("test", OrganizationSettingsArgs.builder()
            .billingEmail("test@example.com")
            .company("Test Company")
            .blog("https://example.com")
            .email("test@example.com")
            .twitterUsername("Test")
            .location("Test Location")
            .name("Test Name")
            .description("Test Description")
            .hasOrganizationProjects(true)
            .hasRepositoryProjects(true)
            .defaultRepositoryPermission("read")
            .membersCanCreateRepositories(true)
            .membersCanCreatePublicRepositories(true)
            .membersCanCreatePrivateRepositories(true)
            .membersCanCreateInternalRepositories(true)
            .membersCanCreatePages(true)
            .membersCanCreatePublicPages(true)
            .membersCanCreatePrivatePages(true)
            .membersCanForkPrivateRepositories(true)
            .webCommitSignoffRequired(true)
            .advancedSecurityEnabledForNewRepositories(false)
            .dependabotAlertsEnabledForNewRepositories(false)
            .dependabotSecurityUpdatesEnabledForNewRepositories(false)
            .dependencyGraphEnabledForNewRepositories(false)
            .secretScanningEnabledForNewRepositories(false)
            .secretScanningPushProtectionEnabledForNewRepositories(false)
            .build());
    }
}
Content copied to clipboard
resources:
  test:
    type: github:OrganizationSettings
    properties:
      billingEmail: test@example.com
      company: Test Company
      blog: https://example.com
      email: test@example.com
      twitterUsername: Test
      location: Test Location
      name: Test Name
      description: Test Description
      hasOrganizationProjects: true
      hasRepositoryProjects: true
      defaultRepositoryPermission: read
      membersCanCreateRepositories: true
      membersCanCreatePublicRepositories: true
      membersCanCreatePrivateRepositories: true
      membersCanCreateInternalRepositories: true
      membersCanCreatePages: true
      membersCanCreatePublicPages: true
      membersCanCreatePrivatePages: true
      membersCanForkPrivateRepositories: true
      webCommitSignoffRequired: true
      advancedSecurityEnabledForNewRepositories: false
      dependabotAlertsEnabledForNewRepositories: false
      dependabotSecurityUpdatesEnabledForNewRepositories: false
      dependencyGraphEnabledForNewRepositories: false
      secretScanningEnabledForNewRepositories: false
      secretScanningPushProtectionEnabledForNewRepositories: false
Content copied to clipboard

Import

Organization settings can be imported using the id of the organization. The id of the organization can be found using the get an organization API.

$ pulumi import github:index/organizationSettings:OrganizationSettings test 123456789
Content copied to clipboard

Properties

val advancedSecurityEnabledForNewRepositories: Output<Boolean>?

Whether or not advanced security is enabled for new repositories. Defaults to false.

Link copied to clipboard
val billingEmail: Output<String>

The billing email address for the organization.

Link copied to clipboard
val blog: Output<String>?

The blog URL for the organization.

Link copied to clipboard
val company: Output<String>?

The company name for the organization.

Link copied to clipboard
val defaultRepositoryPermission: Output<String>?

The default permission for organization members to create new repositories. Can be one of read, write, admin, or none. Defaults to read.

val dependabotAlertsEnabledForNewRepositories: Output<Boolean>?

Whether or not dependabot alerts are enabled for new repositories. Defaults to false.

val dependabotSecurityUpdatesEnabledForNewRepositories: Output<Boolean>?

Whether or not dependabot security updates are enabled for new repositories. Defaults to false.

Link copied to clipboard
val dependencyGraphEnabledForNewRepositories: Output<Boolean>?

Whether or not dependency graph is enabled for new repositories. Defaults to false.

Link copied to clipboard
val description: Output<String>?

The description for the organization.

Link copied to clipboard
val email: Output<String>?

The email address for the organization.

Link copied to clipboard
val hasOrganizationProjects: Output<Boolean>?

Whether or not organization projects are enabled for the organization.

Link copied to clipboard
val hasRepositoryProjects: Output<Boolean>?

Whether or not repository projects are enabled for the organization.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val location: Output<String>?

The location for the organization.

Link copied to clipboard
val membersCanCreateInternalRepositories: Output<Boolean>?

Whether or not organization members can create new internal repositories. For Enterprise Organizations only.

Link copied to clipboard
val membersCanCreatePages: Output<Boolean>?

Whether or not organization members can create new pages. Defaults to true.

Link copied to clipboard
val membersCanCreatePrivatePages: Output<Boolean>?

Whether or not organization members can create new private pages. Defaults to true.

Link copied to clipboard
val membersCanCreatePrivateRepositories: Output<Boolean>?

Whether or not organization members can create new private repositories. Defaults to true.

Link copied to clipboard
val membersCanCreatePublicPages: Output<Boolean>?

Whether or not organization members can create new public pages. Defaults to true.

Link copied to clipboard
val membersCanCreatePublicRepositories: Output<Boolean>?

Whether or not organization members can create new public repositories. Defaults to true.

Link copied to clipboard
val membersCanCreateRepositories: Output<Boolean>?

Whether or not organization members can create new repositories. Defaults to true.

Link copied to clipboard
val membersCanForkPrivateRepositories: Output<Boolean>?

Whether or not organization members can fork private repositories. Defaults to false.

Link copied to clipboard
val name: Output<String>

The name for the organization.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val secretScanningEnabledForNewRepositories: Output<Boolean>?

Whether or not secret scanning is enabled for new repositories. Defaults to false.

val secretScanningPushProtectionEnabledForNewRepositories: Output<Boolean>?

Whether or not secret scanning push protection is enabled for new repositories. Defaults to false.

Link copied to clipboard
val twitterUsername: Output<String>?

The Twitter username for the organization.

Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val webCommitSignoffRequired: Output<Boolean>?

Whether or not commit signatures are required for commits to the organization. Defaults to false.