github.ActionsRunnerGroup

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

const example = new github.Repository("example", {name: "my-repository"});
const exampleActionsRunnerGroup = new github.ActionsRunnerGroup("example", {
    name: example.name,
    visibility: "selected",
    selectedRepositoryIds: [example.repoId],
});

import pulumi
import pulumi_github as github

example = github.Repository("example", name="my-repository")
example_actions_runner_group = github.ActionsRunnerGroup("example",
    name=example.name,
    visibility="selected",
    selected_repository_ids=[example.repo_id])

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 {
		example, err := github.NewRepository(ctx, "example", &github.RepositoryArgs{
			Name: pulumi.String("my-repository"),
		})
		if err != nil {
			return err
		}
		_, err = github.NewActionsRunnerGroup(ctx, "example", &github.ActionsRunnerGroupArgs{
			Name:       example.Name,
			Visibility: pulumi.String("selected"),
			SelectedRepositoryIds: pulumi.IntArray{
				example.RepoId,
			},
		})
		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 example = new Github.Repository("example", new()
    {
        Name = "my-repository",
    });

    var exampleActionsRunnerGroup = new Github.ActionsRunnerGroup("example", new()
    {
        Name = example.Name,
        Visibility = "selected",
        SelectedRepositoryIds = new[]
        {
            example.RepoId,
        },
    });

});

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.ActionsRunnerGroup;
import com.pulumi.github.ActionsRunnerGroupArgs;
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 Repository("example", RepositoryArgs.builder()
            .name("my-repository")
            .build());

        var exampleActionsRunnerGroup = new ActionsRunnerGroup("exampleActionsRunnerGroup", ActionsRunnerGroupArgs.builder()
            .name(example.name())
            .visibility("selected")
            .selectedRepositoryIds(example.repoId())
            .build());

    }
}

resources:
  example:
    type: github:Repository
    properties:
      name: my-repository
  exampleActionsRunnerGroup:
    type: github:ActionsRunnerGroup
    name: example
    properties:
      name: ${example.name}
      visibility: selected
      selectedRepositoryIds:
        - ${example.repoId}

var actionsRunnerGroupResource = new Github.ActionsRunnerGroup("actionsRunnerGroupResource", new()
{
    Visibility = "string",
    AllowsPublicRepositories = false,
    Name = "string",
    RestrictedToWorkflows = false,
    SelectedRepositoryIds = new[]
    {
        0,
    },
    SelectedWorkflows = new[]
    {
        "string",
    },
});

example, err := github.NewActionsRunnerGroup(ctx, "actionsRunnerGroupResource", &github.ActionsRunnerGroupArgs{
	Visibility:               pulumi.String("string"),
	AllowsPublicRepositories: pulumi.Bool(false),
	Name:                     pulumi.String("string"),
	RestrictedToWorkflows:    pulumi.Bool(false),
	SelectedRepositoryIds: pulumi.IntArray{
		pulumi.Int(0),
	},
	SelectedWorkflows: pulumi.StringArray{
		pulumi.String("string"),
	},
})

var actionsRunnerGroupResource = new ActionsRunnerGroup("actionsRunnerGroupResource", ActionsRunnerGroupArgs.builder()
    .visibility("string")
    .allowsPublicRepositories(false)
    .name("string")
    .restrictedToWorkflows(false)
    .selectedRepositoryIds(0)
    .selectedWorkflows("string")
    .build());

actions_runner_group_resource = github.ActionsRunnerGroup("actionsRunnerGroupResource",
    visibility="string",
    allows_public_repositories=False,
    name="string",
    restricted_to_workflows=False,
    selected_repository_ids=[0],
    selected_workflows=["string"])

const actionsRunnerGroupResource = new github.ActionsRunnerGroup("actionsRunnerGroupResource", {
    visibility: "string",
    allowsPublicRepositories: false,
    name: "string",
    restrictedToWorkflows: false,
    selectedRepositoryIds: [0],
    selectedWorkflows: ["string"],
});

type: github:ActionsRunnerGroup
properties:
    allowsPublicRepositories: false
    name: string
    restrictedToWorkflows: false
    selectedRepositoryIds:
        - 0
    selectedWorkflows:
        - string
    visibility: string