github.ActionsOrganizationSecretRepositories

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

const example = new github.ActionsOrganizationSecret("example", {
    secretName: "mysecret",
    plaintextValue: "foo",
    visibility: "selected",
});
const exampleRepository = new github.Repository("example", {
    name: "myrepo",
    visibility: "public",
});
const exampleActionsOrganizationSecretRepositories = new github.ActionsOrganizationSecretRepositories("example", {
    secretName: example.name,
    selectedRepositoryIds: [exampleRepository.repoId],
});

import pulumi
import pulumi_github as github

example = github.ActionsOrganizationSecret("example",
    secret_name="mysecret",
    plaintext_value="foo",
    visibility="selected")
example_repository = github.Repository("example",
    name="myrepo",
    visibility="public")
example_actions_organization_secret_repositories = github.ActionsOrganizationSecretRepositories("example",
    secret_name=example.name,
    selected_repository_ids=[example_repository.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.NewActionsOrganizationSecret(ctx, "example", &github.ActionsOrganizationSecretArgs{
			SecretName:     pulumi.String("mysecret"),
			PlaintextValue: pulumi.String("foo"),
			Visibility:     pulumi.String("selected"),
		})
		if err != nil {
			return err
		}
		exampleRepository, err := github.NewRepository(ctx, "example", &github.RepositoryArgs{
			Name:       pulumi.String("myrepo"),
			Visibility: pulumi.String("public"),
		})
		if err != nil {
			return err
		}
		_, err = github.NewActionsOrganizationSecretRepositories(ctx, "example", &github.ActionsOrganizationSecretRepositoriesArgs{
			SecretName: example.Name,
			SelectedRepositoryIds: pulumi.IntArray{
				exampleRepository.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.ActionsOrganizationSecret("example", new()
    {
        SecretName = "mysecret",
        PlaintextValue = "foo",
        Visibility = "selected",
    });

    var exampleRepository = new Github.Repository("example", new()
    {
        Name = "myrepo",
        Visibility = "public",
    });

    var exampleActionsOrganizationSecretRepositories = new Github.ActionsOrganizationSecretRepositories("example", new()
    {
        SecretName = example.Name,
        SelectedRepositoryIds = new[]
        {
            exampleRepository.RepoId,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.github.ActionsOrganizationSecret;
import com.pulumi.github.ActionsOrganizationSecretArgs;
import com.pulumi.github.Repository;
import com.pulumi.github.RepositoryArgs;
import com.pulumi.github.ActionsOrganizationSecretRepositories;
import com.pulumi.github.ActionsOrganizationSecretRepositoriesArgs;
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 ActionsOrganizationSecret("example", ActionsOrganizationSecretArgs.builder()
            .secretName("mysecret")
            .plaintextValue("foo")
            .visibility("selected")
            .build());

        var exampleRepository = new Repository("exampleRepository", RepositoryArgs.builder()
            .name("myrepo")
            .visibility("public")
            .build());

        var exampleActionsOrganizationSecretRepositories = new ActionsOrganizationSecretRepositories("exampleActionsOrganizationSecretRepositories", ActionsOrganizationSecretRepositoriesArgs.builder()
            .secretName(example.name())
            .selectedRepositoryIds(exampleRepository.repoId())
            .build());

    }
}

resources:
  example:
    type: github:ActionsOrganizationSecret
    properties:
      secretName: mysecret
      plaintextValue: foo
      visibility: selected
  exampleRepository:
    type: github:Repository
    name: example
    properties:
      name: myrepo
      visibility: public
  exampleActionsOrganizationSecretRepositories:
    type: github:ActionsOrganizationSecretRepositories
    name: example
    properties:
      secretName: ${example.name}
      selectedRepositoryIds:
        - ${exampleRepository.repoId}

var actionsOrganizationSecretRepositoriesResource = new Github.ActionsOrganizationSecretRepositories("actionsOrganizationSecretRepositoriesResource", new()
{
    SecretName = "string",
    SelectedRepositoryIds = new[]
    {
        0,
    },
});

example, err := github.NewActionsOrganizationSecretRepositories(ctx, "actionsOrganizationSecretRepositoriesResource", &github.ActionsOrganizationSecretRepositoriesArgs{
	SecretName: pulumi.String("string"),
	SelectedRepositoryIds: pulumi.IntArray{
		pulumi.Int(0),
	},
})

var actionsOrganizationSecretRepositoriesResource = new ActionsOrganizationSecretRepositories("actionsOrganizationSecretRepositoriesResource", ActionsOrganizationSecretRepositoriesArgs.builder()
    .secretName("string")
    .selectedRepositoryIds(0)
    .build());

actions_organization_secret_repositories_resource = github.ActionsOrganizationSecretRepositories("actionsOrganizationSecretRepositoriesResource",
    secret_name="string",
    selected_repository_ids=[0])

const actionsOrganizationSecretRepositoriesResource = new github.ActionsOrganizationSecretRepositories("actionsOrganizationSecretRepositoriesResource", {
    secretName: "string",
    selectedRepositoryIds: [0],
});

type: github:ActionsOrganizationSecretRepositories
properties:
    secretName: string
    selectedRepositoryIds:
        - 0