diff --git a/cmd/mapt/cmd/params/params.go b/cmd/mapt/cmd/params/params.go index f871902a2..fc6ef4985 100644 --- a/cmd/mapt/cmd/params/params.go +++ b/cmd/mapt/cmd/params/params.go @@ -53,7 +53,9 @@ const ( TagsDesc string = "tags to add on each resource (--tags name1=value1,name2=value2)" GHActionsRunnerTokenDesc string = "Token needed for registering the Github Actions Runner token" GHActionsRunnerRepoDesc string = "Full URL of the repository where the Github Actions Runner should be registered" + GHActionsRunnerOrgDesc string = "GitHub organization name where the runner should be registered (mutually exclusive with --ghactions-runner-repo)" GHActionsRunnerLabelsDesc string = "List of labels separated by comma to be added to the self-hosted runner" + GHActionsRunnerEphemeralDesc string = "Configure the runner as ephemeral: it executes a single job then deregisters automatically" // Compute request memory string = "memory" @@ -75,9 +77,18 @@ const ( CreateCmdName string = "create" DestroyCmdName string = "destroy" - ghActionsRunnerToken string = "ghactions-runner-token" - ghActionsRunnerRepo string = "ghactions-runner-repo" - ghActionsRunnerLabels string = "ghactions-runner-labels" + ghActionsRunnerToken string = "ghactions-runner-token" + ghActionsRunnerRepo string = "ghactions-runner-repo" + ghActionsRunnerOrg string = "ghactions-runner-org" + ghActionsRunnerLabels string = "ghactions-runner-labels" + ghActionsRunnerEphemeral string = "ghactions-runner-ephemeral" + + ghActionsAppID string = "ghactions-app-id" + ghActionsAppIDDesc string = "GitHub App ID used to authenticate and generate a runner registration token" + ghActionsAppInstallationID string = "ghactions-app-installation-id" + ghActionsAppInstallationIDDesc string = "GitHub App installation ID for the target organization or repository" + ghActionsAppPrivateKey string = "ghactions-app-private-key" + ghActionsAppPrivateKeyDesc string = "Path to the GitHub App RSA private key PEM file" cirrusPWToken string = "it-cirrus-pw-token" cirrusPWTokenDesc string = "Add mapt target as a cirrus persistent worker. The value will hold a valid token to be used by cirrus cli to join the project." @@ -293,27 +304,71 @@ func AddDebugFlags(fs *pflag.FlagSet) { func AddGHActionsFlags(fs *pflag.FlagSet) { fs.StringP(ghActionsRunnerToken, "", "", GHActionsRunnerTokenDesc) fs.StringP(ghActionsRunnerRepo, "", "", GHActionsRunnerRepoDesc) + fs.StringP(ghActionsRunnerOrg, "", "", GHActionsRunnerOrgDesc) fs.StringSlice(ghActionsRunnerLabels, nil, GHActionsRunnerLabelsDesc) + fs.StringP(ghActionsAppID, "", "", ghActionsAppIDDesc) + fs.StringP(ghActionsAppInstallationID, "", "", ghActionsAppInstallationIDDesc) + fs.StringP(ghActionsAppPrivateKey, "", "", ghActionsAppPrivateKeyDesc) + fs.Bool(ghActionsRunnerEphemeral, false, GHActionsRunnerEphemeralDesc) } func GithubRunnerArgs(arch *github.Arch) *github.GithubRunnerArgs { token := viper.GetString(ghActionsRunnerToken) repoURL := viper.GetString(ghActionsRunnerRepo) + org := viper.GetString(ghActionsRunnerOrg) + appID := viper.GetString(ghActionsAppID) + installationID := viper.GetString(ghActionsAppInstallationID) + privateKeyPath := viper.GetString(ghActionsAppPrivateKey) + ephemeral := viper.GetBool(ghActionsRunnerEphemeral) pat := os.Getenv("GITHUB_TOKEN") - if token == "" && pat == "" { + if token == "" && appID == "" && pat == "" { + return nil + } + + if repoURL != "" && org != "" { + logging.Error("--ghactions-runner-repo and --ghactions-runner-org are mutually exclusive") return nil } - if repoURL == "" { - logging.Error("--ghactions-runner-repo is required for GitHub Actions runner setup") + if repoURL == "" && org == "" { + logging.Error("one of --ghactions-runner-repo or --ghactions-runner-org is required for GitHub Actions runner setup") return nil } + // App auth: validate required companion flags; token is fetched later inside + // the Pulumi context via github.SetupRunner. + if appID != "" { + if installationID == "" { + logging.Error("--ghactions-app-installation-id is required when --ghactions-app-id is set") + return nil + } + if privateKeyPath == "" { + logging.Error("--ghactions-app-private-key is required when --ghactions-app-id is set") + return nil + } + return &github.GithubRunnerArgs{ + RepoURL: repoURL, + Org: org, + Labels: viper.GetStringSlice(ghActionsRunnerLabels), + Platform: &github.Linux, + Arch: arch, + AppID: appID, + InstallationID: installationID, + PrivateKeyPath: privateKeyPath, + Ephemeral: ephemeral, + } + } + + // PAT path: auto-generate registration token before Pulumi runs. if token == "" { logging.Info("no --ghactions-runner-token provided, auto-generating from GITHUB_TOKEN") var err error - token, err = github.GenerateRegistrationToken(pat, repoURL) + if org != "" { + token, err = github.GenerateOrgRegistrationToken(pat, org) + } else { + token, err = github.GenerateRegistrationToken(pat, repoURL) + } if err != nil { logging.Errorf("failed to auto-generate runner registration token: %v", err) return nil @@ -322,11 +377,13 @@ func GithubRunnerArgs(arch *github.Arch) *github.GithubRunnerArgs { } return &github.GithubRunnerArgs{ - Token: token, - RepoURL: repoURL, - Labels: viper.GetStringSlice(ghActionsRunnerLabels), - Platform: &github.Linux, - Arch: arch, + Token: token, + RepoURL: repoURL, + Org: org, + Labels: viper.GetStringSlice(ghActionsRunnerLabels), + Platform: &github.Linux, + Arch: arch, + Ephemeral: ephemeral, } } diff --git a/docs/self-hosted-runner.md b/docs/self-hosted-runner.md index 07099c9a9..417b1a92d 100644 --- a/docs/self-hosted-runner.md +++ b/docs/self-hosted-runner.md @@ -1,59 +1,85 @@ # Overview -This feature of `mapt` allows to setup hosts deployed by it as a GitHub Self Hosted Runner, which can then be directly used for running GitHub actions jobs. +This feature of `mapt` allows to setup hosts deployed by it as a GitHub Self Hosted Runner, which can then be directly used for running GitHub Actions jobs. It benefits from all the existing features that `mapt` already provides, allowing to create self-hosted runners that can be used for different QE scenarios. ## Providers and Platforms -Currently, it allows to create self-hosted runners on AWS (Windows Server, RHEL) and Azure (Windows Desktop) +Currently, it allows to create self-hosted runners on: -### Prerequisite +* AWS: Windows Server, RHEL, Fedora, macOS +* Azure: Windows Desktop, RHEL +* IBM Cloud: IBM Power (ppc64le), IBM Z (s390x) -To register a Self Hosted Runner for a repository or a GitHub organization, the runner program needs a registration token, which can be obtained by requesting the -GitHub API. +## Authentication -* [Information for requesting a token to register a runner for an Organization](https://docs.github.com/en/rest/actions/self-hosted-runners#create-a-registration-token-for-an-organization) -* [Information for requesting a token to register a runner for a repository](https://docs.github.com/en/rest/actions/self-hosted-runners#create-a-registration-token-for-a-repository) +Registering a Self Hosted Runner requires a short-lived registration token from GitHub. `mapt` supports three ways to supply it. Precedence order: GitHub App credentials → explicit registration token → GITHUB_TOKEN (PAT auto-generate). -After obtaining the token we can invoke `mapt` with it to deploy a VM as a Self hosted runner. +### Option A — GitHub App (recommended) -For example to add a runner to this repository, we can use the following `curl` command to request a token: +Using a GitHub App avoids long-lived credentials. `mapt` exchanges the App's private key for a short-lived installation access token inside the Pulumi deployment, then uses it to fetch a fresh runner registration token automatically. -``` -% curl -L \ - -X POST \ - -H "Accept: application/vnd.github+json" \ - -H "Authorization: Bearer " \ - -H "X-GitHub-Api-Version: 2022-11-28" \ - https://api.github.com/repos/redhat-developer/mapt/actions/runners/registration-token -``` -The Response from this `POST` request will be: +**Prerequisites:** -``` -{ - "token": "ACDZL3QXEIC73UXBDGSEYEI", - "expires_at": "2024-07-12T19:01:48.478+05:30" -} -``` +1. Create a GitHub App with the `administration:write` permission on the target repository. +2. Install the App on the target repository and note the **Installation ID**. +3. Generate and download the App's **private key** (`.pem` file). -### Operations +**Flags:** -After getting the required token, we need to also decide what we are going to call this runner, the desired name can be passed to the `mapt` command using the -`--ghactions-runner-name` flag. +| Flag | Description | +|------|-------------| +| `--ghactions-app-id` | GitHub App ID (numeric, shown on the App settings page) | +| `--ghactions-app-installation-id` | Installation ID for the target org or repository | +| `--ghactions-app-private-key` | Path to the App RSA private key PEM file | +| `--ghactions-runner-repo` | Full URL of the repository (mutually exclusive with `--ghactions-runner-org`) | +| `--ghactions-runner-org` | GitHub organization name for an org-level runner (mutually exclusive with `--ghactions-runner-repo`) | +| `--ghactions-runner-labels` | Comma-separated labels to attach to the runner (optional) | -The full URL of the repository or the GitHub organization also needs to be passed using the `--ghactions-runner-repo` flag. +**Example:** + +```bash +mapt aws rhel create \ + --ghactions-runner-repo "https://github.com/redhat-developer/mapt" \ + --ghactions-app-id "123456" \ + --ghactions-app-installation-id "789012" \ + --ghactions-app-private-key "/path/to/app-private-key.pem" \ + --project-name mapt-rhel-aws \ + --backed-url file:///workspace/state \ + --conn-details-output /workspace/conn-details +``` -To deploy a Windows runner on the Azure provider, we can use the following command: +### Option B — Personal Access Token (PAT) +Set the `GITHUB_TOKEN` environment variable to a PAT with `repo` admin scope. `mapt` will call the GitHub API to generate a registration token automatically before deployment. + +```bash +export GITHUB_TOKEN=ghp_xxxxxxxxxxxxxxxxxxxx +mapt aws rhel create \ + --ghactions-runner-repo "https://github.com/redhat-developer/mapt" \ + --project-name mapt-rhel-aws \ + --backed-url file:///workspace/state \ + --conn-details-output /workspace/conn-details ``` -% mapt azure windows create --spot \ - --install-ghactions-runner \ - --ghcations-runner-token="ACDZL3QXEIC73UXBDGSEYEI" \ - --ghcations-runner-name "az-win-11" \ - --ghcations-runner-repo "https://github.com/redhat-developer/mapt" \ + +### Option C — Pre-generated registration token + +Pass a registration token obtained manually from the GitHub API directly via `--ghactions-runner-token`. Tokens expire after 1 hour. + +```bash +# Obtain a token via the GitHub API: +curl -L -X POST \ + -H "Accept: application/vnd.github+json" \ + -H "Authorization: Bearer " \ + -H "X-GitHub-Api-Version: 2022-11-28" \ + https://api.github.com/repos/redhat-developer/mapt/actions/runners/registration-token + +mapt azure windows create --spot \ + --ghactions-runner-repo "https://github.com/redhat-developer/mapt" \ + --ghactions-runner-token "ACDZL3QXEIC73UXBDGSEYEI" \ --project-name mapt-windows-azure \ - --backed-url file:///Users/tester/workspace \ - --conn-details-output /Users/tester/workspace/conn-details + --backed-url file:///workspace/state \ + --conn-details-output /workspace/conn-details ``` -> *NOTE:* additional _labels_ can be added to the runner using the flag `--ghactions-runner-labels`, e.g `--ghactions-runner-lables="azure,mapt,windows"` +> **Note:** Additional labels can be added to the runner with `--ghactions-runner-labels`, e.g. `--ghactions-runner-labels="azure,mapt,windows"`. diff --git a/go.mod b/go.mod index fa10373f7..e30b203c6 100644 --- a/go.mod +++ b/go.mod @@ -43,6 +43,7 @@ require ( github.com/pulumi/pulumi-azure-native-sdk/network/v3 v3.20.0 github.com/pulumi/pulumi-azure-native-sdk/resources/v3 v3.20.0 github.com/pulumi/pulumi-azure-native-sdk/storage/v3 v3.20.0 + github.com/pulumi/pulumi-github/sdk/v6 v6.14.0 github.com/pulumi/pulumi-gitlab/sdk/v9 v9.11.1 github.com/pulumi/pulumi-tls/sdk/v5 v5.5.0 golang.org/x/exp v0.0.0-20260709172345-9ea1abe57597 diff --git a/go.sum b/go.sum index 07dd8d68f..93118c6c1 100644 --- a/go.sum +++ b/go.sum @@ -427,6 +427,8 @@ github.com/pulumi/pulumi-docker-build/sdk/go/dockerbuild v0.0.20 h1:8VJt/iUb1ur3 github.com/pulumi/pulumi-docker-build/sdk/go/dockerbuild v0.0.20/go.mod h1:iRiNhXmySLlREgx1zeoD4Es62WU2jTpd5YXdZ/0AQB4= github.com/pulumi/pulumi-docker/sdk/v4 v4.5.8 h1:rik9L2SIpsoDenY51MkogR6GWgu/0Sy/XmyQmKWNUqU= github.com/pulumi/pulumi-docker/sdk/v4 v4.5.8/go.mod h1:eph7BPNPkEIIK882/Ll4dbeHl5wZEc/UvTcUW0CK1UY= +github.com/pulumi/pulumi-github/sdk/v6 v6.14.0 h1:49TS7PctMDGQpOAD6vu0On+k6L3t0Rtrzmwd/fDcbVk= +github.com/pulumi/pulumi-github/sdk/v6 v6.14.0/go.mod h1:aSCgSWErJwJujq1CKHe71wArYAKjWKHs+REB5GcM0es= github.com/pulumi/pulumi-gitlab/sdk/v9 v9.11.1 h1:DPDQD9FamQ3myy0EQOYuzUFvcJpQDr1H3GNwz/scDgA= github.com/pulumi/pulumi-gitlab/sdk/v9 v9.11.1/go.mod h1:eS9gkxGvdzprE767heyMrPrMY/6FX9UbdPYeI4pbkE8= github.com/pulumi/pulumi-kubernetes/sdk/v4 v4.33.0 h1:fFP72Q6/GfyI7BII3hUS7vn45Eg16zKIIS3I3R9bNEY= diff --git a/oci/Containerfile b/oci/Containerfile index 288786ca5..cabbb1c9e 100644 --- a/oci/Containerfile +++ b/oci/Containerfile @@ -33,6 +33,8 @@ ARG PULUMI_TLS_VERSION=v5.5.0 ARG PULUMI_RANDOM_VERSION=v4.21.0 # renovate: datasource=github-releases depName=pulumi/pulumi-aws-native ARG PULUMI_AWS_NATIVE_VERSION=v1.71.0 +# renovate: datasource=github-releases depName=pulumi/pulumi-github +ARG PULUMI_GITHUB_VERSION=v6.14.0 # renovate: datasource=github-releases depName=pulumi/pulumi-gitlab ARG PULUMI_GITLAB_VERSION=v10.0.0 # renovate: datasource=github-releases depName=mapt-oss/pulumi-ibmcloud @@ -53,6 +55,7 @@ RUN mkdir -p ${PULUMI_HOME} \ && pulumi plugin install resource random ${PULUMI_RANDOM_VERSION} \ && pulumi plugin install resource awsx ${PULUMI_AWSX_VERSION} \ && pulumi plugin install resource aws-native ${PULUMI_AWS_NATIVE_VERSION} \ + && pulumi plugin install resource github ${PULUMI_GITHUB_VERSION} \ && pulumi plugin install resource gitlab ${PULUMI_GITLAB_VERSION} # Stage 2: Red Hat Hardened minimal runtime (glibc + coreutils, no toolchain) diff --git a/pkg/integrations/github/api.go b/pkg/integrations/github/api.go index a592cfc60..36c1455bc 100644 --- a/pkg/integrations/github/api.go +++ b/pkg/integrations/github/api.go @@ -14,22 +14,73 @@ type registrationTokenResponse struct { ExpiresAt string `json:"expires_at"` } -// GenerateRegistrationToken calls the GitHub API to create a short-lived -// runner registration token for the given repository. -// pat is a Personal Access Token with repo admin scope. -// repoURL is in the form "owner/repo" or "https://github.com/owner/repo". -func GenerateRegistrationToken(pat, repoURL string) (string, error) { - ownerRepo := repoURL - ownerRepo = strings.TrimPrefix(ownerRepo, "https://github.com/") +// splitOwnerRepo parses a repo URL in the form "owner/repo" or +// "https://github.com/owner/repo" and returns the two components. +func splitOwnerRepo(repoURL string) (owner, repo string, err error) { + ownerRepo := strings.TrimPrefix(repoURL, "https://github.com/") ownerRepo = strings.TrimPrefix(ownerRepo, "http://github.com/") ownerRepo = strings.TrimSuffix(ownerRepo, "/") parts := strings.Split(ownerRepo, "/") if len(parts) != 2 || parts[0] == "" || parts[1] == "" { - return "", fmt.Errorf("invalid repo format %q, expected owner/repo", repoURL) + return "", "", fmt.Errorf("invalid repo format %q, expected owner/repo", repoURL) + } + return parts[0], parts[1], nil +} + +// GenerateOrgRegistrationToken calls the GitHub API to create a short-lived +// runner registration token for the given organization. +// pat is a Personal Access Token with admin:org scope. +func GenerateOrgRegistrationToken(pat, org string) (string, error) { + url := fmt.Sprintf("https://api.github.com/orgs/%s/actions/runners/registration-token", org) + + req, err := http.NewRequest(http.MethodPost, url, nil) + if err != nil { + return "", fmt.Errorf("creating request: %w", err) + } + req.Header.Set("Authorization", "token "+pat) + req.Header.Set("Accept", "application/vnd.github+json") + req.Header.Set("X-GitHub-Api-Version", "2022-11-28") + + client := &http.Client{Timeout: 30 * time.Second} + resp, err := client.Do(req) + if err != nil { + return "", fmt.Errorf("calling GitHub API: %w", err) + } + defer func() { _ = resp.Body.Close() }() + + body, err := io.ReadAll(resp.Body) + if err != nil { + return "", fmt.Errorf("reading response: %w", err) + } + + if resp.StatusCode != http.StatusCreated { + return "", fmt.Errorf("GitHub API returned %d: %s (ensure GITHUB_TOKEN has admin:org scope)", resp.StatusCode, string(body)) + } + + var tokenResp registrationTokenResponse + if err := json.Unmarshal(body, &tokenResp); err != nil { + return "", fmt.Errorf("parsing response: %w", err) + } + + if tokenResp.Token == "" { + return "", fmt.Errorf("empty token in GitHub API response") + } + + return tokenResp.Token, nil +} + +// GenerateRegistrationToken calls the GitHub API to create a short-lived +// runner registration token for the given repository. +// pat is a Personal Access Token with repo admin scope. +// repoURL is in the form "owner/repo" or "https://github.com/owner/repo". +func GenerateRegistrationToken(pat, repoURL string) (string, error) { + owner, repo, err := splitOwnerRepo(repoURL) + if err != nil { + return "", err } - url := fmt.Sprintf("https://api.github.com/repos/%s/%s/actions/runners/registration-token", parts[0], parts[1]) + url := fmt.Sprintf("https://api.github.com/repos/%s/%s/actions/runners/registration-token", owner, repo) req, err := http.NewRequest(http.MethodPost, url, nil) if err != nil { diff --git a/pkg/integrations/github/ghrunner.go b/pkg/integrations/github/ghrunner.go index 90ce87651..95b27de61 100644 --- a/pkg/integrations/github/ghrunner.go +++ b/pkg/integrations/github/ghrunner.go @@ -3,10 +3,14 @@ package github import ( _ "embed" "fmt" + "os" "strings" + pulgithub "github.com/pulumi/pulumi-github/sdk/v6/go/github" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" "github.com/redhat-developer/mapt/pkg/integrations" "github.com/redhat-developer/mapt/pkg/util" + "github.com/redhat-developer/mapt/pkg/util/logging" ) var runnerVersion = "2.317.0" @@ -53,12 +57,17 @@ func (args *GithubRunnerArgs) GetUserDataValues() *integrations.UserDataValues { if args == nil { return nil } + repoURL := args.RepoURL + if args.Org != "" { + repoURL = "https://github.com/" + args.Org + } return &integrations.UserDataValues{ - Name: args.Name, - Token: args.Token, - Labels: getLabels(), - RepoURL: args.RepoURL, - CliURL: downloadURL(), + Name: args.Name, + Token: args.Token, + Labels: getLabels(), + RepoURL: repoURL, + CliURL: downloadURL(), + Ephemeral: args.Ephemeral, RunnerImageRepo: runnerImageRepo, RunnerImageRepoVersion: runnerImageRepoVersion, } @@ -106,3 +115,59 @@ func getLabels() string { } return util.IfNillable(runnerArgs != nil, labels, "") } + +// SetupRunner fetches a runner registration token from the GitHub App and +// sets it on args. It is a no-op when args is nil, Token is already set, +// or AppID is empty (PAT / plain-token paths are handled in params). +func SetupRunner(ctx *pulumi.Context, args *GithubRunnerArgs) error { + if args == nil || args.AppID == "" || args.Token != "" { + return nil + } + + pemBytes, err := os.ReadFile(args.PrivateKeyPath) + if err != nil { + return fmt.Errorf("reading GitHub App private key: %w", err) + } + + var owner string + if args.Org != "" { + owner = args.Org + } else { + owner, _, err = splitOwnerRepo(args.RepoURL) + if err != nil { + return err + } + } + + provider, err := pulgithub.NewProvider(ctx, "github-app-provider", &pulgithub.ProviderArgs{ + Owner: pulumi.String(owner), + AppAuth: pulgithub.ProviderAppAuthPtr(&pulgithub.ProviderAppAuthArgs{ + Id: pulumi.String(args.AppID), + InstallationId: pulumi.String(args.InstallationID), + PemFile: pulumi.String(string(pemBytes)), + }), + }) + if err != nil { + return fmt.Errorf("creating GitHub App provider: %w", err) + } + + if args.Org != "" { + result, err := pulgithub.GetActionsOrganizationRegistrationToken(ctx, pulumi.Provider(provider)) + if err != nil { + return fmt.Errorf("fetching org runner registration token: %w", err) + } + args.Token = result.Token + } else { + _, repo, _ := splitOwnerRepo(args.RepoURL) + result, err := pulgithub.GetActionsRegistrationToken(ctx, + &pulgithub.GetActionsRegistrationTokenArgs{Repository: repo}, + pulumi.Provider(provider)) + if err != nil { + return fmt.Errorf("fetching runner registration token: %w", err) + } + args.Token = result.Token + } + + logging.Info("runner registration token generated from GitHub App successfully") + return nil +} diff --git a/pkg/integrations/github/snippet-darwin.sh b/pkg/integrations/github/snippet-darwin.sh index d4b7078f7..5195447ee 100644 --- a/pkg/integrations/github/snippet-darwin.sh +++ b/pkg/integrations/github/snippet-darwin.sh @@ -1,7 +1,7 @@ mkdir ~/actions-runner && cd ~/actions-runner curl -o actions-runner-osx.tar.gz -L {{ .CliURL }} tar xzf ./actions-runner-osx.tar.gz -./config.sh --token {{ .Token }} --url {{ .RepoURL }} --name {{ .Name }} --unattended --replace --labels {{ .Labels }} +./config.sh --token {{ .Token }} --url {{ .RepoURL }} --name {{ .Name }} --unattended --replace --labels {{ .Labels }}{{ if .Ephemeral }} --ephemeral{{ end }} ./svc.sh install plistName=$(basename $(./svc.sh status | grep "plist$")) mkdir -p /Library/LaunchDaemons diff --git a/pkg/integrations/github/snippet-linux-ppc64le.sh b/pkg/integrations/github/snippet-linux-ppc64le.sh index 9670a1b78..ae9a77437 100644 --- a/pkg/integrations/github/snippet-linux-ppc64le.sh +++ b/pkg/integrations/github/snippet-linux-ppc64le.sh @@ -34,11 +34,11 @@ sudo -u runner bash -c ' ./config.sh \ --unattended \ --disableupdate \ - --ephemeral \ --name "{{ .Name }}" \ --labels "{{ .Labels }}" \ --url "{{ .RepoURL }}" \ - --token "{{ .Token }}" + --token "{{ .Token }}"{{ if .Ephemeral }} \ + --ephemeral{{ end }} nohup ./run.sh > /tmp/gh-runner.log 2>&1 & ' diff --git a/pkg/integrations/github/snippet-linux-s390x.sh b/pkg/integrations/github/snippet-linux-s390x.sh index e1e638494..2c4025cde 100644 --- a/pkg/integrations/github/snippet-linux-s390x.sh +++ b/pkg/integrations/github/snippet-linux-s390x.sh @@ -23,11 +23,11 @@ sudo -u runner bash -c ' ./config.sh \ --unattended \ --disableupdate \ - --ephemeral \ --name "{{ .Name }}" \ --labels "{{ .Labels }}" \ --url "{{ .RepoURL }}" \ - --token "{{ .Token }}" + --token "{{ .Token }}"{{ if .Ephemeral }} \ + --ephemeral{{ end }} nohup ./run.sh > /tmp/gh-runner.log 2>&1 & ' diff --git a/pkg/integrations/github/snippet-linux.sh b/pkg/integrations/github/snippet-linux.sh index cede15725..369454a95 100644 --- a/pkg/integrations/github/snippet-linux.sh +++ b/pkg/integrations/github/snippet-linux.sh @@ -2,7 +2,7 @@ mkdir ~/actions-runner && cd ~/actions-runner curl -o actions-runner-linux.tar.gz -L {{ .CliURL }} tar xzf ./actions-runner-linux.tar.gz sudo ./bin/installdependencies.sh -./config.sh --token {{ .Token }} --url {{ .RepoURL }} --name {{ .Name }} --unattended --replace --labels {{ .Labels }} +./config.sh --token {{ .Token }} --url {{ .RepoURL }} --name {{ .Name }} --unattended --replace --labels {{ .Labels }}{{ if .Ephemeral }} --ephemeral{{ end }} sudo ./svc.sh install chcon system_u:object_r:usr_t:s0 $(pwd)/runsvc.sh sudo ./svc.sh start diff --git a/pkg/integrations/github/snippet-windows.ps1 b/pkg/integrations/github/snippet-windows.ps1 index 086cde28b..f5db4ab23 100644 --- a/pkg/integrations/github/snippet-windows.ps1 +++ b/pkg/integrations/github/snippet-windows.ps1 @@ -2,4 +2,4 @@ New-Item -Path C:\actions-runner -Type Directory ; cd C:\actions-runner Invoke-WebRequest -Uri {{ .CliURL }} -OutFile actions-runner-win.zip Add-Type -AssemblyName System.IO.Compression.FileSystem ; [System.IO.Compression.ZipFile]::ExtractToDirectory("$PWD\actions-runner-win.zip", "$PWD") -./config.cmd --token $ghToken --url {{ .RepoURL }} --name {{ .Name }} --unattended --runasservice --replace --labels {{ .Labels }} +./config.cmd --token $ghToken --url {{ .RepoURL }} --name {{ .Name }} --unattended --runasservice --replace --labels {{ .Labels }}{{ if .Ephemeral }} --ephemeral{{ end }} diff --git a/pkg/integrations/github/types.go b/pkg/integrations/github/types.go index 2d85f2665..f09b73e2b 100644 --- a/pkg/integrations/github/types.go +++ b/pkg/integrations/github/types.go @@ -16,11 +16,16 @@ var ( ) type GithubRunnerArgs struct { - Token string - RepoURL string - Name string - Platform *Platform - Arch *Arch - Labels []string - User string + Token string + RepoURL string + Org string + Name string + Platform *Platform + Arch *Arch + Labels []string + User string + AppID string + InstallationID string + PrivateKeyPath string + Ephemeral bool } diff --git a/pkg/integrations/integrations.go b/pkg/integrations/integrations.go index ee1df5db3..ed9395f18 100644 --- a/pkg/integrations/integrations.go +++ b/pkg/integrations/integrations.go @@ -17,6 +17,7 @@ type UserDataValues struct { Unsecure bool Concurrent int LogToJournald bool + Ephemeral bool RunnerImageRepo string RunnerImageRepoVersion string } diff --git a/pkg/provider/aws/modules/mac/machine/setup/setup.go b/pkg/provider/aws/modules/mac/machine/setup/setup.go index ccbce125c..a9b11bdb6 100644 --- a/pkg/provider/aws/modules/mac/machine/setup/setup.go +++ b/pkg/provider/aws/modules/mac/machine/setup/setup.go @@ -80,6 +80,12 @@ func GenerateBootstrapScript( currentPassword string, username string, ) (pulumi.StringOutput, error) { + if ghRunnerArgs := github.GetRunnerArgs(); ghRunnerArgs != nil { + if err := github.SetupRunner(ctx, ghRunnerArgs); err != nil { + return pulumi.StringOutput{}, err + } + } + glRunnerArgs := gitlab.GetRunnerArgs() if glRunnerArgs != nil { diff --git a/pkg/provider/azure/action/windows/windows.go b/pkg/provider/azure/action/windows/windows.go index 2d192cf2a..2c1179de0 100644 --- a/pkg/provider/azure/action/windows/windows.go +++ b/pkg/provider/azure/action/windows/windows.go @@ -301,6 +301,12 @@ func (r *windowsRequest) postInitSetup(ctx *pulumi.Context, rg *resources.Resour return nil, nil, err } + if ghRunnerArgs := github.GetRunnerArgs(); ghRunnerArgs != nil { + if err := github.SetupRunner(ctx, ghRunnerArgs); err != nil { + return nil, nil, err + } + } + // Check if GitLab runner args exist and create runner if needed glRunnerArgs := gitlab.GetRunnerArgs() var setupCommand pulumi.StringOutput diff --git a/pkg/provider/ibmcloud/action/ibm-power/ibm-power.go b/pkg/provider/ibmcloud/action/ibm-power/ibm-power.go index a1e758f0b..f8a5ff88b 100644 --- a/pkg/provider/ibmcloud/action/ibm-power/ibm-power.go +++ b/pkg/provider/ibmcloud/action/ibm-power/ibm-power.go @@ -189,6 +189,12 @@ func (r *pwRequest) deploy(ctx *pulumi.Context) error { } hasOtel := otelSet == 3 + if ghRunnerArgs := github.GetRunnerArgs(); ghRunnerArgs != nil { + if err := github.SetupRunner(ctx, ghRunnerArgs); err != nil { + return err + } + } + ghRunnerScript := "" if ghRunnerArgs := github.GetRunnerArgs(); ghRunnerArgs != nil { s, err := integrations.GetIntegrationSnippetAsCloudInitWritableFile(ghRunnerArgs, defaultUser) diff --git a/pkg/provider/ibmcloud/action/ibm-z/ibm-z.go b/pkg/provider/ibmcloud/action/ibm-z/ibm-z.go index 1a4892b61..915979b63 100644 --- a/pkg/provider/ibmcloud/action/ibm-z/ibm-z.go +++ b/pkg/provider/ibmcloud/action/ibm-z/ibm-z.go @@ -149,6 +149,12 @@ func Destroy(mCtxArgs *mc.ContextArgs) (err error) { } func (r *zRequest) deploy(ctx *pulumi.Context) error { + if ghRunnerArgs := github.GetRunnerArgs(); ghRunnerArgs != nil { + if err := github.SetupRunner(ctx, ghRunnerArgs); err != nil { + return err + } + } + if glRunnerArgs := gitlab.GetRunnerArgs(); glRunnerArgs != nil && r.glAuthToken == nil { authToken, err := gitlab.CreateRunner(ctx, glRunnerArgs) if err != nil { diff --git a/pkg/target/host/fedora/fedora.go b/pkg/target/host/fedora/fedora.go index bde640de8..23057970b 100644 --- a/pkg/target/host/fedora/fedora.go +++ b/pkg/target/host/fedora/fedora.go @@ -87,6 +87,12 @@ func UserdataWithGitLabToken(amiUser string, gitlabAuthToken string) (string, er // If GitLab runner args are present, it creates the runner via Pulumi first and uses the auth token. // Otherwise, it generates normal userdata without GitLab integration. func GenerateUserdata(ctx *pulumi.Context, amiUser string, runID string) (pulumi.StringPtrInput, error) { + if ghRunnerArgs := github.GetRunnerArgs(); ghRunnerArgs != nil { + if err := github.SetupRunner(ctx, ghRunnerArgs); err != nil { + return nil, err + } + } + glRunnerArgs := gitlab.GetRunnerArgs() if glRunnerArgs != nil { diff --git a/pkg/target/host/rhel/cloud-config.go b/pkg/target/host/rhel/cloud-config.go index fa3e04eb2..ac2d86275 100644 --- a/pkg/target/host/rhel/cloud-config.go +++ b/pkg/target/host/rhel/cloud-config.go @@ -124,6 +124,12 @@ func (r *CloudConfigArgs) CloudConfigWithGitLabToken(gitlabAuthToken string) (st // If GitLab runner args are present, it creates the runner via Pulumi first and uses the auth token. // Otherwise, it generates normal cloud config without GitLab integration. func (r *CloudConfigArgs) GenerateCloudConfig(ctx *pulumi.Context, runID string) (pulumi.StringInput, error) { + if ghRunnerArgs := github.GetRunnerArgs(); ghRunnerArgs != nil { + if err := github.SetupRunner(ctx, ghRunnerArgs); err != nil { + return nil, err + } + } + glRunnerArgs := gitlab.GetRunnerArgs() if glRunnerArgs != nil { diff --git a/pkg/target/host/windows-server/windows-server.go b/pkg/target/host/windows-server/windows-server.go index 67df4f5d8..c2f38c6d4 100644 --- a/pkg/target/host/windows-server/windows-server.go +++ b/pkg/target/host/windows-server/windows-server.go @@ -118,6 +118,12 @@ func UserdataWithGitLabToken(ctx *pulumi.Context, amiUser *string, password *ran // Otherwise, it generates normal userdata without GitLab integration. func GenerateUserdata(ctx *pulumi.Context, amiUser *string, password *random.RandomPassword, keypair *keypair.KeyPairResources, runID string) (pulumi.StringPtrInput, error) { + if ghRunnerArgs := github.GetRunnerArgs(); ghRunnerArgs != nil { + if err := github.SetupRunner(ctx, ghRunnerArgs); err != nil { + return nil, err + } + } + glRunnerArgs := gitlab.GetRunnerArgs() if glRunnerArgs != nil { diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/LICENSE b/vendor/github.com/pulumi/pulumi-github/sdk/v6/LICENSE new file mode 100644 index 000000000..d64569567 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsEnvironmentSecret.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsEnvironmentSecret.go new file mode 100644 index 000000000..18a199ca1 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsEnvironmentSecret.go @@ -0,0 +1,484 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage GitHub Actions secrets within your GitHub repository environments. +// You must have write access to a repository to use this resource. +// +// Secret values are encrypted using the [Go '/crypto/box' module](https://godoc.org/golang.org/x/crypto/nacl/box) which is +// interoperable with [libsodium](https://libsodium.gitbook.io/doc/). Libsodium is used by GitHub to decrypt secret values. +// +// For the purposes of security, the contents of the `value` field have been marked as `sensitive` to Terraform, +// but it is important to note that **this does not hide it from state files**. You should treat state as sensitive always. +// It is also advised that you do not store plaintext values in your code but rather populate the `valueEncrypted` +// using fields from a resource, data source or variable as, while encrypted in state, these will be easily accessible +// in your code. See below for an example of this abstraction. +// +// ## Example Lifecycle Ignore Changes +// +// This resource supports using the `lifecycle` `ignoreChanges` block on `remoteUpdatedAt` to support use cases where a secret value is created using a placeholder value and then modified after creation outside the scope of Terraform. This approach ensures only the initial placeholder value is referenced in your code and in the resulting state file. +// +// ```go +// 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.NewActionsEnvironmentSecret(ctx, "example_allow_drift", &github.ActionsEnvironmentSecretArgs{ +// Repository: pulumi.String("example-repo"), +// Environment: pulumi.String("example-environment"), +// SecretName: pulumi.String("example_secret_name"), +// Value: pulumi.String("placeholder"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using an ID made of the repository name, environment name (URL escaped), and secret name all separated by a `:`. +// +// > **Note**: When importing secrets, the `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` fields will not be populated in the state. You may need to ignore changes for these as a workaround if you're not planning on updating the secret through Terraform. +// +// ### Import Command +// +// The following command imports a GitHub actions environment secret named `mysecret` for the repo `myrepo` and environment `myenv` to a `ActionsEnvironmentSecret` resource named `example`. +// +// ```sh +// $ pulumi import github:index/actionsEnvironmentSecret:ActionsEnvironmentSecret example myrepo:myenv:mysecret +// ``` +type ActionsEnvironmentSecret struct { + pulumi.CustomResourceState + + // Date the secret was created. + CreatedAt pulumi.StringOutput `pulumi:"createdAt"` + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue pulumi.StringPtrOutput `pulumi:"encryptedValue"` + // Name of the environment. + Environment pulumi.StringOutput `pulumi:"environment"` + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId pulumi.StringOutput `pulumi:"keyId"` + // (Optional) Please use `value`. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: Use value. + PlaintextValue pulumi.StringPtrOutput `pulumi:"plaintextValue"` + // Date the secret was last updated in GitHub. + RemoteUpdatedAt pulumi.StringOutput `pulumi:"remoteUpdatedAt"` + // Name of the repository. + Repository pulumi.StringOutput `pulumi:"repository"` + // ID of the repository. + RepositoryId pulumi.IntOutput `pulumi:"repositoryId"` + // Name of the secret. + SecretName pulumi.StringOutput `pulumi:"secretName"` + // Date the secret was last updated by the provider. + UpdatedAt pulumi.StringOutput `pulumi:"updatedAt"` + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value pulumi.StringPtrOutput `pulumi:"value"` + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted pulumi.StringPtrOutput `pulumi:"valueEncrypted"` +} + +// NewActionsEnvironmentSecret registers a new resource with the given unique name, arguments, and options. +func NewActionsEnvironmentSecret(ctx *pulumi.Context, + name string, args *ActionsEnvironmentSecretArgs, opts ...pulumi.ResourceOption) (*ActionsEnvironmentSecret, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Environment == nil { + return nil, errors.New("invalid value for required argument 'Environment'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + if args.SecretName == nil { + return nil, errors.New("invalid value for required argument 'SecretName'") + } + if args.EncryptedValue != nil { + args.EncryptedValue = pulumi.ToSecret(args.EncryptedValue).(pulumi.StringPtrInput) + } + if args.PlaintextValue != nil { + args.PlaintextValue = pulumi.ToSecret(args.PlaintextValue).(pulumi.StringPtrInput) + } + if args.Value != nil { + args.Value = pulumi.ToSecret(args.Value).(pulumi.StringPtrInput) + } + if args.ValueEncrypted != nil { + args.ValueEncrypted = pulumi.ToSecret(args.ValueEncrypted).(pulumi.StringPtrInput) + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "encryptedValue", + "plaintextValue", + "value", + "valueEncrypted", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsEnvironmentSecret + err := ctx.RegisterResource("github:index/actionsEnvironmentSecret:ActionsEnvironmentSecret", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsEnvironmentSecret gets an existing ActionsEnvironmentSecret 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 GetActionsEnvironmentSecret(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsEnvironmentSecretState, opts ...pulumi.ResourceOption) (*ActionsEnvironmentSecret, error) { + var resource ActionsEnvironmentSecret + err := ctx.ReadResource("github:index/actionsEnvironmentSecret:ActionsEnvironmentSecret", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsEnvironmentSecret resources. +type actionsEnvironmentSecretState struct { + // Date the secret was created. + CreatedAt *string `pulumi:"createdAt"` + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue *string `pulumi:"encryptedValue"` + // Name of the environment. + Environment *string `pulumi:"environment"` + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId *string `pulumi:"keyId"` + // (Optional) Please use `value`. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: Use value. + PlaintextValue *string `pulumi:"plaintextValue"` + // Date the secret was last updated in GitHub. + RemoteUpdatedAt *string `pulumi:"remoteUpdatedAt"` + // Name of the repository. + Repository *string `pulumi:"repository"` + // ID of the repository. + RepositoryId *int `pulumi:"repositoryId"` + // Name of the secret. + SecretName *string `pulumi:"secretName"` + // Date the secret was last updated by the provider. + UpdatedAt *string `pulumi:"updatedAt"` + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value *string `pulumi:"value"` + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted *string `pulumi:"valueEncrypted"` +} + +type ActionsEnvironmentSecretState struct { + // Date the secret was created. + CreatedAt pulumi.StringPtrInput + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue pulumi.StringPtrInput + // Name of the environment. + Environment pulumi.StringPtrInput + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId pulumi.StringPtrInput + // (Optional) Please use `value`. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: Use value. + PlaintextValue pulumi.StringPtrInput + // Date the secret was last updated in GitHub. + RemoteUpdatedAt pulumi.StringPtrInput + // Name of the repository. + Repository pulumi.StringPtrInput + // ID of the repository. + RepositoryId pulumi.IntPtrInput + // Name of the secret. + SecretName pulumi.StringPtrInput + // Date the secret was last updated by the provider. + UpdatedAt pulumi.StringPtrInput + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value pulumi.StringPtrInput + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted pulumi.StringPtrInput +} + +func (ActionsEnvironmentSecretState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsEnvironmentSecretState)(nil)).Elem() +} + +type actionsEnvironmentSecretArgs struct { + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue *string `pulumi:"encryptedValue"` + // Name of the environment. + Environment string `pulumi:"environment"` + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId *string `pulumi:"keyId"` + // (Optional) Please use `value`. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: Use value. + PlaintextValue *string `pulumi:"plaintextValue"` + // Name of the repository. + Repository string `pulumi:"repository"` + // Name of the secret. + SecretName string `pulumi:"secretName"` + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value *string `pulumi:"value"` + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted *string `pulumi:"valueEncrypted"` +} + +// The set of arguments for constructing a ActionsEnvironmentSecret resource. +type ActionsEnvironmentSecretArgs struct { + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue pulumi.StringPtrInput + // Name of the environment. + Environment pulumi.StringInput + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId pulumi.StringPtrInput + // (Optional) Please use `value`. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: Use value. + PlaintextValue pulumi.StringPtrInput + // Name of the repository. + Repository pulumi.StringInput + // Name of the secret. + SecretName pulumi.StringInput + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value pulumi.StringPtrInput + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted pulumi.StringPtrInput +} + +func (ActionsEnvironmentSecretArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsEnvironmentSecretArgs)(nil)).Elem() +} + +type ActionsEnvironmentSecretInput interface { + pulumi.Input + + ToActionsEnvironmentSecretOutput() ActionsEnvironmentSecretOutput + ToActionsEnvironmentSecretOutputWithContext(ctx context.Context) ActionsEnvironmentSecretOutput +} + +func (*ActionsEnvironmentSecret) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsEnvironmentSecret)(nil)).Elem() +} + +func (i *ActionsEnvironmentSecret) ToActionsEnvironmentSecretOutput() ActionsEnvironmentSecretOutput { + return i.ToActionsEnvironmentSecretOutputWithContext(context.Background()) +} + +func (i *ActionsEnvironmentSecret) ToActionsEnvironmentSecretOutputWithContext(ctx context.Context) ActionsEnvironmentSecretOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsEnvironmentSecretOutput) +} + +// ActionsEnvironmentSecretArrayInput is an input type that accepts ActionsEnvironmentSecretArray and ActionsEnvironmentSecretArrayOutput values. +// You can construct a concrete instance of `ActionsEnvironmentSecretArrayInput` via: +// +// ActionsEnvironmentSecretArray{ ActionsEnvironmentSecretArgs{...} } +type ActionsEnvironmentSecretArrayInput interface { + pulumi.Input + + ToActionsEnvironmentSecretArrayOutput() ActionsEnvironmentSecretArrayOutput + ToActionsEnvironmentSecretArrayOutputWithContext(context.Context) ActionsEnvironmentSecretArrayOutput +} + +type ActionsEnvironmentSecretArray []ActionsEnvironmentSecretInput + +func (ActionsEnvironmentSecretArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsEnvironmentSecret)(nil)).Elem() +} + +func (i ActionsEnvironmentSecretArray) ToActionsEnvironmentSecretArrayOutput() ActionsEnvironmentSecretArrayOutput { + return i.ToActionsEnvironmentSecretArrayOutputWithContext(context.Background()) +} + +func (i ActionsEnvironmentSecretArray) ToActionsEnvironmentSecretArrayOutputWithContext(ctx context.Context) ActionsEnvironmentSecretArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsEnvironmentSecretArrayOutput) +} + +// ActionsEnvironmentSecretMapInput is an input type that accepts ActionsEnvironmentSecretMap and ActionsEnvironmentSecretMapOutput values. +// You can construct a concrete instance of `ActionsEnvironmentSecretMapInput` via: +// +// ActionsEnvironmentSecretMap{ "key": ActionsEnvironmentSecretArgs{...} } +type ActionsEnvironmentSecretMapInput interface { + pulumi.Input + + ToActionsEnvironmentSecretMapOutput() ActionsEnvironmentSecretMapOutput + ToActionsEnvironmentSecretMapOutputWithContext(context.Context) ActionsEnvironmentSecretMapOutput +} + +type ActionsEnvironmentSecretMap map[string]ActionsEnvironmentSecretInput + +func (ActionsEnvironmentSecretMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsEnvironmentSecret)(nil)).Elem() +} + +func (i ActionsEnvironmentSecretMap) ToActionsEnvironmentSecretMapOutput() ActionsEnvironmentSecretMapOutput { + return i.ToActionsEnvironmentSecretMapOutputWithContext(context.Background()) +} + +func (i ActionsEnvironmentSecretMap) ToActionsEnvironmentSecretMapOutputWithContext(ctx context.Context) ActionsEnvironmentSecretMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsEnvironmentSecretMapOutput) +} + +type ActionsEnvironmentSecretOutput struct{ *pulumi.OutputState } + +func (ActionsEnvironmentSecretOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsEnvironmentSecret)(nil)).Elem() +} + +func (o ActionsEnvironmentSecretOutput) ToActionsEnvironmentSecretOutput() ActionsEnvironmentSecretOutput { + return o +} + +func (o ActionsEnvironmentSecretOutput) ToActionsEnvironmentSecretOutputWithContext(ctx context.Context) ActionsEnvironmentSecretOutput { + return o +} + +// Date the secret was created. +func (o ActionsEnvironmentSecretOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsEnvironmentSecret) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) +} + +// (Optional) Please use `valueEncrypted`. +// +// Deprecated: Use valueEncrypted and key_id. +func (o ActionsEnvironmentSecretOutput) EncryptedValue() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsEnvironmentSecret) pulumi.StringPtrOutput { return v.EncryptedValue }).(pulumi.StringPtrOutput) +} + +// Name of the environment. +func (o ActionsEnvironmentSecretOutput) Environment() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsEnvironmentSecret) pulumi.StringOutput { return v.Environment }).(pulumi.StringOutput) +} + +// ID of the public key used to encrypt the secret, required when setting `encryptedValue`. +func (o ActionsEnvironmentSecretOutput) KeyId() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsEnvironmentSecret) pulumi.StringOutput { return v.KeyId }).(pulumi.StringOutput) +} + +// (Optional) Please use `value`. +// +// > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. +// +// Deprecated: Use value. +func (o ActionsEnvironmentSecretOutput) PlaintextValue() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsEnvironmentSecret) pulumi.StringPtrOutput { return v.PlaintextValue }).(pulumi.StringPtrOutput) +} + +// Date the secret was last updated in GitHub. +func (o ActionsEnvironmentSecretOutput) RemoteUpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsEnvironmentSecret) pulumi.StringOutput { return v.RemoteUpdatedAt }).(pulumi.StringOutput) +} + +// Name of the repository. +func (o ActionsEnvironmentSecretOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsEnvironmentSecret) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// ID of the repository. +func (o ActionsEnvironmentSecretOutput) RepositoryId() pulumi.IntOutput { + return o.ApplyT(func(v *ActionsEnvironmentSecret) pulumi.IntOutput { return v.RepositoryId }).(pulumi.IntOutput) +} + +// Name of the secret. +func (o ActionsEnvironmentSecretOutput) SecretName() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsEnvironmentSecret) pulumi.StringOutput { return v.SecretName }).(pulumi.StringOutput) +} + +// Date the secret was last updated by the provider. +func (o ActionsEnvironmentSecretOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsEnvironmentSecret) pulumi.StringOutput { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. +func (o ActionsEnvironmentSecretOutput) Value() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsEnvironmentSecret) pulumi.StringPtrOutput { return v.Value }).(pulumi.StringPtrOutput) +} + +// Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. +func (o ActionsEnvironmentSecretOutput) ValueEncrypted() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsEnvironmentSecret) pulumi.StringPtrOutput { return v.ValueEncrypted }).(pulumi.StringPtrOutput) +} + +type ActionsEnvironmentSecretArrayOutput struct{ *pulumi.OutputState } + +func (ActionsEnvironmentSecretArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsEnvironmentSecret)(nil)).Elem() +} + +func (o ActionsEnvironmentSecretArrayOutput) ToActionsEnvironmentSecretArrayOutput() ActionsEnvironmentSecretArrayOutput { + return o +} + +func (o ActionsEnvironmentSecretArrayOutput) ToActionsEnvironmentSecretArrayOutputWithContext(ctx context.Context) ActionsEnvironmentSecretArrayOutput { + return o +} + +func (o ActionsEnvironmentSecretArrayOutput) Index(i pulumi.IntInput) ActionsEnvironmentSecretOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsEnvironmentSecret { + return vs[0].([]*ActionsEnvironmentSecret)[vs[1].(int)] + }).(ActionsEnvironmentSecretOutput) +} + +type ActionsEnvironmentSecretMapOutput struct{ *pulumi.OutputState } + +func (ActionsEnvironmentSecretMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsEnvironmentSecret)(nil)).Elem() +} + +func (o ActionsEnvironmentSecretMapOutput) ToActionsEnvironmentSecretMapOutput() ActionsEnvironmentSecretMapOutput { + return o +} + +func (o ActionsEnvironmentSecretMapOutput) ToActionsEnvironmentSecretMapOutputWithContext(ctx context.Context) ActionsEnvironmentSecretMapOutput { + return o +} + +func (o ActionsEnvironmentSecretMapOutput) MapIndex(k pulumi.StringInput) ActionsEnvironmentSecretOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsEnvironmentSecret { + return vs[0].(map[string]*ActionsEnvironmentSecret)[vs[1].(string)] + }).(ActionsEnvironmentSecretOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsEnvironmentSecretInput)(nil)).Elem(), &ActionsEnvironmentSecret{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsEnvironmentSecretArrayInput)(nil)).Elem(), ActionsEnvironmentSecretArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsEnvironmentSecretMapInput)(nil)).Elem(), ActionsEnvironmentSecretMap{}) + pulumi.RegisterOutputType(ActionsEnvironmentSecretOutput{}) + pulumi.RegisterOutputType(ActionsEnvironmentSecretArrayOutput{}) + pulumi.RegisterOutputType(ActionsEnvironmentSecretMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsEnvironmentVariable.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsEnvironmentVariable.go new file mode 100644 index 000000000..363a52e1c --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsEnvironmentVariable.go @@ -0,0 +1,388 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage GitHub Actions variables within your GitHub repository environments. +// You must have write access to a repository to use this resource. +// +// ## Example Usage +// +// ```go +// 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.NewActionsEnvironmentVariable(ctx, "example", &github.ActionsEnvironmentVariableArgs{ +// Repository: pulumi.String("example-repo"), +// Environment: pulumi.String("example-environment"), +// VariableName: pulumi.String("example_variable_name"), +// Value: pulumi.String("example-value"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ```go +// 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.GetRepository(ctx, &github.LookupRepositoryArgs{ +// FullName: pulumi.StringRef("my-org/repo"), +// }, nil) +// if err != nil { +// return err +// } +// exampleRepositoryEnvironment, err := github.NewRepositoryEnvironment(ctx, "example", &github.RepositoryEnvironmentArgs{ +// Repository: pulumi.String(pulumi.String(example.Name)), +// Environment: pulumi.String("example_environment"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewActionsEnvironmentVariable(ctx, "example", &github.ActionsEnvironmentVariableArgs{ +// Repository: pulumi.String(pulumi.String(example.Name)), +// Environment: exampleRepositoryEnvironment.Environment, +// VariableName: pulumi.String("example_variable_name"), +// Value: pulumi.String("example-value"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using an ID made of the repository name, environment name (any `:` in the environment name need to be escaped as `??`), and variable name all separated by a `:`. +// +// ### Import Command +// +// The following command imports a GitHub actions environment variable named `myvariable` for the repo `myrepo` and environment `myenv` to a `ActionsEnvironmentVariable` resource named `example`. +// +// ```sh +// $ pulumi import github:index/actionsEnvironmentVariable:ActionsEnvironmentVariable example myrepo:myenv:myvariable +// ``` +type ActionsEnvironmentVariable struct { + pulumi.CustomResourceState + + // Date the variable was created. + CreatedAt pulumi.StringOutput `pulumi:"createdAt"` + // Name of the environment. + Environment pulumi.StringOutput `pulumi:"environment"` + // Name of the repository. + Repository pulumi.StringOutput `pulumi:"repository"` + // ID of the repository. + RepositoryId pulumi.IntOutput `pulumi:"repositoryId"` + // Date the variable was last updated. + UpdatedAt pulumi.StringOutput `pulumi:"updatedAt"` + // Value of the variable. + Value pulumi.StringOutput `pulumi:"value"` + // Name of the variable. + VariableName pulumi.StringOutput `pulumi:"variableName"` +} + +// NewActionsEnvironmentVariable registers a new resource with the given unique name, arguments, and options. +func NewActionsEnvironmentVariable(ctx *pulumi.Context, + name string, args *ActionsEnvironmentVariableArgs, opts ...pulumi.ResourceOption) (*ActionsEnvironmentVariable, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Environment == nil { + return nil, errors.New("invalid value for required argument 'Environment'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + if args.Value == nil { + return nil, errors.New("invalid value for required argument 'Value'") + } + if args.VariableName == nil { + return nil, errors.New("invalid value for required argument 'VariableName'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsEnvironmentVariable + err := ctx.RegisterResource("github:index/actionsEnvironmentVariable:ActionsEnvironmentVariable", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsEnvironmentVariable gets an existing ActionsEnvironmentVariable 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 GetActionsEnvironmentVariable(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsEnvironmentVariableState, opts ...pulumi.ResourceOption) (*ActionsEnvironmentVariable, error) { + var resource ActionsEnvironmentVariable + err := ctx.ReadResource("github:index/actionsEnvironmentVariable:ActionsEnvironmentVariable", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsEnvironmentVariable resources. +type actionsEnvironmentVariableState struct { + // Date the variable was created. + CreatedAt *string `pulumi:"createdAt"` + // Name of the environment. + Environment *string `pulumi:"environment"` + // Name of the repository. + Repository *string `pulumi:"repository"` + // ID of the repository. + RepositoryId *int `pulumi:"repositoryId"` + // Date the variable was last updated. + UpdatedAt *string `pulumi:"updatedAt"` + // Value of the variable. + Value *string `pulumi:"value"` + // Name of the variable. + VariableName *string `pulumi:"variableName"` +} + +type ActionsEnvironmentVariableState struct { + // Date the variable was created. + CreatedAt pulumi.StringPtrInput + // Name of the environment. + Environment pulumi.StringPtrInput + // Name of the repository. + Repository pulumi.StringPtrInput + // ID of the repository. + RepositoryId pulumi.IntPtrInput + // Date the variable was last updated. + UpdatedAt pulumi.StringPtrInput + // Value of the variable. + Value pulumi.StringPtrInput + // Name of the variable. + VariableName pulumi.StringPtrInput +} + +func (ActionsEnvironmentVariableState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsEnvironmentVariableState)(nil)).Elem() +} + +type actionsEnvironmentVariableArgs struct { + // Name of the environment. + Environment string `pulumi:"environment"` + // Name of the repository. + Repository string `pulumi:"repository"` + // Value of the variable. + Value string `pulumi:"value"` + // Name of the variable. + VariableName string `pulumi:"variableName"` +} + +// The set of arguments for constructing a ActionsEnvironmentVariable resource. +type ActionsEnvironmentVariableArgs struct { + // Name of the environment. + Environment pulumi.StringInput + // Name of the repository. + Repository pulumi.StringInput + // Value of the variable. + Value pulumi.StringInput + // Name of the variable. + VariableName pulumi.StringInput +} + +func (ActionsEnvironmentVariableArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsEnvironmentVariableArgs)(nil)).Elem() +} + +type ActionsEnvironmentVariableInput interface { + pulumi.Input + + ToActionsEnvironmentVariableOutput() ActionsEnvironmentVariableOutput + ToActionsEnvironmentVariableOutputWithContext(ctx context.Context) ActionsEnvironmentVariableOutput +} + +func (*ActionsEnvironmentVariable) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsEnvironmentVariable)(nil)).Elem() +} + +func (i *ActionsEnvironmentVariable) ToActionsEnvironmentVariableOutput() ActionsEnvironmentVariableOutput { + return i.ToActionsEnvironmentVariableOutputWithContext(context.Background()) +} + +func (i *ActionsEnvironmentVariable) ToActionsEnvironmentVariableOutputWithContext(ctx context.Context) ActionsEnvironmentVariableOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsEnvironmentVariableOutput) +} + +// ActionsEnvironmentVariableArrayInput is an input type that accepts ActionsEnvironmentVariableArray and ActionsEnvironmentVariableArrayOutput values. +// You can construct a concrete instance of `ActionsEnvironmentVariableArrayInput` via: +// +// ActionsEnvironmentVariableArray{ ActionsEnvironmentVariableArgs{...} } +type ActionsEnvironmentVariableArrayInput interface { + pulumi.Input + + ToActionsEnvironmentVariableArrayOutput() ActionsEnvironmentVariableArrayOutput + ToActionsEnvironmentVariableArrayOutputWithContext(context.Context) ActionsEnvironmentVariableArrayOutput +} + +type ActionsEnvironmentVariableArray []ActionsEnvironmentVariableInput + +func (ActionsEnvironmentVariableArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsEnvironmentVariable)(nil)).Elem() +} + +func (i ActionsEnvironmentVariableArray) ToActionsEnvironmentVariableArrayOutput() ActionsEnvironmentVariableArrayOutput { + return i.ToActionsEnvironmentVariableArrayOutputWithContext(context.Background()) +} + +func (i ActionsEnvironmentVariableArray) ToActionsEnvironmentVariableArrayOutputWithContext(ctx context.Context) ActionsEnvironmentVariableArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsEnvironmentVariableArrayOutput) +} + +// ActionsEnvironmentVariableMapInput is an input type that accepts ActionsEnvironmentVariableMap and ActionsEnvironmentVariableMapOutput values. +// You can construct a concrete instance of `ActionsEnvironmentVariableMapInput` via: +// +// ActionsEnvironmentVariableMap{ "key": ActionsEnvironmentVariableArgs{...} } +type ActionsEnvironmentVariableMapInput interface { + pulumi.Input + + ToActionsEnvironmentVariableMapOutput() ActionsEnvironmentVariableMapOutput + ToActionsEnvironmentVariableMapOutputWithContext(context.Context) ActionsEnvironmentVariableMapOutput +} + +type ActionsEnvironmentVariableMap map[string]ActionsEnvironmentVariableInput + +func (ActionsEnvironmentVariableMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsEnvironmentVariable)(nil)).Elem() +} + +func (i ActionsEnvironmentVariableMap) ToActionsEnvironmentVariableMapOutput() ActionsEnvironmentVariableMapOutput { + return i.ToActionsEnvironmentVariableMapOutputWithContext(context.Background()) +} + +func (i ActionsEnvironmentVariableMap) ToActionsEnvironmentVariableMapOutputWithContext(ctx context.Context) ActionsEnvironmentVariableMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsEnvironmentVariableMapOutput) +} + +type ActionsEnvironmentVariableOutput struct{ *pulumi.OutputState } + +func (ActionsEnvironmentVariableOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsEnvironmentVariable)(nil)).Elem() +} + +func (o ActionsEnvironmentVariableOutput) ToActionsEnvironmentVariableOutput() ActionsEnvironmentVariableOutput { + return o +} + +func (o ActionsEnvironmentVariableOutput) ToActionsEnvironmentVariableOutputWithContext(ctx context.Context) ActionsEnvironmentVariableOutput { + return o +} + +// Date the variable was created. +func (o ActionsEnvironmentVariableOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsEnvironmentVariable) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) +} + +// Name of the environment. +func (o ActionsEnvironmentVariableOutput) Environment() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsEnvironmentVariable) pulumi.StringOutput { return v.Environment }).(pulumi.StringOutput) +} + +// Name of the repository. +func (o ActionsEnvironmentVariableOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsEnvironmentVariable) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// ID of the repository. +func (o ActionsEnvironmentVariableOutput) RepositoryId() pulumi.IntOutput { + return o.ApplyT(func(v *ActionsEnvironmentVariable) pulumi.IntOutput { return v.RepositoryId }).(pulumi.IntOutput) +} + +// Date the variable was last updated. +func (o ActionsEnvironmentVariableOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsEnvironmentVariable) pulumi.StringOutput { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// Value of the variable. +func (o ActionsEnvironmentVariableOutput) Value() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsEnvironmentVariable) pulumi.StringOutput { return v.Value }).(pulumi.StringOutput) +} + +// Name of the variable. +func (o ActionsEnvironmentVariableOutput) VariableName() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsEnvironmentVariable) pulumi.StringOutput { return v.VariableName }).(pulumi.StringOutput) +} + +type ActionsEnvironmentVariableArrayOutput struct{ *pulumi.OutputState } + +func (ActionsEnvironmentVariableArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsEnvironmentVariable)(nil)).Elem() +} + +func (o ActionsEnvironmentVariableArrayOutput) ToActionsEnvironmentVariableArrayOutput() ActionsEnvironmentVariableArrayOutput { + return o +} + +func (o ActionsEnvironmentVariableArrayOutput) ToActionsEnvironmentVariableArrayOutputWithContext(ctx context.Context) ActionsEnvironmentVariableArrayOutput { + return o +} + +func (o ActionsEnvironmentVariableArrayOutput) Index(i pulumi.IntInput) ActionsEnvironmentVariableOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsEnvironmentVariable { + return vs[0].([]*ActionsEnvironmentVariable)[vs[1].(int)] + }).(ActionsEnvironmentVariableOutput) +} + +type ActionsEnvironmentVariableMapOutput struct{ *pulumi.OutputState } + +func (ActionsEnvironmentVariableMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsEnvironmentVariable)(nil)).Elem() +} + +func (o ActionsEnvironmentVariableMapOutput) ToActionsEnvironmentVariableMapOutput() ActionsEnvironmentVariableMapOutput { + return o +} + +func (o ActionsEnvironmentVariableMapOutput) ToActionsEnvironmentVariableMapOutputWithContext(ctx context.Context) ActionsEnvironmentVariableMapOutput { + return o +} + +func (o ActionsEnvironmentVariableMapOutput) MapIndex(k pulumi.StringInput) ActionsEnvironmentVariableOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsEnvironmentVariable { + return vs[0].(map[string]*ActionsEnvironmentVariable)[vs[1].(string)] + }).(ActionsEnvironmentVariableOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsEnvironmentVariableInput)(nil)).Elem(), &ActionsEnvironmentVariable{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsEnvironmentVariableArrayInput)(nil)).Elem(), ActionsEnvironmentVariableArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsEnvironmentVariableMapInput)(nil)).Elem(), ActionsEnvironmentVariableMap{}) + pulumi.RegisterOutputType(ActionsEnvironmentVariableOutput{}) + pulumi.RegisterOutputType(ActionsEnvironmentVariableArrayOutput{}) + pulumi.RegisterOutputType(ActionsEnvironmentVariableMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsHostedRunner.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsHostedRunner.go new file mode 100644 index 000000000..da2b03066 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsHostedRunner.go @@ -0,0 +1,496 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage GitHub-hosted runners within your GitHub organization. +// You must have admin access to an organization to use this resource. +// +// GitHub-hosted runners are fully managed virtual machines that run your GitHub Actions workflows. Unlike self-hosted runners, GitHub handles the infrastructure, maintenance, and scaling. +// +// ## Example Usage +// +// ### Basic Usage +// +// ```go +// 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.NewActionsRunnerGroup(ctx, "example", &github.ActionsRunnerGroupArgs{ +// Name: pulumi.String("example-runner-group"), +// Visibility: pulumi.String("all"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewActionsHostedRunner(ctx, "example", &github.ActionsHostedRunnerArgs{ +// Name: pulumi.String("example-hosted-runner"), +// Image: &github.ActionsHostedRunnerImageArgs{ +// Id: pulumi.String("2306"), +// Source: pulumi.String("github"), +// }, +// Size: pulumi.String("4-core"), +// RunnerGroupId: example.ID(), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ### Advanced Usage with Optional Parameters +// +// ```go +// 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 { +// advanced, err := github.NewActionsRunnerGroup(ctx, "advanced", &github.ActionsRunnerGroupArgs{ +// Name: pulumi.String("advanced-runner-group"), +// Visibility: pulumi.String("selected"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewActionsHostedRunner(ctx, "advanced", &github.ActionsHostedRunnerArgs{ +// Name: pulumi.String("advanced-hosted-runner"), +// Image: &github.ActionsHostedRunnerImageArgs{ +// Id: pulumi.String("2306"), +// Source: pulumi.String("github"), +// }, +// Size: pulumi.String("8-core"), +// RunnerGroupId: advanced.ID(), +// MaximumRunners: pulumi.Int(10), +// PublicIpEnabled: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Notes +// +// * This resource is **organization-only** and cannot be used with individual accounts. +// * The `image` field cannot be changed after the runner is created. Changing it will force recreation of the runner. +// * The `size` field can be updated to scale the runner up or down as needed. +// * Image IDs for GitHub-owned images are numeric strings (e.g., "2306" for Ubuntu Latest 24.04), not names like "ubuntu-latest". +// * Deletion of hosted runners is asynchronous. The provider will poll for up to 10 minutes (configurable via timeouts) to confirm deletion. +// * Runner creation and updates may take several minutes as GitHub provisions the infrastructure. +// * Static public IPs are subject to account limits. Check your organization's limits before enabling. +// +// ## Getting Available Images and Sizes +// +// To get a list of available images: +// +// To get available machine sizes: +// +// ## Import +// +// Hosted runners can be imported using the runner ID: +// +// ```sh +// $ pulumi import github:index/actionsHostedRunner:ActionsHostedRunner example 123456 +// ``` +type ActionsHostedRunner struct { + pulumi.CustomResourceState + + // Image configuration for the hosted runner. Cannot be changed after creation. Block supports: + Image ActionsHostedRunnerImageOutput `pulumi:"image"` + // Whether this runner should be used to generate custom images. Cannot be changed after creation. + ImageGen pulumi.BoolPtrOutput `pulumi:"imageGen"` + // The version of the runner image to deploy. This is only relevant for runners using custom images. + ImageVersion pulumi.StringPtrOutput `pulumi:"imageVersion"` + // Timestamp (RFC3339) when the runner was last active. + LastActiveOn pulumi.StringOutput `pulumi:"lastActiveOn"` + // Detailed specifications of the machine size: + MachineSizeDetails ActionsHostedRunnerMachineSizeDetailArrayOutput `pulumi:"machineSizeDetails"` + // Maximum number of runners to scale up to. Runners will not auto-scale above this number. Use this setting to limit costs. + MaximumRunners pulumi.IntOutput `pulumi:"maximumRunners"` + // Name of the hosted runner. Must be between 1 and 64 characters and may only contain alphanumeric characters, '.', '-', and '_'. + Name pulumi.StringOutput `pulumi:"name"` + // Platform of the runner (e.g., "linux-x64", "win-x64"). + Platform pulumi.StringOutput `pulumi:"platform"` + // Whether to enable static public IP for the runner. Note there are account limits. To list limits, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/limits`. Defaults to false. + PublicIpEnabled pulumi.BoolPtrOutput `pulumi:"publicIpEnabled"` + // List of public IP ranges assigned to this runner (only if `publicIpEnabled` is true): + PublicIps ActionsHostedRunnerPublicIpArrayOutput `pulumi:"publicIps"` + // The ID of the runner group to assign this runner to. + RunnerGroupId pulumi.IntOutput `pulumi:"runnerGroupId"` + // Machine size for the hosted runner (e.g., "4-core", "8-core"). Can be updated to scale the runner. To list available sizes, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/machine-sizes`. + Size pulumi.StringOutput `pulumi:"size"` + // Current status of the runner (e.g., "Ready", "Provisioning"). + Status pulumi.StringOutput `pulumi:"status"` +} + +// NewActionsHostedRunner registers a new resource with the given unique name, arguments, and options. +func NewActionsHostedRunner(ctx *pulumi.Context, + name string, args *ActionsHostedRunnerArgs, opts ...pulumi.ResourceOption) (*ActionsHostedRunner, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Image == nil { + return nil, errors.New("invalid value for required argument 'Image'") + } + if args.RunnerGroupId == nil { + return nil, errors.New("invalid value for required argument 'RunnerGroupId'") + } + if args.Size == nil { + return nil, errors.New("invalid value for required argument 'Size'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsHostedRunner + err := ctx.RegisterResource("github:index/actionsHostedRunner:ActionsHostedRunner", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsHostedRunner gets an existing ActionsHostedRunner 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 GetActionsHostedRunner(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsHostedRunnerState, opts ...pulumi.ResourceOption) (*ActionsHostedRunner, error) { + var resource ActionsHostedRunner + err := ctx.ReadResource("github:index/actionsHostedRunner:ActionsHostedRunner", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsHostedRunner resources. +type actionsHostedRunnerState struct { + // Image configuration for the hosted runner. Cannot be changed after creation. Block supports: + Image *ActionsHostedRunnerImage `pulumi:"image"` + // Whether this runner should be used to generate custom images. Cannot be changed after creation. + ImageGen *bool `pulumi:"imageGen"` + // The version of the runner image to deploy. This is only relevant for runners using custom images. + ImageVersion *string `pulumi:"imageVersion"` + // Timestamp (RFC3339) when the runner was last active. + LastActiveOn *string `pulumi:"lastActiveOn"` + // Detailed specifications of the machine size: + MachineSizeDetails []ActionsHostedRunnerMachineSizeDetail `pulumi:"machineSizeDetails"` + // Maximum number of runners to scale up to. Runners will not auto-scale above this number. Use this setting to limit costs. + MaximumRunners *int `pulumi:"maximumRunners"` + // Name of the hosted runner. Must be between 1 and 64 characters and may only contain alphanumeric characters, '.', '-', and '_'. + Name *string `pulumi:"name"` + // Platform of the runner (e.g., "linux-x64", "win-x64"). + Platform *string `pulumi:"platform"` + // Whether to enable static public IP for the runner. Note there are account limits. To list limits, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/limits`. Defaults to false. + PublicIpEnabled *bool `pulumi:"publicIpEnabled"` + // List of public IP ranges assigned to this runner (only if `publicIpEnabled` is true): + PublicIps []ActionsHostedRunnerPublicIp `pulumi:"publicIps"` + // The ID of the runner group to assign this runner to. + RunnerGroupId *int `pulumi:"runnerGroupId"` + // Machine size for the hosted runner (e.g., "4-core", "8-core"). Can be updated to scale the runner. To list available sizes, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/machine-sizes`. + Size *string `pulumi:"size"` + // Current status of the runner (e.g., "Ready", "Provisioning"). + Status *string `pulumi:"status"` +} + +type ActionsHostedRunnerState struct { + // Image configuration for the hosted runner. Cannot be changed after creation. Block supports: + Image ActionsHostedRunnerImagePtrInput + // Whether this runner should be used to generate custom images. Cannot be changed after creation. + ImageGen pulumi.BoolPtrInput + // The version of the runner image to deploy. This is only relevant for runners using custom images. + ImageVersion pulumi.StringPtrInput + // Timestamp (RFC3339) when the runner was last active. + LastActiveOn pulumi.StringPtrInput + // Detailed specifications of the machine size: + MachineSizeDetails ActionsHostedRunnerMachineSizeDetailArrayInput + // Maximum number of runners to scale up to. Runners will not auto-scale above this number. Use this setting to limit costs. + MaximumRunners pulumi.IntPtrInput + // Name of the hosted runner. Must be between 1 and 64 characters and may only contain alphanumeric characters, '.', '-', and '_'. + Name pulumi.StringPtrInput + // Platform of the runner (e.g., "linux-x64", "win-x64"). + Platform pulumi.StringPtrInput + // Whether to enable static public IP for the runner. Note there are account limits. To list limits, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/limits`. Defaults to false. + PublicIpEnabled pulumi.BoolPtrInput + // List of public IP ranges assigned to this runner (only if `publicIpEnabled` is true): + PublicIps ActionsHostedRunnerPublicIpArrayInput + // The ID of the runner group to assign this runner to. + RunnerGroupId pulumi.IntPtrInput + // Machine size for the hosted runner (e.g., "4-core", "8-core"). Can be updated to scale the runner. To list available sizes, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/machine-sizes`. + Size pulumi.StringPtrInput + // Current status of the runner (e.g., "Ready", "Provisioning"). + Status pulumi.StringPtrInput +} + +func (ActionsHostedRunnerState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsHostedRunnerState)(nil)).Elem() +} + +type actionsHostedRunnerArgs struct { + // Image configuration for the hosted runner. Cannot be changed after creation. Block supports: + Image ActionsHostedRunnerImage `pulumi:"image"` + // Whether this runner should be used to generate custom images. Cannot be changed after creation. + ImageGen *bool `pulumi:"imageGen"` + // The version of the runner image to deploy. This is only relevant for runners using custom images. + ImageVersion *string `pulumi:"imageVersion"` + // Maximum number of runners to scale up to. Runners will not auto-scale above this number. Use this setting to limit costs. + MaximumRunners *int `pulumi:"maximumRunners"` + // Name of the hosted runner. Must be between 1 and 64 characters and may only contain alphanumeric characters, '.', '-', and '_'. + Name *string `pulumi:"name"` + // Whether to enable static public IP for the runner. Note there are account limits. To list limits, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/limits`. Defaults to false. + PublicIpEnabled *bool `pulumi:"publicIpEnabled"` + // The ID of the runner group to assign this runner to. + RunnerGroupId int `pulumi:"runnerGroupId"` + // Machine size for the hosted runner (e.g., "4-core", "8-core"). Can be updated to scale the runner. To list available sizes, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/machine-sizes`. + Size string `pulumi:"size"` +} + +// The set of arguments for constructing a ActionsHostedRunner resource. +type ActionsHostedRunnerArgs struct { + // Image configuration for the hosted runner. Cannot be changed after creation. Block supports: + Image ActionsHostedRunnerImageInput + // Whether this runner should be used to generate custom images. Cannot be changed after creation. + ImageGen pulumi.BoolPtrInput + // The version of the runner image to deploy. This is only relevant for runners using custom images. + ImageVersion pulumi.StringPtrInput + // Maximum number of runners to scale up to. Runners will not auto-scale above this number. Use this setting to limit costs. + MaximumRunners pulumi.IntPtrInput + // Name of the hosted runner. Must be between 1 and 64 characters and may only contain alphanumeric characters, '.', '-', and '_'. + Name pulumi.StringPtrInput + // Whether to enable static public IP for the runner. Note there are account limits. To list limits, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/limits`. Defaults to false. + PublicIpEnabled pulumi.BoolPtrInput + // The ID of the runner group to assign this runner to. + RunnerGroupId pulumi.IntInput + // Machine size for the hosted runner (e.g., "4-core", "8-core"). Can be updated to scale the runner. To list available sizes, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/machine-sizes`. + Size pulumi.StringInput +} + +func (ActionsHostedRunnerArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsHostedRunnerArgs)(nil)).Elem() +} + +type ActionsHostedRunnerInput interface { + pulumi.Input + + ToActionsHostedRunnerOutput() ActionsHostedRunnerOutput + ToActionsHostedRunnerOutputWithContext(ctx context.Context) ActionsHostedRunnerOutput +} + +func (*ActionsHostedRunner) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsHostedRunner)(nil)).Elem() +} + +func (i *ActionsHostedRunner) ToActionsHostedRunnerOutput() ActionsHostedRunnerOutput { + return i.ToActionsHostedRunnerOutputWithContext(context.Background()) +} + +func (i *ActionsHostedRunner) ToActionsHostedRunnerOutputWithContext(ctx context.Context) ActionsHostedRunnerOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsHostedRunnerOutput) +} + +// ActionsHostedRunnerArrayInput is an input type that accepts ActionsHostedRunnerArray and ActionsHostedRunnerArrayOutput values. +// You can construct a concrete instance of `ActionsHostedRunnerArrayInput` via: +// +// ActionsHostedRunnerArray{ ActionsHostedRunnerArgs{...} } +type ActionsHostedRunnerArrayInput interface { + pulumi.Input + + ToActionsHostedRunnerArrayOutput() ActionsHostedRunnerArrayOutput + ToActionsHostedRunnerArrayOutputWithContext(context.Context) ActionsHostedRunnerArrayOutput +} + +type ActionsHostedRunnerArray []ActionsHostedRunnerInput + +func (ActionsHostedRunnerArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsHostedRunner)(nil)).Elem() +} + +func (i ActionsHostedRunnerArray) ToActionsHostedRunnerArrayOutput() ActionsHostedRunnerArrayOutput { + return i.ToActionsHostedRunnerArrayOutputWithContext(context.Background()) +} + +func (i ActionsHostedRunnerArray) ToActionsHostedRunnerArrayOutputWithContext(ctx context.Context) ActionsHostedRunnerArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsHostedRunnerArrayOutput) +} + +// ActionsHostedRunnerMapInput is an input type that accepts ActionsHostedRunnerMap and ActionsHostedRunnerMapOutput values. +// You can construct a concrete instance of `ActionsHostedRunnerMapInput` via: +// +// ActionsHostedRunnerMap{ "key": ActionsHostedRunnerArgs{...} } +type ActionsHostedRunnerMapInput interface { + pulumi.Input + + ToActionsHostedRunnerMapOutput() ActionsHostedRunnerMapOutput + ToActionsHostedRunnerMapOutputWithContext(context.Context) ActionsHostedRunnerMapOutput +} + +type ActionsHostedRunnerMap map[string]ActionsHostedRunnerInput + +func (ActionsHostedRunnerMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsHostedRunner)(nil)).Elem() +} + +func (i ActionsHostedRunnerMap) ToActionsHostedRunnerMapOutput() ActionsHostedRunnerMapOutput { + return i.ToActionsHostedRunnerMapOutputWithContext(context.Background()) +} + +func (i ActionsHostedRunnerMap) ToActionsHostedRunnerMapOutputWithContext(ctx context.Context) ActionsHostedRunnerMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsHostedRunnerMapOutput) +} + +type ActionsHostedRunnerOutput struct{ *pulumi.OutputState } + +func (ActionsHostedRunnerOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsHostedRunner)(nil)).Elem() +} + +func (o ActionsHostedRunnerOutput) ToActionsHostedRunnerOutput() ActionsHostedRunnerOutput { + return o +} + +func (o ActionsHostedRunnerOutput) ToActionsHostedRunnerOutputWithContext(ctx context.Context) ActionsHostedRunnerOutput { + return o +} + +// Image configuration for the hosted runner. Cannot be changed after creation. Block supports: +func (o ActionsHostedRunnerOutput) Image() ActionsHostedRunnerImageOutput { + return o.ApplyT(func(v *ActionsHostedRunner) ActionsHostedRunnerImageOutput { return v.Image }).(ActionsHostedRunnerImageOutput) +} + +// Whether this runner should be used to generate custom images. Cannot be changed after creation. +func (o ActionsHostedRunnerOutput) ImageGen() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ActionsHostedRunner) pulumi.BoolPtrOutput { return v.ImageGen }).(pulumi.BoolPtrOutput) +} + +// The version of the runner image to deploy. This is only relevant for runners using custom images. +func (o ActionsHostedRunnerOutput) ImageVersion() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsHostedRunner) pulumi.StringPtrOutput { return v.ImageVersion }).(pulumi.StringPtrOutput) +} + +// Timestamp (RFC3339) when the runner was last active. +func (o ActionsHostedRunnerOutput) LastActiveOn() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsHostedRunner) pulumi.StringOutput { return v.LastActiveOn }).(pulumi.StringOutput) +} + +// Detailed specifications of the machine size: +func (o ActionsHostedRunnerOutput) MachineSizeDetails() ActionsHostedRunnerMachineSizeDetailArrayOutput { + return o.ApplyT(func(v *ActionsHostedRunner) ActionsHostedRunnerMachineSizeDetailArrayOutput { + return v.MachineSizeDetails + }).(ActionsHostedRunnerMachineSizeDetailArrayOutput) +} + +// Maximum number of runners to scale up to. Runners will not auto-scale above this number. Use this setting to limit costs. +func (o ActionsHostedRunnerOutput) MaximumRunners() pulumi.IntOutput { + return o.ApplyT(func(v *ActionsHostedRunner) pulumi.IntOutput { return v.MaximumRunners }).(pulumi.IntOutput) +} + +// Name of the hosted runner. Must be between 1 and 64 characters and may only contain alphanumeric characters, '.', '-', and '_'. +func (o ActionsHostedRunnerOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsHostedRunner) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// Platform of the runner (e.g., "linux-x64", "win-x64"). +func (o ActionsHostedRunnerOutput) Platform() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsHostedRunner) pulumi.StringOutput { return v.Platform }).(pulumi.StringOutput) +} + +// Whether to enable static public IP for the runner. Note there are account limits. To list limits, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/limits`. Defaults to false. +func (o ActionsHostedRunnerOutput) PublicIpEnabled() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ActionsHostedRunner) pulumi.BoolPtrOutput { return v.PublicIpEnabled }).(pulumi.BoolPtrOutput) +} + +// List of public IP ranges assigned to this runner (only if `publicIpEnabled` is true): +func (o ActionsHostedRunnerOutput) PublicIps() ActionsHostedRunnerPublicIpArrayOutput { + return o.ApplyT(func(v *ActionsHostedRunner) ActionsHostedRunnerPublicIpArrayOutput { return v.PublicIps }).(ActionsHostedRunnerPublicIpArrayOutput) +} + +// The ID of the runner group to assign this runner to. +func (o ActionsHostedRunnerOutput) RunnerGroupId() pulumi.IntOutput { + return o.ApplyT(func(v *ActionsHostedRunner) pulumi.IntOutput { return v.RunnerGroupId }).(pulumi.IntOutput) +} + +// Machine size for the hosted runner (e.g., "4-core", "8-core"). Can be updated to scale the runner. To list available sizes, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/machine-sizes`. +func (o ActionsHostedRunnerOutput) Size() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsHostedRunner) pulumi.StringOutput { return v.Size }).(pulumi.StringOutput) +} + +// Current status of the runner (e.g., "Ready", "Provisioning"). +func (o ActionsHostedRunnerOutput) Status() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsHostedRunner) pulumi.StringOutput { return v.Status }).(pulumi.StringOutput) +} + +type ActionsHostedRunnerArrayOutput struct{ *pulumi.OutputState } + +func (ActionsHostedRunnerArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsHostedRunner)(nil)).Elem() +} + +func (o ActionsHostedRunnerArrayOutput) ToActionsHostedRunnerArrayOutput() ActionsHostedRunnerArrayOutput { + return o +} + +func (o ActionsHostedRunnerArrayOutput) ToActionsHostedRunnerArrayOutputWithContext(ctx context.Context) ActionsHostedRunnerArrayOutput { + return o +} + +func (o ActionsHostedRunnerArrayOutput) Index(i pulumi.IntInput) ActionsHostedRunnerOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsHostedRunner { + return vs[0].([]*ActionsHostedRunner)[vs[1].(int)] + }).(ActionsHostedRunnerOutput) +} + +type ActionsHostedRunnerMapOutput struct{ *pulumi.OutputState } + +func (ActionsHostedRunnerMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsHostedRunner)(nil)).Elem() +} + +func (o ActionsHostedRunnerMapOutput) ToActionsHostedRunnerMapOutput() ActionsHostedRunnerMapOutput { + return o +} + +func (o ActionsHostedRunnerMapOutput) ToActionsHostedRunnerMapOutputWithContext(ctx context.Context) ActionsHostedRunnerMapOutput { + return o +} + +func (o ActionsHostedRunnerMapOutput) MapIndex(k pulumi.StringInput) ActionsHostedRunnerOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsHostedRunner { + return vs[0].(map[string]*ActionsHostedRunner)[vs[1].(string)] + }).(ActionsHostedRunnerOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsHostedRunnerInput)(nil)).Elem(), &ActionsHostedRunner{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsHostedRunnerArrayInput)(nil)).Elem(), ActionsHostedRunnerArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsHostedRunnerMapInput)(nil)).Elem(), ActionsHostedRunnerMap{}) + pulumi.RegisterOutputType(ActionsHostedRunnerOutput{}) + pulumi.RegisterOutputType(ActionsHostedRunnerArrayOutput{}) + pulumi.RegisterOutputType(ActionsHostedRunnerMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationOidcSubjectClaimCustomizationTemplate.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationOidcSubjectClaimCustomizationTemplate.go new file mode 100644 index 000000000..52af9dddf --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationOidcSubjectClaimCustomizationTemplate.go @@ -0,0 +1,263 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage an OpenID Connect subject claim customization template within a GitHub +// organization. +// +// More information on integrating GitHub with cloud providers using OpenID Connect and a list of available claims is +// available in the [Actions documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect). +// +// ## Example Usage +// +// ```go +// 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.NewActionsOrganizationOidcSubjectClaimCustomizationTemplate(ctx, "example_template", &github.ActionsOrganizationOidcSubjectClaimCustomizationTemplateArgs{ +// IncludeClaimKeys: pulumi.StringArray{ +// pulumi.String("actor"), +// pulumi.String("context"), +// pulumi.String("repository_owner"), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using the organization's name. +// +// ```sh +// $ pulumi import github:index/actionsOrganizationOidcSubjectClaimCustomizationTemplate:ActionsOrganizationOidcSubjectClaimCustomizationTemplate test example_organization +// ``` +type ActionsOrganizationOidcSubjectClaimCustomizationTemplate struct { + pulumi.CustomResourceState + + // A list of OpenID Connect claims. + IncludeClaimKeys pulumi.StringArrayOutput `pulumi:"includeClaimKeys"` +} + +// NewActionsOrganizationOidcSubjectClaimCustomizationTemplate registers a new resource with the given unique name, arguments, and options. +func NewActionsOrganizationOidcSubjectClaimCustomizationTemplate(ctx *pulumi.Context, + name string, args *ActionsOrganizationOidcSubjectClaimCustomizationTemplateArgs, opts ...pulumi.ResourceOption) (*ActionsOrganizationOidcSubjectClaimCustomizationTemplate, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.IncludeClaimKeys == nil { + return nil, errors.New("invalid value for required argument 'IncludeClaimKeys'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsOrganizationOidcSubjectClaimCustomizationTemplate + err := ctx.RegisterResource("github:index/actionsOrganizationOidcSubjectClaimCustomizationTemplate:ActionsOrganizationOidcSubjectClaimCustomizationTemplate", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsOrganizationOidcSubjectClaimCustomizationTemplate gets an existing ActionsOrganizationOidcSubjectClaimCustomizationTemplate 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 GetActionsOrganizationOidcSubjectClaimCustomizationTemplate(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsOrganizationOidcSubjectClaimCustomizationTemplateState, opts ...pulumi.ResourceOption) (*ActionsOrganizationOidcSubjectClaimCustomizationTemplate, error) { + var resource ActionsOrganizationOidcSubjectClaimCustomizationTemplate + err := ctx.ReadResource("github:index/actionsOrganizationOidcSubjectClaimCustomizationTemplate:ActionsOrganizationOidcSubjectClaimCustomizationTemplate", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsOrganizationOidcSubjectClaimCustomizationTemplate resources. +type actionsOrganizationOidcSubjectClaimCustomizationTemplateState struct { + // A list of OpenID Connect claims. + IncludeClaimKeys []string `pulumi:"includeClaimKeys"` +} + +type ActionsOrganizationOidcSubjectClaimCustomizationTemplateState struct { + // A list of OpenID Connect claims. + IncludeClaimKeys pulumi.StringArrayInput +} + +func (ActionsOrganizationOidcSubjectClaimCustomizationTemplateState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationOidcSubjectClaimCustomizationTemplateState)(nil)).Elem() +} + +type actionsOrganizationOidcSubjectClaimCustomizationTemplateArgs struct { + // A list of OpenID Connect claims. + IncludeClaimKeys []string `pulumi:"includeClaimKeys"` +} + +// The set of arguments for constructing a ActionsOrganizationOidcSubjectClaimCustomizationTemplate resource. +type ActionsOrganizationOidcSubjectClaimCustomizationTemplateArgs struct { + // A list of OpenID Connect claims. + IncludeClaimKeys pulumi.StringArrayInput +} + +func (ActionsOrganizationOidcSubjectClaimCustomizationTemplateArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationOidcSubjectClaimCustomizationTemplateArgs)(nil)).Elem() +} + +type ActionsOrganizationOidcSubjectClaimCustomizationTemplateInput interface { + pulumi.Input + + ToActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput() ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput + ToActionsOrganizationOidcSubjectClaimCustomizationTemplateOutputWithContext(ctx context.Context) ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput +} + +func (*ActionsOrganizationOidcSubjectClaimCustomizationTemplate) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationOidcSubjectClaimCustomizationTemplate)(nil)).Elem() +} + +func (i *ActionsOrganizationOidcSubjectClaimCustomizationTemplate) ToActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput() ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput { + return i.ToActionsOrganizationOidcSubjectClaimCustomizationTemplateOutputWithContext(context.Background()) +} + +func (i *ActionsOrganizationOidcSubjectClaimCustomizationTemplate) ToActionsOrganizationOidcSubjectClaimCustomizationTemplateOutputWithContext(ctx context.Context) ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput) +} + +// ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayInput is an input type that accepts ActionsOrganizationOidcSubjectClaimCustomizationTemplateArray and ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput values. +// You can construct a concrete instance of `ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayInput` via: +// +// ActionsOrganizationOidcSubjectClaimCustomizationTemplateArray{ ActionsOrganizationOidcSubjectClaimCustomizationTemplateArgs{...} } +type ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayInput interface { + pulumi.Input + + ToActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput() ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput + ToActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutputWithContext(context.Context) ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput +} + +type ActionsOrganizationOidcSubjectClaimCustomizationTemplateArray []ActionsOrganizationOidcSubjectClaimCustomizationTemplateInput + +func (ActionsOrganizationOidcSubjectClaimCustomizationTemplateArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationOidcSubjectClaimCustomizationTemplate)(nil)).Elem() +} + +func (i ActionsOrganizationOidcSubjectClaimCustomizationTemplateArray) ToActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput() ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput { + return i.ToActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationOidcSubjectClaimCustomizationTemplateArray) ToActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutputWithContext(ctx context.Context) ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput) +} + +// ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapInput is an input type that accepts ActionsOrganizationOidcSubjectClaimCustomizationTemplateMap and ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput values. +// You can construct a concrete instance of `ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapInput` via: +// +// ActionsOrganizationOidcSubjectClaimCustomizationTemplateMap{ "key": ActionsOrganizationOidcSubjectClaimCustomizationTemplateArgs{...} } +type ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapInput interface { + pulumi.Input + + ToActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput() ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput + ToActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutputWithContext(context.Context) ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput +} + +type ActionsOrganizationOidcSubjectClaimCustomizationTemplateMap map[string]ActionsOrganizationOidcSubjectClaimCustomizationTemplateInput + +func (ActionsOrganizationOidcSubjectClaimCustomizationTemplateMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationOidcSubjectClaimCustomizationTemplate)(nil)).Elem() +} + +func (i ActionsOrganizationOidcSubjectClaimCustomizationTemplateMap) ToActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput() ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput { + return i.ToActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationOidcSubjectClaimCustomizationTemplateMap) ToActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutputWithContext(ctx context.Context) ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput) +} + +type ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationOidcSubjectClaimCustomizationTemplate)(nil)).Elem() +} + +func (o ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput) ToActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput() ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput { + return o +} + +func (o ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput) ToActionsOrganizationOidcSubjectClaimCustomizationTemplateOutputWithContext(ctx context.Context) ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput { + return o +} + +// A list of OpenID Connect claims. +func (o ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput) IncludeClaimKeys() pulumi.StringArrayOutput { + return o.ApplyT(func(v *ActionsOrganizationOidcSubjectClaimCustomizationTemplate) pulumi.StringArrayOutput { + return v.IncludeClaimKeys + }).(pulumi.StringArrayOutput) +} + +type ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationOidcSubjectClaimCustomizationTemplate)(nil)).Elem() +} + +func (o ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput) ToActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput() ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput { + return o +} + +func (o ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput) ToActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutputWithContext(ctx context.Context) ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput { + return o +} + +func (o ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput) Index(i pulumi.IntInput) ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsOrganizationOidcSubjectClaimCustomizationTemplate { + return vs[0].([]*ActionsOrganizationOidcSubjectClaimCustomizationTemplate)[vs[1].(int)] + }).(ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput) +} + +type ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationOidcSubjectClaimCustomizationTemplate)(nil)).Elem() +} + +func (o ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput) ToActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput() ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput { + return o +} + +func (o ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput) ToActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutputWithContext(ctx context.Context) ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput { + return o +} + +func (o ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput) MapIndex(k pulumi.StringInput) ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsOrganizationOidcSubjectClaimCustomizationTemplate { + return vs[0].(map[string]*ActionsOrganizationOidcSubjectClaimCustomizationTemplate)[vs[1].(string)] + }).(ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationOidcSubjectClaimCustomizationTemplateInput)(nil)).Elem(), &ActionsOrganizationOidcSubjectClaimCustomizationTemplate{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayInput)(nil)).Elem(), ActionsOrganizationOidcSubjectClaimCustomizationTemplateArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapInput)(nil)).Elem(), ActionsOrganizationOidcSubjectClaimCustomizationTemplateMap{}) + pulumi.RegisterOutputType(ActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationOidcSubjectClaimCustomizationTemplateArrayOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationOidcSubjectClaimCustomizationTemplateMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationPermissions.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationPermissions.go new file mode 100644 index 000000000..9b1b57b35 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationPermissions.go @@ -0,0 +1,338 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage GitHub Actions permissions within your GitHub enterprise organizations. +// You must have admin access to an organization to use this resource. +// +// ## Example Usage +// +// ```go +// 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.NewActionsOrganizationPermissions(ctx, "test", &github.ActionsOrganizationPermissionsArgs{ +// AllowedActions: pulumi.String("selected"), +// EnabledRepositories: pulumi.String("selected"), +// AllowedActionsConfig: &github.ActionsOrganizationPermissionsAllowedActionsConfigArgs{ +// GithubOwnedAllowed: pulumi.Bool(true), +// PatternsAlloweds: pulumi.StringArray{ +// pulumi.String("actions/cache@*"), +// pulumi.String("actions/checkout@*"), +// }, +// VerifiedAllowed: pulumi.Bool(true), +// }, +// EnabledRepositoriesConfig: &github.ActionsOrganizationPermissionsEnabledRepositoriesConfigArgs{ +// RepositoryIds: pulumi.IntArray{ +// example.RepoId, +// }, +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using the name of the GitHub organization: +// +// ```sh +// $ pulumi import github:index/actionsOrganizationPermissions:ActionsOrganizationPermissions test github_organization_name +// ``` +type ActionsOrganizationPermissions struct { + pulumi.CustomResourceState + + // The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. + AllowedActions pulumi.StringPtrOutput `pulumi:"allowedActions"` + // Sets the actions that are allowed in an organization. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. + AllowedActionsConfig ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput `pulumi:"allowedActionsConfig"` + // The policy that controls the repositories in the organization that are allowed to run GitHub Actions. Can be one of: `all`, `none`, or `selected`. + EnabledRepositories pulumi.StringOutput `pulumi:"enabledRepositories"` + // Sets the list of selected repositories that are enabled for GitHub Actions in an organization. Only available when `enabledRepositories` = `selected`. See Enabled Repositories Config below for details. + EnabledRepositoriesConfig ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput `pulumi:"enabledRepositoriesConfig"` + // Whether pinning to a specific SHA is required for all actions and reusable workflows in the organization. + ShaPinningRequired pulumi.BoolOutput `pulumi:"shaPinningRequired"` +} + +// NewActionsOrganizationPermissions registers a new resource with the given unique name, arguments, and options. +func NewActionsOrganizationPermissions(ctx *pulumi.Context, + name string, args *ActionsOrganizationPermissionsArgs, opts ...pulumi.ResourceOption) (*ActionsOrganizationPermissions, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.EnabledRepositories == nil { + return nil, errors.New("invalid value for required argument 'EnabledRepositories'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsOrganizationPermissions + err := ctx.RegisterResource("github:index/actionsOrganizationPermissions:ActionsOrganizationPermissions", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsOrganizationPermissions gets an existing ActionsOrganizationPermissions 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 GetActionsOrganizationPermissions(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsOrganizationPermissionsState, opts ...pulumi.ResourceOption) (*ActionsOrganizationPermissions, error) { + var resource ActionsOrganizationPermissions + err := ctx.ReadResource("github:index/actionsOrganizationPermissions:ActionsOrganizationPermissions", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsOrganizationPermissions resources. +type actionsOrganizationPermissionsState struct { + // The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. + AllowedActions *string `pulumi:"allowedActions"` + // Sets the actions that are allowed in an organization. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. + AllowedActionsConfig *ActionsOrganizationPermissionsAllowedActionsConfig `pulumi:"allowedActionsConfig"` + // The policy that controls the repositories in the organization that are allowed to run GitHub Actions. Can be one of: `all`, `none`, or `selected`. + EnabledRepositories *string `pulumi:"enabledRepositories"` + // Sets the list of selected repositories that are enabled for GitHub Actions in an organization. Only available when `enabledRepositories` = `selected`. See Enabled Repositories Config below for details. + EnabledRepositoriesConfig *ActionsOrganizationPermissionsEnabledRepositoriesConfig `pulumi:"enabledRepositoriesConfig"` + // Whether pinning to a specific SHA is required for all actions and reusable workflows in the organization. + ShaPinningRequired *bool `pulumi:"shaPinningRequired"` +} + +type ActionsOrganizationPermissionsState struct { + // The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. + AllowedActions pulumi.StringPtrInput + // Sets the actions that are allowed in an organization. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. + AllowedActionsConfig ActionsOrganizationPermissionsAllowedActionsConfigPtrInput + // The policy that controls the repositories in the organization that are allowed to run GitHub Actions. Can be one of: `all`, `none`, or `selected`. + EnabledRepositories pulumi.StringPtrInput + // Sets the list of selected repositories that are enabled for GitHub Actions in an organization. Only available when `enabledRepositories` = `selected`. See Enabled Repositories Config below for details. + EnabledRepositoriesConfig ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrInput + // Whether pinning to a specific SHA is required for all actions and reusable workflows in the organization. + ShaPinningRequired pulumi.BoolPtrInput +} + +func (ActionsOrganizationPermissionsState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationPermissionsState)(nil)).Elem() +} + +type actionsOrganizationPermissionsArgs struct { + // The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. + AllowedActions *string `pulumi:"allowedActions"` + // Sets the actions that are allowed in an organization. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. + AllowedActionsConfig *ActionsOrganizationPermissionsAllowedActionsConfig `pulumi:"allowedActionsConfig"` + // The policy that controls the repositories in the organization that are allowed to run GitHub Actions. Can be one of: `all`, `none`, or `selected`. + EnabledRepositories string `pulumi:"enabledRepositories"` + // Sets the list of selected repositories that are enabled for GitHub Actions in an organization. Only available when `enabledRepositories` = `selected`. See Enabled Repositories Config below for details. + EnabledRepositoriesConfig *ActionsOrganizationPermissionsEnabledRepositoriesConfig `pulumi:"enabledRepositoriesConfig"` + // Whether pinning to a specific SHA is required for all actions and reusable workflows in the organization. + ShaPinningRequired *bool `pulumi:"shaPinningRequired"` +} + +// The set of arguments for constructing a ActionsOrganizationPermissions resource. +type ActionsOrganizationPermissionsArgs struct { + // The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. + AllowedActions pulumi.StringPtrInput + // Sets the actions that are allowed in an organization. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. + AllowedActionsConfig ActionsOrganizationPermissionsAllowedActionsConfigPtrInput + // The policy that controls the repositories in the organization that are allowed to run GitHub Actions. Can be one of: `all`, `none`, or `selected`. + EnabledRepositories pulumi.StringInput + // Sets the list of selected repositories that are enabled for GitHub Actions in an organization. Only available when `enabledRepositories` = `selected`. See Enabled Repositories Config below for details. + EnabledRepositoriesConfig ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrInput + // Whether pinning to a specific SHA is required for all actions and reusable workflows in the organization. + ShaPinningRequired pulumi.BoolPtrInput +} + +func (ActionsOrganizationPermissionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationPermissionsArgs)(nil)).Elem() +} + +type ActionsOrganizationPermissionsInput interface { + pulumi.Input + + ToActionsOrganizationPermissionsOutput() ActionsOrganizationPermissionsOutput + ToActionsOrganizationPermissionsOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsOutput +} + +func (*ActionsOrganizationPermissions) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationPermissions)(nil)).Elem() +} + +func (i *ActionsOrganizationPermissions) ToActionsOrganizationPermissionsOutput() ActionsOrganizationPermissionsOutput { + return i.ToActionsOrganizationPermissionsOutputWithContext(context.Background()) +} + +func (i *ActionsOrganizationPermissions) ToActionsOrganizationPermissionsOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationPermissionsOutput) +} + +// ActionsOrganizationPermissionsArrayInput is an input type that accepts ActionsOrganizationPermissionsArray and ActionsOrganizationPermissionsArrayOutput values. +// You can construct a concrete instance of `ActionsOrganizationPermissionsArrayInput` via: +// +// ActionsOrganizationPermissionsArray{ ActionsOrganizationPermissionsArgs{...} } +type ActionsOrganizationPermissionsArrayInput interface { + pulumi.Input + + ToActionsOrganizationPermissionsArrayOutput() ActionsOrganizationPermissionsArrayOutput + ToActionsOrganizationPermissionsArrayOutputWithContext(context.Context) ActionsOrganizationPermissionsArrayOutput +} + +type ActionsOrganizationPermissionsArray []ActionsOrganizationPermissionsInput + +func (ActionsOrganizationPermissionsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationPermissions)(nil)).Elem() +} + +func (i ActionsOrganizationPermissionsArray) ToActionsOrganizationPermissionsArrayOutput() ActionsOrganizationPermissionsArrayOutput { + return i.ToActionsOrganizationPermissionsArrayOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationPermissionsArray) ToActionsOrganizationPermissionsArrayOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationPermissionsArrayOutput) +} + +// ActionsOrganizationPermissionsMapInput is an input type that accepts ActionsOrganizationPermissionsMap and ActionsOrganizationPermissionsMapOutput values. +// You can construct a concrete instance of `ActionsOrganizationPermissionsMapInput` via: +// +// ActionsOrganizationPermissionsMap{ "key": ActionsOrganizationPermissionsArgs{...} } +type ActionsOrganizationPermissionsMapInput interface { + pulumi.Input + + ToActionsOrganizationPermissionsMapOutput() ActionsOrganizationPermissionsMapOutput + ToActionsOrganizationPermissionsMapOutputWithContext(context.Context) ActionsOrganizationPermissionsMapOutput +} + +type ActionsOrganizationPermissionsMap map[string]ActionsOrganizationPermissionsInput + +func (ActionsOrganizationPermissionsMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationPermissions)(nil)).Elem() +} + +func (i ActionsOrganizationPermissionsMap) ToActionsOrganizationPermissionsMapOutput() ActionsOrganizationPermissionsMapOutput { + return i.ToActionsOrganizationPermissionsMapOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationPermissionsMap) ToActionsOrganizationPermissionsMapOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationPermissionsMapOutput) +} + +type ActionsOrganizationPermissionsOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationPermissionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationPermissions)(nil)).Elem() +} + +func (o ActionsOrganizationPermissionsOutput) ToActionsOrganizationPermissionsOutput() ActionsOrganizationPermissionsOutput { + return o +} + +func (o ActionsOrganizationPermissionsOutput) ToActionsOrganizationPermissionsOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsOutput { + return o +} + +// The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. +func (o ActionsOrganizationPermissionsOutput) AllowedActions() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsOrganizationPermissions) pulumi.StringPtrOutput { return v.AllowedActions }).(pulumi.StringPtrOutput) +} + +// Sets the actions that are allowed in an organization. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. +func (o ActionsOrganizationPermissionsOutput) AllowedActionsConfig() ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput { + return o.ApplyT(func(v *ActionsOrganizationPermissions) ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput { + return v.AllowedActionsConfig + }).(ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput) +} + +// The policy that controls the repositories in the organization that are allowed to run GitHub Actions. Can be one of: `all`, `none`, or `selected`. +func (o ActionsOrganizationPermissionsOutput) EnabledRepositories() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationPermissions) pulumi.StringOutput { return v.EnabledRepositories }).(pulumi.StringOutput) +} + +// Sets the list of selected repositories that are enabled for GitHub Actions in an organization. Only available when `enabledRepositories` = `selected`. See Enabled Repositories Config below for details. +func (o ActionsOrganizationPermissionsOutput) EnabledRepositoriesConfig() ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput { + return o.ApplyT(func(v *ActionsOrganizationPermissions) ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput { + return v.EnabledRepositoriesConfig + }).(ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput) +} + +// Whether pinning to a specific SHA is required for all actions and reusable workflows in the organization. +func (o ActionsOrganizationPermissionsOutput) ShaPinningRequired() pulumi.BoolOutput { + return o.ApplyT(func(v *ActionsOrganizationPermissions) pulumi.BoolOutput { return v.ShaPinningRequired }).(pulumi.BoolOutput) +} + +type ActionsOrganizationPermissionsArrayOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationPermissionsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationPermissions)(nil)).Elem() +} + +func (o ActionsOrganizationPermissionsArrayOutput) ToActionsOrganizationPermissionsArrayOutput() ActionsOrganizationPermissionsArrayOutput { + return o +} + +func (o ActionsOrganizationPermissionsArrayOutput) ToActionsOrganizationPermissionsArrayOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsArrayOutput { + return o +} + +func (o ActionsOrganizationPermissionsArrayOutput) Index(i pulumi.IntInput) ActionsOrganizationPermissionsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsOrganizationPermissions { + return vs[0].([]*ActionsOrganizationPermissions)[vs[1].(int)] + }).(ActionsOrganizationPermissionsOutput) +} + +type ActionsOrganizationPermissionsMapOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationPermissionsMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationPermissions)(nil)).Elem() +} + +func (o ActionsOrganizationPermissionsMapOutput) ToActionsOrganizationPermissionsMapOutput() ActionsOrganizationPermissionsMapOutput { + return o +} + +func (o ActionsOrganizationPermissionsMapOutput) ToActionsOrganizationPermissionsMapOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsMapOutput { + return o +} + +func (o ActionsOrganizationPermissionsMapOutput) MapIndex(k pulumi.StringInput) ActionsOrganizationPermissionsOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsOrganizationPermissions { + return vs[0].(map[string]*ActionsOrganizationPermissions)[vs[1].(string)] + }).(ActionsOrganizationPermissionsOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationPermissionsInput)(nil)).Elem(), &ActionsOrganizationPermissions{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationPermissionsArrayInput)(nil)).Elem(), ActionsOrganizationPermissionsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationPermissionsMapInput)(nil)).Elem(), ActionsOrganizationPermissionsMap{}) + pulumi.RegisterOutputType(ActionsOrganizationPermissionsOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationPermissionsArrayOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationPermissionsMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationSecret.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationSecret.go new file mode 100644 index 000000000..6cdaa1c80 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationSecret.go @@ -0,0 +1,590 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage GitHub Actions secrets within your GitHub organization. +// You must have write access to a repository to use this resource. +// +// Secret values are encrypted using the [Go '/crypto/box' module](https://godoc.org/golang.org/x/crypto/nacl/box) which is +// interoperable with [libsodium](https://libsodium.gitbook.io/doc/). Libsodium is used by GitHub to decrypt secret values. +// +// For the purposes of security, the contents of the `value` field have been marked as `sensitive` to Terraform, +// but it is important to note that **this does not hide it from state files**. You should treat state as sensitive always. +// It is also advised that you do not store plaintext values in your code but rather populate the `valueEncrypted` +// using fields from a resource, data source or variable as, while encrypted in state, these will be easily accessible +// in your code. See below for an example of this abstraction. +// +// ## Example Usage +// +// ```go +// 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.NewActionsOrganizationSecret(ctx, "example_plaintext", &github.ActionsOrganizationSecretArgs{ +// SecretName: pulumi.String("example_secret_name"), +// Visibility: pulumi.String("all"), +// Value: pulumi.Any(someSecretString), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewActionsOrganizationSecret(ctx, "example_encrypted", &github.ActionsOrganizationSecretArgs{ +// SecretName: pulumi.String("example_secret_name"), +// Visibility: pulumi.String("all"), +// ValueEncrypted: pulumi.Any(someEncryptedSecretString), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ```go +// 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 { +// repo, err := github.GetRepository(ctx, &github.LookupRepositoryArgs{ +// FullName: pulumi.StringRef("my-org/repo"), +// }, nil) +// if err != nil { +// return err +// } +// _, err = github.NewActionsOrganizationSecret(ctx, "example_encrypted", &github.ActionsOrganizationSecretArgs{ +// SecretName: pulumi.String("example_secret_name"), +// Visibility: pulumi.String("selected"), +// Value: pulumi.Any(someSecretString), +// SelectedRepositoryIds: pulumi.IntArray{ +// pulumi.Int(pulumi.Int(repo.RepoId)), +// }, +// }) +// if err != nil { +// return err +// } +// _, err = github.NewActionsOrganizationSecret(ctx, "example_secret", &github.ActionsOrganizationSecretArgs{ +// SecretName: pulumi.String("example_secret_name"), +// Visibility: pulumi.String("selected"), +// ValueEncrypted: pulumi.Any(someEncryptedSecretString), +// SelectedRepositoryIds: pulumi.IntArray{ +// pulumi.Int(pulumi.Int(repo.RepoId)), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Example Lifecycle Ignore Changes +// +// This resource supports using the `lifecycle` `ignoreChanges` block on `remoteUpdatedAt` to support use cases where a secret value is created using a placeholder value and then modified after creation outside the scope of Terraform. This approach ensures only the initial placeholder value is referenced in your code and in the resulting state file. +// +// ```go +// 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.NewActionsOrganizationSecret(ctx, "example_allow_drift", &github.ActionsOrganizationSecretArgs{ +// SecretName: pulumi.String("example_secret_name"), +// Visibility: pulumi.String("all"), +// Value: pulumi.String("placeholder"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using the secret name as the ID. +// +// > **Note**: When importing secrets, the `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` fields will not be populated in the state. You may need to ignore changes for these as a workaround if you're not planning on updating the secret through Terraform. +// +// ### Import Command +// +// The following command imports a GitHub actions organization secret named `mysecret` to a `ActionsOrganizationSecret` resource named `example`. +// +// ```sh +// $ pulumi import github:index/actionsOrganizationSecret:ActionsOrganizationSecret example mysecret +// ``` +type ActionsOrganizationSecret struct { + pulumi.CustomResourceState + + // Date the secret was created. + CreatedAt pulumi.StringOutput `pulumi:"createdAt"` + // (Optional) This is ignored as drift detection is built into the resource. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: This is no longer required and will be removed in a future release. Drift detection is now always performed, and external changes will result in the secret being updated to match the Terraform configuration. If you want to ignore external changes, you can use the `lifecycle` block with `ignoreChanges` on the `remoteUpdatedAt` field. + DestroyOnDrift pulumi.BoolPtrOutput `pulumi:"destroyOnDrift"` + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue pulumi.StringPtrOutput `pulumi:"encryptedValue"` + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId pulumi.StringOutput `pulumi:"keyId"` + // (Optional) Please use `value`. + // + // Deprecated: Use value. + PlaintextValue pulumi.StringPtrOutput `pulumi:"plaintextValue"` + // Date the secret was last updated in GitHub. + RemoteUpdatedAt pulumi.StringOutput `pulumi:"remoteUpdatedAt"` + // Name of the secret. + SecretName pulumi.StringOutput `pulumi:"secretName"` + // An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. + // + // Deprecated: This field is deprecated and will be removed in a future release. Please use the `ActionsOrganizationSecretRepositories` or `ActionsOrganizationSecretRepository` resources to manage repository access to organization secrets. + SelectedRepositoryIds pulumi.IntArrayOutput `pulumi:"selectedRepositoryIds"` + // Date the secret was last updated by the provider. + UpdatedAt pulumi.StringOutput `pulumi:"updatedAt"` + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value pulumi.StringPtrOutput `pulumi:"value"` + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted pulumi.StringPtrOutput `pulumi:"valueEncrypted"` + // Configures the access that repositories have to the organization secret; must be one of `all`, `private`, or `selected`. + Visibility pulumi.StringOutput `pulumi:"visibility"` +} + +// NewActionsOrganizationSecret registers a new resource with the given unique name, arguments, and options. +func NewActionsOrganizationSecret(ctx *pulumi.Context, + name string, args *ActionsOrganizationSecretArgs, opts ...pulumi.ResourceOption) (*ActionsOrganizationSecret, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.SecretName == nil { + return nil, errors.New("invalid value for required argument 'SecretName'") + } + if args.Visibility == nil { + return nil, errors.New("invalid value for required argument 'Visibility'") + } + if args.EncryptedValue != nil { + args.EncryptedValue = pulumi.ToSecret(args.EncryptedValue).(pulumi.StringPtrInput) + } + if args.PlaintextValue != nil { + args.PlaintextValue = pulumi.ToSecret(args.PlaintextValue).(pulumi.StringPtrInput) + } + if args.Value != nil { + args.Value = pulumi.ToSecret(args.Value).(pulumi.StringPtrInput) + } + if args.ValueEncrypted != nil { + args.ValueEncrypted = pulumi.ToSecret(args.ValueEncrypted).(pulumi.StringPtrInput) + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "encryptedValue", + "plaintextValue", + "value", + "valueEncrypted", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsOrganizationSecret + err := ctx.RegisterResource("github:index/actionsOrganizationSecret:ActionsOrganizationSecret", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsOrganizationSecret gets an existing ActionsOrganizationSecret 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 GetActionsOrganizationSecret(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsOrganizationSecretState, opts ...pulumi.ResourceOption) (*ActionsOrganizationSecret, error) { + var resource ActionsOrganizationSecret + err := ctx.ReadResource("github:index/actionsOrganizationSecret:ActionsOrganizationSecret", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsOrganizationSecret resources. +type actionsOrganizationSecretState struct { + // Date the secret was created. + CreatedAt *string `pulumi:"createdAt"` + // (Optional) This is ignored as drift detection is built into the resource. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: This is no longer required and will be removed in a future release. Drift detection is now always performed, and external changes will result in the secret being updated to match the Terraform configuration. If you want to ignore external changes, you can use the `lifecycle` block with `ignoreChanges` on the `remoteUpdatedAt` field. + DestroyOnDrift *bool `pulumi:"destroyOnDrift"` + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue *string `pulumi:"encryptedValue"` + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId *string `pulumi:"keyId"` + // (Optional) Please use `value`. + // + // Deprecated: Use value. + PlaintextValue *string `pulumi:"plaintextValue"` + // Date the secret was last updated in GitHub. + RemoteUpdatedAt *string `pulumi:"remoteUpdatedAt"` + // Name of the secret. + SecretName *string `pulumi:"secretName"` + // An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. + // + // Deprecated: This field is deprecated and will be removed in a future release. Please use the `ActionsOrganizationSecretRepositories` or `ActionsOrganizationSecretRepository` resources to manage repository access to organization secrets. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` + // Date the secret was last updated by the provider. + UpdatedAt *string `pulumi:"updatedAt"` + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value *string `pulumi:"value"` + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted *string `pulumi:"valueEncrypted"` + // Configures the access that repositories have to the organization secret; must be one of `all`, `private`, or `selected`. + Visibility *string `pulumi:"visibility"` +} + +type ActionsOrganizationSecretState struct { + // Date the secret was created. + CreatedAt pulumi.StringPtrInput + // (Optional) This is ignored as drift detection is built into the resource. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: This is no longer required and will be removed in a future release. Drift detection is now always performed, and external changes will result in the secret being updated to match the Terraform configuration. If you want to ignore external changes, you can use the `lifecycle` block with `ignoreChanges` on the `remoteUpdatedAt` field. + DestroyOnDrift pulumi.BoolPtrInput + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue pulumi.StringPtrInput + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId pulumi.StringPtrInput + // (Optional) Please use `value`. + // + // Deprecated: Use value. + PlaintextValue pulumi.StringPtrInput + // Date the secret was last updated in GitHub. + RemoteUpdatedAt pulumi.StringPtrInput + // Name of the secret. + SecretName pulumi.StringPtrInput + // An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. + // + // Deprecated: This field is deprecated and will be removed in a future release. Please use the `ActionsOrganizationSecretRepositories` or `ActionsOrganizationSecretRepository` resources to manage repository access to organization secrets. + SelectedRepositoryIds pulumi.IntArrayInput + // Date the secret was last updated by the provider. + UpdatedAt pulumi.StringPtrInput + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value pulumi.StringPtrInput + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted pulumi.StringPtrInput + // Configures the access that repositories have to the organization secret; must be one of `all`, `private`, or `selected`. + Visibility pulumi.StringPtrInput +} + +func (ActionsOrganizationSecretState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationSecretState)(nil)).Elem() +} + +type actionsOrganizationSecretArgs struct { + // (Optional) This is ignored as drift detection is built into the resource. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: This is no longer required and will be removed in a future release. Drift detection is now always performed, and external changes will result in the secret being updated to match the Terraform configuration. If you want to ignore external changes, you can use the `lifecycle` block with `ignoreChanges` on the `remoteUpdatedAt` field. + DestroyOnDrift *bool `pulumi:"destroyOnDrift"` + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue *string `pulumi:"encryptedValue"` + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId *string `pulumi:"keyId"` + // (Optional) Please use `value`. + // + // Deprecated: Use value. + PlaintextValue *string `pulumi:"plaintextValue"` + // Name of the secret. + SecretName string `pulumi:"secretName"` + // An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. + // + // Deprecated: This field is deprecated and will be removed in a future release. Please use the `ActionsOrganizationSecretRepositories` or `ActionsOrganizationSecretRepository` resources to manage repository access to organization secrets. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value *string `pulumi:"value"` + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted *string `pulumi:"valueEncrypted"` + // Configures the access that repositories have to the organization secret; must be one of `all`, `private`, or `selected`. + Visibility string `pulumi:"visibility"` +} + +// The set of arguments for constructing a ActionsOrganizationSecret resource. +type ActionsOrganizationSecretArgs struct { + // (Optional) This is ignored as drift detection is built into the resource. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: This is no longer required and will be removed in a future release. Drift detection is now always performed, and external changes will result in the secret being updated to match the Terraform configuration. If you want to ignore external changes, you can use the `lifecycle` block with `ignoreChanges` on the `remoteUpdatedAt` field. + DestroyOnDrift pulumi.BoolPtrInput + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue pulumi.StringPtrInput + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId pulumi.StringPtrInput + // (Optional) Please use `value`. + // + // Deprecated: Use value. + PlaintextValue pulumi.StringPtrInput + // Name of the secret. + SecretName pulumi.StringInput + // An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. + // + // Deprecated: This field is deprecated and will be removed in a future release. Please use the `ActionsOrganizationSecretRepositories` or `ActionsOrganizationSecretRepository` resources to manage repository access to organization secrets. + SelectedRepositoryIds pulumi.IntArrayInput + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value pulumi.StringPtrInput + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted pulumi.StringPtrInput + // Configures the access that repositories have to the organization secret; must be one of `all`, `private`, or `selected`. + Visibility pulumi.StringInput +} + +func (ActionsOrganizationSecretArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationSecretArgs)(nil)).Elem() +} + +type ActionsOrganizationSecretInput interface { + pulumi.Input + + ToActionsOrganizationSecretOutput() ActionsOrganizationSecretOutput + ToActionsOrganizationSecretOutputWithContext(ctx context.Context) ActionsOrganizationSecretOutput +} + +func (*ActionsOrganizationSecret) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationSecret)(nil)).Elem() +} + +func (i *ActionsOrganizationSecret) ToActionsOrganizationSecretOutput() ActionsOrganizationSecretOutput { + return i.ToActionsOrganizationSecretOutputWithContext(context.Background()) +} + +func (i *ActionsOrganizationSecret) ToActionsOrganizationSecretOutputWithContext(ctx context.Context) ActionsOrganizationSecretOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationSecretOutput) +} + +// ActionsOrganizationSecretArrayInput is an input type that accepts ActionsOrganizationSecretArray and ActionsOrganizationSecretArrayOutput values. +// You can construct a concrete instance of `ActionsOrganizationSecretArrayInput` via: +// +// ActionsOrganizationSecretArray{ ActionsOrganizationSecretArgs{...} } +type ActionsOrganizationSecretArrayInput interface { + pulumi.Input + + ToActionsOrganizationSecretArrayOutput() ActionsOrganizationSecretArrayOutput + ToActionsOrganizationSecretArrayOutputWithContext(context.Context) ActionsOrganizationSecretArrayOutput +} + +type ActionsOrganizationSecretArray []ActionsOrganizationSecretInput + +func (ActionsOrganizationSecretArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationSecret)(nil)).Elem() +} + +func (i ActionsOrganizationSecretArray) ToActionsOrganizationSecretArrayOutput() ActionsOrganizationSecretArrayOutput { + return i.ToActionsOrganizationSecretArrayOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationSecretArray) ToActionsOrganizationSecretArrayOutputWithContext(ctx context.Context) ActionsOrganizationSecretArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationSecretArrayOutput) +} + +// ActionsOrganizationSecretMapInput is an input type that accepts ActionsOrganizationSecretMap and ActionsOrganizationSecretMapOutput values. +// You can construct a concrete instance of `ActionsOrganizationSecretMapInput` via: +// +// ActionsOrganizationSecretMap{ "key": ActionsOrganizationSecretArgs{...} } +type ActionsOrganizationSecretMapInput interface { + pulumi.Input + + ToActionsOrganizationSecretMapOutput() ActionsOrganizationSecretMapOutput + ToActionsOrganizationSecretMapOutputWithContext(context.Context) ActionsOrganizationSecretMapOutput +} + +type ActionsOrganizationSecretMap map[string]ActionsOrganizationSecretInput + +func (ActionsOrganizationSecretMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationSecret)(nil)).Elem() +} + +func (i ActionsOrganizationSecretMap) ToActionsOrganizationSecretMapOutput() ActionsOrganizationSecretMapOutput { + return i.ToActionsOrganizationSecretMapOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationSecretMap) ToActionsOrganizationSecretMapOutputWithContext(ctx context.Context) ActionsOrganizationSecretMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationSecretMapOutput) +} + +type ActionsOrganizationSecretOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationSecretOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationSecret)(nil)).Elem() +} + +func (o ActionsOrganizationSecretOutput) ToActionsOrganizationSecretOutput() ActionsOrganizationSecretOutput { + return o +} + +func (o ActionsOrganizationSecretOutput) ToActionsOrganizationSecretOutputWithContext(ctx context.Context) ActionsOrganizationSecretOutput { + return o +} + +// Date the secret was created. +func (o ActionsOrganizationSecretOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationSecret) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) +} + +// (Optional) This is ignored as drift detection is built into the resource. +// +// > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. +// +// Deprecated: This is no longer required and will be removed in a future release. Drift detection is now always performed, and external changes will result in the secret being updated to match the Terraform configuration. If you want to ignore external changes, you can use the `lifecycle` block with `ignoreChanges` on the `remoteUpdatedAt` field. +func (o ActionsOrganizationSecretOutput) DestroyOnDrift() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ActionsOrganizationSecret) pulumi.BoolPtrOutput { return v.DestroyOnDrift }).(pulumi.BoolPtrOutput) +} + +// (Optional) Please use `valueEncrypted`. +// +// Deprecated: Use valueEncrypted and key_id. +func (o ActionsOrganizationSecretOutput) EncryptedValue() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsOrganizationSecret) pulumi.StringPtrOutput { return v.EncryptedValue }).(pulumi.StringPtrOutput) +} + +// ID of the public key used to encrypt the secret, required when setting `encryptedValue`. +func (o ActionsOrganizationSecretOutput) KeyId() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationSecret) pulumi.StringOutput { return v.KeyId }).(pulumi.StringOutput) +} + +// (Optional) Please use `value`. +// +// Deprecated: Use value. +func (o ActionsOrganizationSecretOutput) PlaintextValue() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsOrganizationSecret) pulumi.StringPtrOutput { return v.PlaintextValue }).(pulumi.StringPtrOutput) +} + +// Date the secret was last updated in GitHub. +func (o ActionsOrganizationSecretOutput) RemoteUpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationSecret) pulumi.StringOutput { return v.RemoteUpdatedAt }).(pulumi.StringOutput) +} + +// Name of the secret. +func (o ActionsOrganizationSecretOutput) SecretName() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationSecret) pulumi.StringOutput { return v.SecretName }).(pulumi.StringOutput) +} + +// An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. +// +// Deprecated: This field is deprecated and will be removed in a future release. Please use the `ActionsOrganizationSecretRepositories` or `ActionsOrganizationSecretRepository` resources to manage repository access to organization secrets. +func (o ActionsOrganizationSecretOutput) SelectedRepositoryIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v *ActionsOrganizationSecret) pulumi.IntArrayOutput { return v.SelectedRepositoryIds }).(pulumi.IntArrayOutput) +} + +// Date the secret was last updated by the provider. +func (o ActionsOrganizationSecretOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationSecret) pulumi.StringOutput { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. +func (o ActionsOrganizationSecretOutput) Value() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsOrganizationSecret) pulumi.StringPtrOutput { return v.Value }).(pulumi.StringPtrOutput) +} + +// Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. +func (o ActionsOrganizationSecretOutput) ValueEncrypted() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsOrganizationSecret) pulumi.StringPtrOutput { return v.ValueEncrypted }).(pulumi.StringPtrOutput) +} + +// Configures the access that repositories have to the organization secret; must be one of `all`, `private`, or `selected`. +func (o ActionsOrganizationSecretOutput) Visibility() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationSecret) pulumi.StringOutput { return v.Visibility }).(pulumi.StringOutput) +} + +type ActionsOrganizationSecretArrayOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationSecretArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationSecret)(nil)).Elem() +} + +func (o ActionsOrganizationSecretArrayOutput) ToActionsOrganizationSecretArrayOutput() ActionsOrganizationSecretArrayOutput { + return o +} + +func (o ActionsOrganizationSecretArrayOutput) ToActionsOrganizationSecretArrayOutputWithContext(ctx context.Context) ActionsOrganizationSecretArrayOutput { + return o +} + +func (o ActionsOrganizationSecretArrayOutput) Index(i pulumi.IntInput) ActionsOrganizationSecretOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsOrganizationSecret { + return vs[0].([]*ActionsOrganizationSecret)[vs[1].(int)] + }).(ActionsOrganizationSecretOutput) +} + +type ActionsOrganizationSecretMapOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationSecretMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationSecret)(nil)).Elem() +} + +func (o ActionsOrganizationSecretMapOutput) ToActionsOrganizationSecretMapOutput() ActionsOrganizationSecretMapOutput { + return o +} + +func (o ActionsOrganizationSecretMapOutput) ToActionsOrganizationSecretMapOutputWithContext(ctx context.Context) ActionsOrganizationSecretMapOutput { + return o +} + +func (o ActionsOrganizationSecretMapOutput) MapIndex(k pulumi.StringInput) ActionsOrganizationSecretOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsOrganizationSecret { + return vs[0].(map[string]*ActionsOrganizationSecret)[vs[1].(string)] + }).(ActionsOrganizationSecretOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationSecretInput)(nil)).Elem(), &ActionsOrganizationSecret{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationSecretArrayInput)(nil)).Elem(), ActionsOrganizationSecretArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationSecretMapInput)(nil)).Elem(), ActionsOrganizationSecretMap{}) + pulumi.RegisterOutputType(ActionsOrganizationSecretOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationSecretArrayOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationSecretMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationSecretRepositories.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationSecretRepositories.go new file mode 100644 index 000000000..8478708e1 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationSecretRepositories.go @@ -0,0 +1,296 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to manage the repositories allowed to access an actions secret within your GitHub organization. +// You must have write access to an organization secret to use this resource. +// +// This resource is only applicable when `visibility` of the existing organization secret has been set to `selected`. +// +// ## Example Usage +// +// ```go +// 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"), +// Value: 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 +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using the secret name as the ID. +// +// ### Import Command +// +// The following command imports the repositories able to access the actions organization secret named `mysecret` to a `ActionsOrganizationSecretRepositories` resource named `example`. +// +// ```sh +// $ pulumi import github:index/actionsOrganizationSecretRepositories:ActionsOrganizationSecretRepositories example mysecret +// ``` +type ActionsOrganizationSecretRepositories struct { + pulumi.CustomResourceState + + // Name of the actions organization secret. + SecretName pulumi.StringOutput `pulumi:"secretName"` + // List of IDs for the repositories that should be able to access the secret. + SelectedRepositoryIds pulumi.IntArrayOutput `pulumi:"selectedRepositoryIds"` +} + +// NewActionsOrganizationSecretRepositories registers a new resource with the given unique name, arguments, and options. +func NewActionsOrganizationSecretRepositories(ctx *pulumi.Context, + name string, args *ActionsOrganizationSecretRepositoriesArgs, opts ...pulumi.ResourceOption) (*ActionsOrganizationSecretRepositories, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.SecretName == nil { + return nil, errors.New("invalid value for required argument 'SecretName'") + } + if args.SelectedRepositoryIds == nil { + return nil, errors.New("invalid value for required argument 'SelectedRepositoryIds'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsOrganizationSecretRepositories + err := ctx.RegisterResource("github:index/actionsOrganizationSecretRepositories:ActionsOrganizationSecretRepositories", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsOrganizationSecretRepositories gets an existing ActionsOrganizationSecretRepositories 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 GetActionsOrganizationSecretRepositories(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsOrganizationSecretRepositoriesState, opts ...pulumi.ResourceOption) (*ActionsOrganizationSecretRepositories, error) { + var resource ActionsOrganizationSecretRepositories + err := ctx.ReadResource("github:index/actionsOrganizationSecretRepositories:ActionsOrganizationSecretRepositories", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsOrganizationSecretRepositories resources. +type actionsOrganizationSecretRepositoriesState struct { + // Name of the actions organization secret. + SecretName *string `pulumi:"secretName"` + // List of IDs for the repositories that should be able to access the secret. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` +} + +type ActionsOrganizationSecretRepositoriesState struct { + // Name of the actions organization secret. + SecretName pulumi.StringPtrInput + // List of IDs for the repositories that should be able to access the secret. + SelectedRepositoryIds pulumi.IntArrayInput +} + +func (ActionsOrganizationSecretRepositoriesState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationSecretRepositoriesState)(nil)).Elem() +} + +type actionsOrganizationSecretRepositoriesArgs struct { + // Name of the actions organization secret. + SecretName string `pulumi:"secretName"` + // List of IDs for the repositories that should be able to access the secret. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` +} + +// The set of arguments for constructing a ActionsOrganizationSecretRepositories resource. +type ActionsOrganizationSecretRepositoriesArgs struct { + // Name of the actions organization secret. + SecretName pulumi.StringInput + // List of IDs for the repositories that should be able to access the secret. + SelectedRepositoryIds pulumi.IntArrayInput +} + +func (ActionsOrganizationSecretRepositoriesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationSecretRepositoriesArgs)(nil)).Elem() +} + +type ActionsOrganizationSecretRepositoriesInput interface { + pulumi.Input + + ToActionsOrganizationSecretRepositoriesOutput() ActionsOrganizationSecretRepositoriesOutput + ToActionsOrganizationSecretRepositoriesOutputWithContext(ctx context.Context) ActionsOrganizationSecretRepositoriesOutput +} + +func (*ActionsOrganizationSecretRepositories) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationSecretRepositories)(nil)).Elem() +} + +func (i *ActionsOrganizationSecretRepositories) ToActionsOrganizationSecretRepositoriesOutput() ActionsOrganizationSecretRepositoriesOutput { + return i.ToActionsOrganizationSecretRepositoriesOutputWithContext(context.Background()) +} + +func (i *ActionsOrganizationSecretRepositories) ToActionsOrganizationSecretRepositoriesOutputWithContext(ctx context.Context) ActionsOrganizationSecretRepositoriesOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationSecretRepositoriesOutput) +} + +// ActionsOrganizationSecretRepositoriesArrayInput is an input type that accepts ActionsOrganizationSecretRepositoriesArray and ActionsOrganizationSecretRepositoriesArrayOutput values. +// You can construct a concrete instance of `ActionsOrganizationSecretRepositoriesArrayInput` via: +// +// ActionsOrganizationSecretRepositoriesArray{ ActionsOrganizationSecretRepositoriesArgs{...} } +type ActionsOrganizationSecretRepositoriesArrayInput interface { + pulumi.Input + + ToActionsOrganizationSecretRepositoriesArrayOutput() ActionsOrganizationSecretRepositoriesArrayOutput + ToActionsOrganizationSecretRepositoriesArrayOutputWithContext(context.Context) ActionsOrganizationSecretRepositoriesArrayOutput +} + +type ActionsOrganizationSecretRepositoriesArray []ActionsOrganizationSecretRepositoriesInput + +func (ActionsOrganizationSecretRepositoriesArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationSecretRepositories)(nil)).Elem() +} + +func (i ActionsOrganizationSecretRepositoriesArray) ToActionsOrganizationSecretRepositoriesArrayOutput() ActionsOrganizationSecretRepositoriesArrayOutput { + return i.ToActionsOrganizationSecretRepositoriesArrayOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationSecretRepositoriesArray) ToActionsOrganizationSecretRepositoriesArrayOutputWithContext(ctx context.Context) ActionsOrganizationSecretRepositoriesArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationSecretRepositoriesArrayOutput) +} + +// ActionsOrganizationSecretRepositoriesMapInput is an input type that accepts ActionsOrganizationSecretRepositoriesMap and ActionsOrganizationSecretRepositoriesMapOutput values. +// You can construct a concrete instance of `ActionsOrganizationSecretRepositoriesMapInput` via: +// +// ActionsOrganizationSecretRepositoriesMap{ "key": ActionsOrganizationSecretRepositoriesArgs{...} } +type ActionsOrganizationSecretRepositoriesMapInput interface { + pulumi.Input + + ToActionsOrganizationSecretRepositoriesMapOutput() ActionsOrganizationSecretRepositoriesMapOutput + ToActionsOrganizationSecretRepositoriesMapOutputWithContext(context.Context) ActionsOrganizationSecretRepositoriesMapOutput +} + +type ActionsOrganizationSecretRepositoriesMap map[string]ActionsOrganizationSecretRepositoriesInput + +func (ActionsOrganizationSecretRepositoriesMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationSecretRepositories)(nil)).Elem() +} + +func (i ActionsOrganizationSecretRepositoriesMap) ToActionsOrganizationSecretRepositoriesMapOutput() ActionsOrganizationSecretRepositoriesMapOutput { + return i.ToActionsOrganizationSecretRepositoriesMapOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationSecretRepositoriesMap) ToActionsOrganizationSecretRepositoriesMapOutputWithContext(ctx context.Context) ActionsOrganizationSecretRepositoriesMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationSecretRepositoriesMapOutput) +} + +type ActionsOrganizationSecretRepositoriesOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationSecretRepositoriesOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationSecretRepositories)(nil)).Elem() +} + +func (o ActionsOrganizationSecretRepositoriesOutput) ToActionsOrganizationSecretRepositoriesOutput() ActionsOrganizationSecretRepositoriesOutput { + return o +} + +func (o ActionsOrganizationSecretRepositoriesOutput) ToActionsOrganizationSecretRepositoriesOutputWithContext(ctx context.Context) ActionsOrganizationSecretRepositoriesOutput { + return o +} + +// Name of the actions organization secret. +func (o ActionsOrganizationSecretRepositoriesOutput) SecretName() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationSecretRepositories) pulumi.StringOutput { return v.SecretName }).(pulumi.StringOutput) +} + +// List of IDs for the repositories that should be able to access the secret. +func (o ActionsOrganizationSecretRepositoriesOutput) SelectedRepositoryIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v *ActionsOrganizationSecretRepositories) pulumi.IntArrayOutput { return v.SelectedRepositoryIds }).(pulumi.IntArrayOutput) +} + +type ActionsOrganizationSecretRepositoriesArrayOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationSecretRepositoriesArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationSecretRepositories)(nil)).Elem() +} + +func (o ActionsOrganizationSecretRepositoriesArrayOutput) ToActionsOrganizationSecretRepositoriesArrayOutput() ActionsOrganizationSecretRepositoriesArrayOutput { + return o +} + +func (o ActionsOrganizationSecretRepositoriesArrayOutput) ToActionsOrganizationSecretRepositoriesArrayOutputWithContext(ctx context.Context) ActionsOrganizationSecretRepositoriesArrayOutput { + return o +} + +func (o ActionsOrganizationSecretRepositoriesArrayOutput) Index(i pulumi.IntInput) ActionsOrganizationSecretRepositoriesOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsOrganizationSecretRepositories { + return vs[0].([]*ActionsOrganizationSecretRepositories)[vs[1].(int)] + }).(ActionsOrganizationSecretRepositoriesOutput) +} + +type ActionsOrganizationSecretRepositoriesMapOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationSecretRepositoriesMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationSecretRepositories)(nil)).Elem() +} + +func (o ActionsOrganizationSecretRepositoriesMapOutput) ToActionsOrganizationSecretRepositoriesMapOutput() ActionsOrganizationSecretRepositoriesMapOutput { + return o +} + +func (o ActionsOrganizationSecretRepositoriesMapOutput) ToActionsOrganizationSecretRepositoriesMapOutputWithContext(ctx context.Context) ActionsOrganizationSecretRepositoriesMapOutput { + return o +} + +func (o ActionsOrganizationSecretRepositoriesMapOutput) MapIndex(k pulumi.StringInput) ActionsOrganizationSecretRepositoriesOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsOrganizationSecretRepositories { + return vs[0].(map[string]*ActionsOrganizationSecretRepositories)[vs[1].(string)] + }).(ActionsOrganizationSecretRepositoriesOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationSecretRepositoriesInput)(nil)).Elem(), &ActionsOrganizationSecretRepositories{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationSecretRepositoriesArrayInput)(nil)).Elem(), ActionsOrganizationSecretRepositoriesArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationSecretRepositoriesMapInput)(nil)).Elem(), ActionsOrganizationSecretRepositoriesMap{}) + pulumi.RegisterOutputType(ActionsOrganizationSecretRepositoriesOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationSecretRepositoriesArrayOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationSecretRepositoriesMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationSecretRepository.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationSecretRepository.go new file mode 100644 index 000000000..3e1730c8a --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationSecretRepository.go @@ -0,0 +1,294 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource adds permission for a repository to use an actions secret within your GitHub organization. +// You must have write access to an organization secret to use this resource. +// +// This resource is only applicable when `visibility` of the existing organization secret has been set to `selected`. +// +// ## Example Usage +// +// ```go +// 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"), +// Value: 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.NewActionsOrganizationSecretRepository(ctx, "example", &github.ActionsOrganizationSecretRepositoryArgs{ +// SecretName: example.Name, +// RepositoryId: exampleRepository.RepoId, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using an ID made of the secret name and repository name separated by a `:`. +// +// ### Import Command +// +// The following command imports the access of repository ID `123456` for the actions organization secret named `mysecret` to a `ActionsOrganizationSecretRepository` resource named `example`. +// +// ```sh +// $ pulumi import github:index/actionsOrganizationSecretRepository:ActionsOrganizationSecretRepository example mysecret:123456 +// ``` +type ActionsOrganizationSecretRepository struct { + pulumi.CustomResourceState + + // ID of the repository that should be able to access the secret. + RepositoryId pulumi.IntOutput `pulumi:"repositoryId"` + // Name of the actions organization secret. + SecretName pulumi.StringOutput `pulumi:"secretName"` +} + +// NewActionsOrganizationSecretRepository registers a new resource with the given unique name, arguments, and options. +func NewActionsOrganizationSecretRepository(ctx *pulumi.Context, + name string, args *ActionsOrganizationSecretRepositoryArgs, opts ...pulumi.ResourceOption) (*ActionsOrganizationSecretRepository, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.RepositoryId == nil { + return nil, errors.New("invalid value for required argument 'RepositoryId'") + } + if args.SecretName == nil { + return nil, errors.New("invalid value for required argument 'SecretName'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsOrganizationSecretRepository + err := ctx.RegisterResource("github:index/actionsOrganizationSecretRepository:ActionsOrganizationSecretRepository", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsOrganizationSecretRepository gets an existing ActionsOrganizationSecretRepository 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 GetActionsOrganizationSecretRepository(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsOrganizationSecretRepositoryState, opts ...pulumi.ResourceOption) (*ActionsOrganizationSecretRepository, error) { + var resource ActionsOrganizationSecretRepository + err := ctx.ReadResource("github:index/actionsOrganizationSecretRepository:ActionsOrganizationSecretRepository", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsOrganizationSecretRepository resources. +type actionsOrganizationSecretRepositoryState struct { + // ID of the repository that should be able to access the secret. + RepositoryId *int `pulumi:"repositoryId"` + // Name of the actions organization secret. + SecretName *string `pulumi:"secretName"` +} + +type ActionsOrganizationSecretRepositoryState struct { + // ID of the repository that should be able to access the secret. + RepositoryId pulumi.IntPtrInput + // Name of the actions organization secret. + SecretName pulumi.StringPtrInput +} + +func (ActionsOrganizationSecretRepositoryState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationSecretRepositoryState)(nil)).Elem() +} + +type actionsOrganizationSecretRepositoryArgs struct { + // ID of the repository that should be able to access the secret. + RepositoryId int `pulumi:"repositoryId"` + // Name of the actions organization secret. + SecretName string `pulumi:"secretName"` +} + +// The set of arguments for constructing a ActionsOrganizationSecretRepository resource. +type ActionsOrganizationSecretRepositoryArgs struct { + // ID of the repository that should be able to access the secret. + RepositoryId pulumi.IntInput + // Name of the actions organization secret. + SecretName pulumi.StringInput +} + +func (ActionsOrganizationSecretRepositoryArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationSecretRepositoryArgs)(nil)).Elem() +} + +type ActionsOrganizationSecretRepositoryInput interface { + pulumi.Input + + ToActionsOrganizationSecretRepositoryOutput() ActionsOrganizationSecretRepositoryOutput + ToActionsOrganizationSecretRepositoryOutputWithContext(ctx context.Context) ActionsOrganizationSecretRepositoryOutput +} + +func (*ActionsOrganizationSecretRepository) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationSecretRepository)(nil)).Elem() +} + +func (i *ActionsOrganizationSecretRepository) ToActionsOrganizationSecretRepositoryOutput() ActionsOrganizationSecretRepositoryOutput { + return i.ToActionsOrganizationSecretRepositoryOutputWithContext(context.Background()) +} + +func (i *ActionsOrganizationSecretRepository) ToActionsOrganizationSecretRepositoryOutputWithContext(ctx context.Context) ActionsOrganizationSecretRepositoryOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationSecretRepositoryOutput) +} + +// ActionsOrganizationSecretRepositoryArrayInput is an input type that accepts ActionsOrganizationSecretRepositoryArray and ActionsOrganizationSecretRepositoryArrayOutput values. +// You can construct a concrete instance of `ActionsOrganizationSecretRepositoryArrayInput` via: +// +// ActionsOrganizationSecretRepositoryArray{ ActionsOrganizationSecretRepositoryArgs{...} } +type ActionsOrganizationSecretRepositoryArrayInput interface { + pulumi.Input + + ToActionsOrganizationSecretRepositoryArrayOutput() ActionsOrganizationSecretRepositoryArrayOutput + ToActionsOrganizationSecretRepositoryArrayOutputWithContext(context.Context) ActionsOrganizationSecretRepositoryArrayOutput +} + +type ActionsOrganizationSecretRepositoryArray []ActionsOrganizationSecretRepositoryInput + +func (ActionsOrganizationSecretRepositoryArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationSecretRepository)(nil)).Elem() +} + +func (i ActionsOrganizationSecretRepositoryArray) ToActionsOrganizationSecretRepositoryArrayOutput() ActionsOrganizationSecretRepositoryArrayOutput { + return i.ToActionsOrganizationSecretRepositoryArrayOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationSecretRepositoryArray) ToActionsOrganizationSecretRepositoryArrayOutputWithContext(ctx context.Context) ActionsOrganizationSecretRepositoryArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationSecretRepositoryArrayOutput) +} + +// ActionsOrganizationSecretRepositoryMapInput is an input type that accepts ActionsOrganizationSecretRepositoryMap and ActionsOrganizationSecretRepositoryMapOutput values. +// You can construct a concrete instance of `ActionsOrganizationSecretRepositoryMapInput` via: +// +// ActionsOrganizationSecretRepositoryMap{ "key": ActionsOrganizationSecretRepositoryArgs{...} } +type ActionsOrganizationSecretRepositoryMapInput interface { + pulumi.Input + + ToActionsOrganizationSecretRepositoryMapOutput() ActionsOrganizationSecretRepositoryMapOutput + ToActionsOrganizationSecretRepositoryMapOutputWithContext(context.Context) ActionsOrganizationSecretRepositoryMapOutput +} + +type ActionsOrganizationSecretRepositoryMap map[string]ActionsOrganizationSecretRepositoryInput + +func (ActionsOrganizationSecretRepositoryMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationSecretRepository)(nil)).Elem() +} + +func (i ActionsOrganizationSecretRepositoryMap) ToActionsOrganizationSecretRepositoryMapOutput() ActionsOrganizationSecretRepositoryMapOutput { + return i.ToActionsOrganizationSecretRepositoryMapOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationSecretRepositoryMap) ToActionsOrganizationSecretRepositoryMapOutputWithContext(ctx context.Context) ActionsOrganizationSecretRepositoryMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationSecretRepositoryMapOutput) +} + +type ActionsOrganizationSecretRepositoryOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationSecretRepositoryOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationSecretRepository)(nil)).Elem() +} + +func (o ActionsOrganizationSecretRepositoryOutput) ToActionsOrganizationSecretRepositoryOutput() ActionsOrganizationSecretRepositoryOutput { + return o +} + +func (o ActionsOrganizationSecretRepositoryOutput) ToActionsOrganizationSecretRepositoryOutputWithContext(ctx context.Context) ActionsOrganizationSecretRepositoryOutput { + return o +} + +// ID of the repository that should be able to access the secret. +func (o ActionsOrganizationSecretRepositoryOutput) RepositoryId() pulumi.IntOutput { + return o.ApplyT(func(v *ActionsOrganizationSecretRepository) pulumi.IntOutput { return v.RepositoryId }).(pulumi.IntOutput) +} + +// Name of the actions organization secret. +func (o ActionsOrganizationSecretRepositoryOutput) SecretName() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationSecretRepository) pulumi.StringOutput { return v.SecretName }).(pulumi.StringOutput) +} + +type ActionsOrganizationSecretRepositoryArrayOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationSecretRepositoryArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationSecretRepository)(nil)).Elem() +} + +func (o ActionsOrganizationSecretRepositoryArrayOutput) ToActionsOrganizationSecretRepositoryArrayOutput() ActionsOrganizationSecretRepositoryArrayOutput { + return o +} + +func (o ActionsOrganizationSecretRepositoryArrayOutput) ToActionsOrganizationSecretRepositoryArrayOutputWithContext(ctx context.Context) ActionsOrganizationSecretRepositoryArrayOutput { + return o +} + +func (o ActionsOrganizationSecretRepositoryArrayOutput) Index(i pulumi.IntInput) ActionsOrganizationSecretRepositoryOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsOrganizationSecretRepository { + return vs[0].([]*ActionsOrganizationSecretRepository)[vs[1].(int)] + }).(ActionsOrganizationSecretRepositoryOutput) +} + +type ActionsOrganizationSecretRepositoryMapOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationSecretRepositoryMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationSecretRepository)(nil)).Elem() +} + +func (o ActionsOrganizationSecretRepositoryMapOutput) ToActionsOrganizationSecretRepositoryMapOutput() ActionsOrganizationSecretRepositoryMapOutput { + return o +} + +func (o ActionsOrganizationSecretRepositoryMapOutput) ToActionsOrganizationSecretRepositoryMapOutputWithContext(ctx context.Context) ActionsOrganizationSecretRepositoryMapOutput { + return o +} + +func (o ActionsOrganizationSecretRepositoryMapOutput) MapIndex(k pulumi.StringInput) ActionsOrganizationSecretRepositoryOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsOrganizationSecretRepository { + return vs[0].(map[string]*ActionsOrganizationSecretRepository)[vs[1].(string)] + }).(ActionsOrganizationSecretRepositoryOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationSecretRepositoryInput)(nil)).Elem(), &ActionsOrganizationSecretRepository{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationSecretRepositoryArrayInput)(nil)).Elem(), ActionsOrganizationSecretRepositoryArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationSecretRepositoryMapInput)(nil)).Elem(), ActionsOrganizationSecretRepositoryMap{}) + pulumi.RegisterOutputType(ActionsOrganizationSecretRepositoryOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationSecretRepositoryArrayOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationSecretRepositoryMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationVariable.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationVariable.go new file mode 100644 index 000000000..a8934cff1 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationVariable.go @@ -0,0 +1,368 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage GitHub Actions variables within your GitHub organization. +// You must have write access to a repository to use this resource. +// +// ## Example Usage +// +// ```go +// 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.NewActionsOrganizationVariable(ctx, "example_variable", &github.ActionsOrganizationVariableArgs{ +// VariableName: pulumi.String("example_variable_name"), +// Visibility: pulumi.String("private"), +// Value: pulumi.String("example_variable_value"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ```go +// 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 { +// repo, err := github.GetRepository(ctx, &github.LookupRepositoryArgs{ +// FullName: pulumi.StringRef("my-org/repo"), +// }, nil) +// if err != nil { +// return err +// } +// _, err = github.NewActionsOrganizationVariable(ctx, "example_variable", &github.ActionsOrganizationVariableArgs{ +// VariableName: pulumi.String("example_variable_name"), +// Visibility: pulumi.String("selected"), +// Value: pulumi.String("example_variable_value"), +// SelectedRepositoryIds: pulumi.IntArray{ +// pulumi.Int(pulumi.Int(repo.RepoId)), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using the variable name as the ID. +// +// ### Import Command +// +// The following command imports a GitHub actions organization variable named `myvariable` to a `ActionsOrganizationVariable` resource named `example`. +// +// ```sh +// $ pulumi import github:index/actionsOrganizationVariable:ActionsOrganizationVariable example myvariable +// ``` +type ActionsOrganizationVariable struct { + pulumi.CustomResourceState + + // Date the variable was created. + CreatedAt pulumi.StringOutput `pulumi:"createdAt"` + // An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. + SelectedRepositoryIds pulumi.IntArrayOutput `pulumi:"selectedRepositoryIds"` + // Date the variable was last updated. + UpdatedAt pulumi.StringOutput `pulumi:"updatedAt"` + // Value of the variable. + Value pulumi.StringOutput `pulumi:"value"` + // Name of the variable. + VariableName pulumi.StringOutput `pulumi:"variableName"` + // Configures the access that repositories have to the organization variable; must be one of `all`, `private`, or `selected`. + Visibility pulumi.StringOutput `pulumi:"visibility"` +} + +// NewActionsOrganizationVariable registers a new resource with the given unique name, arguments, and options. +func NewActionsOrganizationVariable(ctx *pulumi.Context, + name string, args *ActionsOrganizationVariableArgs, opts ...pulumi.ResourceOption) (*ActionsOrganizationVariable, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Value == nil { + return nil, errors.New("invalid value for required argument 'Value'") + } + if args.VariableName == nil { + return nil, errors.New("invalid value for required argument 'VariableName'") + } + if args.Visibility == nil { + return nil, errors.New("invalid value for required argument 'Visibility'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsOrganizationVariable + err := ctx.RegisterResource("github:index/actionsOrganizationVariable:ActionsOrganizationVariable", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsOrganizationVariable gets an existing ActionsOrganizationVariable 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 GetActionsOrganizationVariable(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsOrganizationVariableState, opts ...pulumi.ResourceOption) (*ActionsOrganizationVariable, error) { + var resource ActionsOrganizationVariable + err := ctx.ReadResource("github:index/actionsOrganizationVariable:ActionsOrganizationVariable", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsOrganizationVariable resources. +type actionsOrganizationVariableState struct { + // Date the variable was created. + CreatedAt *string `pulumi:"createdAt"` + // An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` + // Date the variable was last updated. + UpdatedAt *string `pulumi:"updatedAt"` + // Value of the variable. + Value *string `pulumi:"value"` + // Name of the variable. + VariableName *string `pulumi:"variableName"` + // Configures the access that repositories have to the organization variable; must be one of `all`, `private`, or `selected`. + Visibility *string `pulumi:"visibility"` +} + +type ActionsOrganizationVariableState struct { + // Date the variable was created. + CreatedAt pulumi.StringPtrInput + // An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. + SelectedRepositoryIds pulumi.IntArrayInput + // Date the variable was last updated. + UpdatedAt pulumi.StringPtrInput + // Value of the variable. + Value pulumi.StringPtrInput + // Name of the variable. + VariableName pulumi.StringPtrInput + // Configures the access that repositories have to the organization variable; must be one of `all`, `private`, or `selected`. + Visibility pulumi.StringPtrInput +} + +func (ActionsOrganizationVariableState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationVariableState)(nil)).Elem() +} + +type actionsOrganizationVariableArgs struct { + // An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` + // Value of the variable. + Value string `pulumi:"value"` + // Name of the variable. + VariableName string `pulumi:"variableName"` + // Configures the access that repositories have to the organization variable; must be one of `all`, `private`, or `selected`. + Visibility string `pulumi:"visibility"` +} + +// The set of arguments for constructing a ActionsOrganizationVariable resource. +type ActionsOrganizationVariableArgs struct { + // An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. + SelectedRepositoryIds pulumi.IntArrayInput + // Value of the variable. + Value pulumi.StringInput + // Name of the variable. + VariableName pulumi.StringInput + // Configures the access that repositories have to the organization variable; must be one of `all`, `private`, or `selected`. + Visibility pulumi.StringInput +} + +func (ActionsOrganizationVariableArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationVariableArgs)(nil)).Elem() +} + +type ActionsOrganizationVariableInput interface { + pulumi.Input + + ToActionsOrganizationVariableOutput() ActionsOrganizationVariableOutput + ToActionsOrganizationVariableOutputWithContext(ctx context.Context) ActionsOrganizationVariableOutput +} + +func (*ActionsOrganizationVariable) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationVariable)(nil)).Elem() +} + +func (i *ActionsOrganizationVariable) ToActionsOrganizationVariableOutput() ActionsOrganizationVariableOutput { + return i.ToActionsOrganizationVariableOutputWithContext(context.Background()) +} + +func (i *ActionsOrganizationVariable) ToActionsOrganizationVariableOutputWithContext(ctx context.Context) ActionsOrganizationVariableOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationVariableOutput) +} + +// ActionsOrganizationVariableArrayInput is an input type that accepts ActionsOrganizationVariableArray and ActionsOrganizationVariableArrayOutput values. +// You can construct a concrete instance of `ActionsOrganizationVariableArrayInput` via: +// +// ActionsOrganizationVariableArray{ ActionsOrganizationVariableArgs{...} } +type ActionsOrganizationVariableArrayInput interface { + pulumi.Input + + ToActionsOrganizationVariableArrayOutput() ActionsOrganizationVariableArrayOutput + ToActionsOrganizationVariableArrayOutputWithContext(context.Context) ActionsOrganizationVariableArrayOutput +} + +type ActionsOrganizationVariableArray []ActionsOrganizationVariableInput + +func (ActionsOrganizationVariableArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationVariable)(nil)).Elem() +} + +func (i ActionsOrganizationVariableArray) ToActionsOrganizationVariableArrayOutput() ActionsOrganizationVariableArrayOutput { + return i.ToActionsOrganizationVariableArrayOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationVariableArray) ToActionsOrganizationVariableArrayOutputWithContext(ctx context.Context) ActionsOrganizationVariableArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationVariableArrayOutput) +} + +// ActionsOrganizationVariableMapInput is an input type that accepts ActionsOrganizationVariableMap and ActionsOrganizationVariableMapOutput values. +// You can construct a concrete instance of `ActionsOrganizationVariableMapInput` via: +// +// ActionsOrganizationVariableMap{ "key": ActionsOrganizationVariableArgs{...} } +type ActionsOrganizationVariableMapInput interface { + pulumi.Input + + ToActionsOrganizationVariableMapOutput() ActionsOrganizationVariableMapOutput + ToActionsOrganizationVariableMapOutputWithContext(context.Context) ActionsOrganizationVariableMapOutput +} + +type ActionsOrganizationVariableMap map[string]ActionsOrganizationVariableInput + +func (ActionsOrganizationVariableMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationVariable)(nil)).Elem() +} + +func (i ActionsOrganizationVariableMap) ToActionsOrganizationVariableMapOutput() ActionsOrganizationVariableMapOutput { + return i.ToActionsOrganizationVariableMapOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationVariableMap) ToActionsOrganizationVariableMapOutputWithContext(ctx context.Context) ActionsOrganizationVariableMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationVariableMapOutput) +} + +type ActionsOrganizationVariableOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationVariableOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationVariable)(nil)).Elem() +} + +func (o ActionsOrganizationVariableOutput) ToActionsOrganizationVariableOutput() ActionsOrganizationVariableOutput { + return o +} + +func (o ActionsOrganizationVariableOutput) ToActionsOrganizationVariableOutputWithContext(ctx context.Context) ActionsOrganizationVariableOutput { + return o +} + +// Date the variable was created. +func (o ActionsOrganizationVariableOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationVariable) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) +} + +// An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. +func (o ActionsOrganizationVariableOutput) SelectedRepositoryIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v *ActionsOrganizationVariable) pulumi.IntArrayOutput { return v.SelectedRepositoryIds }).(pulumi.IntArrayOutput) +} + +// Date the variable was last updated. +func (o ActionsOrganizationVariableOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationVariable) pulumi.StringOutput { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// Value of the variable. +func (o ActionsOrganizationVariableOutput) Value() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationVariable) pulumi.StringOutput { return v.Value }).(pulumi.StringOutput) +} + +// Name of the variable. +func (o ActionsOrganizationVariableOutput) VariableName() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationVariable) pulumi.StringOutput { return v.VariableName }).(pulumi.StringOutput) +} + +// Configures the access that repositories have to the organization variable; must be one of `all`, `private`, or `selected`. +func (o ActionsOrganizationVariableOutput) Visibility() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationVariable) pulumi.StringOutput { return v.Visibility }).(pulumi.StringOutput) +} + +type ActionsOrganizationVariableArrayOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationVariableArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationVariable)(nil)).Elem() +} + +func (o ActionsOrganizationVariableArrayOutput) ToActionsOrganizationVariableArrayOutput() ActionsOrganizationVariableArrayOutput { + return o +} + +func (o ActionsOrganizationVariableArrayOutput) ToActionsOrganizationVariableArrayOutputWithContext(ctx context.Context) ActionsOrganizationVariableArrayOutput { + return o +} + +func (o ActionsOrganizationVariableArrayOutput) Index(i pulumi.IntInput) ActionsOrganizationVariableOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsOrganizationVariable { + return vs[0].([]*ActionsOrganizationVariable)[vs[1].(int)] + }).(ActionsOrganizationVariableOutput) +} + +type ActionsOrganizationVariableMapOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationVariableMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationVariable)(nil)).Elem() +} + +func (o ActionsOrganizationVariableMapOutput) ToActionsOrganizationVariableMapOutput() ActionsOrganizationVariableMapOutput { + return o +} + +func (o ActionsOrganizationVariableMapOutput) ToActionsOrganizationVariableMapOutputWithContext(ctx context.Context) ActionsOrganizationVariableMapOutput { + return o +} + +func (o ActionsOrganizationVariableMapOutput) MapIndex(k pulumi.StringInput) ActionsOrganizationVariableOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsOrganizationVariable { + return vs[0].(map[string]*ActionsOrganizationVariable)[vs[1].(string)] + }).(ActionsOrganizationVariableOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationVariableInput)(nil)).Elem(), &ActionsOrganizationVariable{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationVariableArrayInput)(nil)).Elem(), ActionsOrganizationVariableArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationVariableMapInput)(nil)).Elem(), ActionsOrganizationVariableMap{}) + pulumi.RegisterOutputType(ActionsOrganizationVariableOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationVariableArrayOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationVariableMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationVariableRepositories.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationVariableRepositories.go new file mode 100644 index 000000000..69a61eefe --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationVariableRepositories.go @@ -0,0 +1,296 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to manage the repositories allowed to access an actions variable within your GitHub organization. +// You must have write access to an organization variable to use this resource. +// +// This resource is only applicable when `visibility` of the existing organization variable has been set to `selected`. +// +// ## Example Usage +// +// ```go +// 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.NewActionsOrganizationVariable(ctx, "example", &github.ActionsOrganizationVariableArgs{ +// VariableName: pulumi.String("myvariable"), +// Value: 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.NewActionsOrganizationVariableRepositories(ctx, "example", &github.ActionsOrganizationVariableRepositoriesArgs{ +// VariableName: example.Name, +// SelectedRepositoryIds: pulumi.IntArray{ +// exampleRepository.RepoId, +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using the variable name as the ID. +// +// ### Import Command +// +// The following command imports the repositories able to access the actions organization variable named `myvariable` to a `ActionsOrganizationVariableRepositories` resource named `example`. +// +// ```sh +// $ pulumi import github:index/actionsOrganizationVariableRepositories:ActionsOrganizationVariableRepositories example myvariable +// ``` +type ActionsOrganizationVariableRepositories struct { + pulumi.CustomResourceState + + // List of IDs for the repositories that should be able to access the variable. + SelectedRepositoryIds pulumi.IntArrayOutput `pulumi:"selectedRepositoryIds"` + // Name of the actions organization variable. + VariableName pulumi.StringOutput `pulumi:"variableName"` +} + +// NewActionsOrganizationVariableRepositories registers a new resource with the given unique name, arguments, and options. +func NewActionsOrganizationVariableRepositories(ctx *pulumi.Context, + name string, args *ActionsOrganizationVariableRepositoriesArgs, opts ...pulumi.ResourceOption) (*ActionsOrganizationVariableRepositories, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.SelectedRepositoryIds == nil { + return nil, errors.New("invalid value for required argument 'SelectedRepositoryIds'") + } + if args.VariableName == nil { + return nil, errors.New("invalid value for required argument 'VariableName'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsOrganizationVariableRepositories + err := ctx.RegisterResource("github:index/actionsOrganizationVariableRepositories:ActionsOrganizationVariableRepositories", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsOrganizationVariableRepositories gets an existing ActionsOrganizationVariableRepositories 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 GetActionsOrganizationVariableRepositories(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsOrganizationVariableRepositoriesState, opts ...pulumi.ResourceOption) (*ActionsOrganizationVariableRepositories, error) { + var resource ActionsOrganizationVariableRepositories + err := ctx.ReadResource("github:index/actionsOrganizationVariableRepositories:ActionsOrganizationVariableRepositories", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsOrganizationVariableRepositories resources. +type actionsOrganizationVariableRepositoriesState struct { + // List of IDs for the repositories that should be able to access the variable. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` + // Name of the actions organization variable. + VariableName *string `pulumi:"variableName"` +} + +type ActionsOrganizationVariableRepositoriesState struct { + // List of IDs for the repositories that should be able to access the variable. + SelectedRepositoryIds pulumi.IntArrayInput + // Name of the actions organization variable. + VariableName pulumi.StringPtrInput +} + +func (ActionsOrganizationVariableRepositoriesState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationVariableRepositoriesState)(nil)).Elem() +} + +type actionsOrganizationVariableRepositoriesArgs struct { + // List of IDs for the repositories that should be able to access the variable. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` + // Name of the actions organization variable. + VariableName string `pulumi:"variableName"` +} + +// The set of arguments for constructing a ActionsOrganizationVariableRepositories resource. +type ActionsOrganizationVariableRepositoriesArgs struct { + // List of IDs for the repositories that should be able to access the variable. + SelectedRepositoryIds pulumi.IntArrayInput + // Name of the actions organization variable. + VariableName pulumi.StringInput +} + +func (ActionsOrganizationVariableRepositoriesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationVariableRepositoriesArgs)(nil)).Elem() +} + +type ActionsOrganizationVariableRepositoriesInput interface { + pulumi.Input + + ToActionsOrganizationVariableRepositoriesOutput() ActionsOrganizationVariableRepositoriesOutput + ToActionsOrganizationVariableRepositoriesOutputWithContext(ctx context.Context) ActionsOrganizationVariableRepositoriesOutput +} + +func (*ActionsOrganizationVariableRepositories) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationVariableRepositories)(nil)).Elem() +} + +func (i *ActionsOrganizationVariableRepositories) ToActionsOrganizationVariableRepositoriesOutput() ActionsOrganizationVariableRepositoriesOutput { + return i.ToActionsOrganizationVariableRepositoriesOutputWithContext(context.Background()) +} + +func (i *ActionsOrganizationVariableRepositories) ToActionsOrganizationVariableRepositoriesOutputWithContext(ctx context.Context) ActionsOrganizationVariableRepositoriesOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationVariableRepositoriesOutput) +} + +// ActionsOrganizationVariableRepositoriesArrayInput is an input type that accepts ActionsOrganizationVariableRepositoriesArray and ActionsOrganizationVariableRepositoriesArrayOutput values. +// You can construct a concrete instance of `ActionsOrganizationVariableRepositoriesArrayInput` via: +// +// ActionsOrganizationVariableRepositoriesArray{ ActionsOrganizationVariableRepositoriesArgs{...} } +type ActionsOrganizationVariableRepositoriesArrayInput interface { + pulumi.Input + + ToActionsOrganizationVariableRepositoriesArrayOutput() ActionsOrganizationVariableRepositoriesArrayOutput + ToActionsOrganizationVariableRepositoriesArrayOutputWithContext(context.Context) ActionsOrganizationVariableRepositoriesArrayOutput +} + +type ActionsOrganizationVariableRepositoriesArray []ActionsOrganizationVariableRepositoriesInput + +func (ActionsOrganizationVariableRepositoriesArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationVariableRepositories)(nil)).Elem() +} + +func (i ActionsOrganizationVariableRepositoriesArray) ToActionsOrganizationVariableRepositoriesArrayOutput() ActionsOrganizationVariableRepositoriesArrayOutput { + return i.ToActionsOrganizationVariableRepositoriesArrayOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationVariableRepositoriesArray) ToActionsOrganizationVariableRepositoriesArrayOutputWithContext(ctx context.Context) ActionsOrganizationVariableRepositoriesArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationVariableRepositoriesArrayOutput) +} + +// ActionsOrganizationVariableRepositoriesMapInput is an input type that accepts ActionsOrganizationVariableRepositoriesMap and ActionsOrganizationVariableRepositoriesMapOutput values. +// You can construct a concrete instance of `ActionsOrganizationVariableRepositoriesMapInput` via: +// +// ActionsOrganizationVariableRepositoriesMap{ "key": ActionsOrganizationVariableRepositoriesArgs{...} } +type ActionsOrganizationVariableRepositoriesMapInput interface { + pulumi.Input + + ToActionsOrganizationVariableRepositoriesMapOutput() ActionsOrganizationVariableRepositoriesMapOutput + ToActionsOrganizationVariableRepositoriesMapOutputWithContext(context.Context) ActionsOrganizationVariableRepositoriesMapOutput +} + +type ActionsOrganizationVariableRepositoriesMap map[string]ActionsOrganizationVariableRepositoriesInput + +func (ActionsOrganizationVariableRepositoriesMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationVariableRepositories)(nil)).Elem() +} + +func (i ActionsOrganizationVariableRepositoriesMap) ToActionsOrganizationVariableRepositoriesMapOutput() ActionsOrganizationVariableRepositoriesMapOutput { + return i.ToActionsOrganizationVariableRepositoriesMapOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationVariableRepositoriesMap) ToActionsOrganizationVariableRepositoriesMapOutputWithContext(ctx context.Context) ActionsOrganizationVariableRepositoriesMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationVariableRepositoriesMapOutput) +} + +type ActionsOrganizationVariableRepositoriesOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationVariableRepositoriesOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationVariableRepositories)(nil)).Elem() +} + +func (o ActionsOrganizationVariableRepositoriesOutput) ToActionsOrganizationVariableRepositoriesOutput() ActionsOrganizationVariableRepositoriesOutput { + return o +} + +func (o ActionsOrganizationVariableRepositoriesOutput) ToActionsOrganizationVariableRepositoriesOutputWithContext(ctx context.Context) ActionsOrganizationVariableRepositoriesOutput { + return o +} + +// List of IDs for the repositories that should be able to access the variable. +func (o ActionsOrganizationVariableRepositoriesOutput) SelectedRepositoryIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v *ActionsOrganizationVariableRepositories) pulumi.IntArrayOutput { return v.SelectedRepositoryIds }).(pulumi.IntArrayOutput) +} + +// Name of the actions organization variable. +func (o ActionsOrganizationVariableRepositoriesOutput) VariableName() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationVariableRepositories) pulumi.StringOutput { return v.VariableName }).(pulumi.StringOutput) +} + +type ActionsOrganizationVariableRepositoriesArrayOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationVariableRepositoriesArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationVariableRepositories)(nil)).Elem() +} + +func (o ActionsOrganizationVariableRepositoriesArrayOutput) ToActionsOrganizationVariableRepositoriesArrayOutput() ActionsOrganizationVariableRepositoriesArrayOutput { + return o +} + +func (o ActionsOrganizationVariableRepositoriesArrayOutput) ToActionsOrganizationVariableRepositoriesArrayOutputWithContext(ctx context.Context) ActionsOrganizationVariableRepositoriesArrayOutput { + return o +} + +func (o ActionsOrganizationVariableRepositoriesArrayOutput) Index(i pulumi.IntInput) ActionsOrganizationVariableRepositoriesOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsOrganizationVariableRepositories { + return vs[0].([]*ActionsOrganizationVariableRepositories)[vs[1].(int)] + }).(ActionsOrganizationVariableRepositoriesOutput) +} + +type ActionsOrganizationVariableRepositoriesMapOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationVariableRepositoriesMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationVariableRepositories)(nil)).Elem() +} + +func (o ActionsOrganizationVariableRepositoriesMapOutput) ToActionsOrganizationVariableRepositoriesMapOutput() ActionsOrganizationVariableRepositoriesMapOutput { + return o +} + +func (o ActionsOrganizationVariableRepositoriesMapOutput) ToActionsOrganizationVariableRepositoriesMapOutputWithContext(ctx context.Context) ActionsOrganizationVariableRepositoriesMapOutput { + return o +} + +func (o ActionsOrganizationVariableRepositoriesMapOutput) MapIndex(k pulumi.StringInput) ActionsOrganizationVariableRepositoriesOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsOrganizationVariableRepositories { + return vs[0].(map[string]*ActionsOrganizationVariableRepositories)[vs[1].(string)] + }).(ActionsOrganizationVariableRepositoriesOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationVariableRepositoriesInput)(nil)).Elem(), &ActionsOrganizationVariableRepositories{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationVariableRepositoriesArrayInput)(nil)).Elem(), ActionsOrganizationVariableRepositoriesArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationVariableRepositoriesMapInput)(nil)).Elem(), ActionsOrganizationVariableRepositoriesMap{}) + pulumi.RegisterOutputType(ActionsOrganizationVariableRepositoriesOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationVariableRepositoriesArrayOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationVariableRepositoriesMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationVariableRepository.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationVariableRepository.go new file mode 100644 index 000000000..b6bfbb947 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationVariableRepository.go @@ -0,0 +1,294 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource adds permission for a repository to use an actions variables within your GitHub organization. +// You must have write access to an organization variable to use this resource. +// +// This resource is only applicable when `visibility` of the existing organization variable has been set to `selected`. +// +// ## Example Usage +// +// ```go +// 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.NewActionsOrganizationVariable(ctx, "example", &github.ActionsOrganizationVariableArgs{ +// VariableName: pulumi.String("myvariable"), +// Value: 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.NewActionsOrganizationVariableRepository(ctx, "example", &github.ActionsOrganizationVariableRepositoryArgs{ +// VariableName: example.Name, +// RepositoryId: exampleRepository.RepoId, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using an ID made of the variable name and repository name separated by a `:`. +// +// ### Import Command +// +// The following command imports the access of repository ID `123456` for the actions organization variable named `myvariable` to a `ActionsOrganizationVariableRepository` resource named `example`. +// +// ```sh +// $ pulumi import github:index/actionsOrganizationVariableRepository:ActionsOrganizationVariableRepository example myvariable:123456 +// ``` +type ActionsOrganizationVariableRepository struct { + pulumi.CustomResourceState + + // ID of the repository that should be able to access the variable. + RepositoryId pulumi.IntOutput `pulumi:"repositoryId"` + // Name of the actions organization variable. + VariableName pulumi.StringOutput `pulumi:"variableName"` +} + +// NewActionsOrganizationVariableRepository registers a new resource with the given unique name, arguments, and options. +func NewActionsOrganizationVariableRepository(ctx *pulumi.Context, + name string, args *ActionsOrganizationVariableRepositoryArgs, opts ...pulumi.ResourceOption) (*ActionsOrganizationVariableRepository, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.RepositoryId == nil { + return nil, errors.New("invalid value for required argument 'RepositoryId'") + } + if args.VariableName == nil { + return nil, errors.New("invalid value for required argument 'VariableName'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsOrganizationVariableRepository + err := ctx.RegisterResource("github:index/actionsOrganizationVariableRepository:ActionsOrganizationVariableRepository", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsOrganizationVariableRepository gets an existing ActionsOrganizationVariableRepository 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 GetActionsOrganizationVariableRepository(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsOrganizationVariableRepositoryState, opts ...pulumi.ResourceOption) (*ActionsOrganizationVariableRepository, error) { + var resource ActionsOrganizationVariableRepository + err := ctx.ReadResource("github:index/actionsOrganizationVariableRepository:ActionsOrganizationVariableRepository", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsOrganizationVariableRepository resources. +type actionsOrganizationVariableRepositoryState struct { + // ID of the repository that should be able to access the variable. + RepositoryId *int `pulumi:"repositoryId"` + // Name of the actions organization variable. + VariableName *string `pulumi:"variableName"` +} + +type ActionsOrganizationVariableRepositoryState struct { + // ID of the repository that should be able to access the variable. + RepositoryId pulumi.IntPtrInput + // Name of the actions organization variable. + VariableName pulumi.StringPtrInput +} + +func (ActionsOrganizationVariableRepositoryState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationVariableRepositoryState)(nil)).Elem() +} + +type actionsOrganizationVariableRepositoryArgs struct { + // ID of the repository that should be able to access the variable. + RepositoryId int `pulumi:"repositoryId"` + // Name of the actions organization variable. + VariableName string `pulumi:"variableName"` +} + +// The set of arguments for constructing a ActionsOrganizationVariableRepository resource. +type ActionsOrganizationVariableRepositoryArgs struct { + // ID of the repository that should be able to access the variable. + RepositoryId pulumi.IntInput + // Name of the actions organization variable. + VariableName pulumi.StringInput +} + +func (ActionsOrganizationVariableRepositoryArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationVariableRepositoryArgs)(nil)).Elem() +} + +type ActionsOrganizationVariableRepositoryInput interface { + pulumi.Input + + ToActionsOrganizationVariableRepositoryOutput() ActionsOrganizationVariableRepositoryOutput + ToActionsOrganizationVariableRepositoryOutputWithContext(ctx context.Context) ActionsOrganizationVariableRepositoryOutput +} + +func (*ActionsOrganizationVariableRepository) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationVariableRepository)(nil)).Elem() +} + +func (i *ActionsOrganizationVariableRepository) ToActionsOrganizationVariableRepositoryOutput() ActionsOrganizationVariableRepositoryOutput { + return i.ToActionsOrganizationVariableRepositoryOutputWithContext(context.Background()) +} + +func (i *ActionsOrganizationVariableRepository) ToActionsOrganizationVariableRepositoryOutputWithContext(ctx context.Context) ActionsOrganizationVariableRepositoryOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationVariableRepositoryOutput) +} + +// ActionsOrganizationVariableRepositoryArrayInput is an input type that accepts ActionsOrganizationVariableRepositoryArray and ActionsOrganizationVariableRepositoryArrayOutput values. +// You can construct a concrete instance of `ActionsOrganizationVariableRepositoryArrayInput` via: +// +// ActionsOrganizationVariableRepositoryArray{ ActionsOrganizationVariableRepositoryArgs{...} } +type ActionsOrganizationVariableRepositoryArrayInput interface { + pulumi.Input + + ToActionsOrganizationVariableRepositoryArrayOutput() ActionsOrganizationVariableRepositoryArrayOutput + ToActionsOrganizationVariableRepositoryArrayOutputWithContext(context.Context) ActionsOrganizationVariableRepositoryArrayOutput +} + +type ActionsOrganizationVariableRepositoryArray []ActionsOrganizationVariableRepositoryInput + +func (ActionsOrganizationVariableRepositoryArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationVariableRepository)(nil)).Elem() +} + +func (i ActionsOrganizationVariableRepositoryArray) ToActionsOrganizationVariableRepositoryArrayOutput() ActionsOrganizationVariableRepositoryArrayOutput { + return i.ToActionsOrganizationVariableRepositoryArrayOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationVariableRepositoryArray) ToActionsOrganizationVariableRepositoryArrayOutputWithContext(ctx context.Context) ActionsOrganizationVariableRepositoryArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationVariableRepositoryArrayOutput) +} + +// ActionsOrganizationVariableRepositoryMapInput is an input type that accepts ActionsOrganizationVariableRepositoryMap and ActionsOrganizationVariableRepositoryMapOutput values. +// You can construct a concrete instance of `ActionsOrganizationVariableRepositoryMapInput` via: +// +// ActionsOrganizationVariableRepositoryMap{ "key": ActionsOrganizationVariableRepositoryArgs{...} } +type ActionsOrganizationVariableRepositoryMapInput interface { + pulumi.Input + + ToActionsOrganizationVariableRepositoryMapOutput() ActionsOrganizationVariableRepositoryMapOutput + ToActionsOrganizationVariableRepositoryMapOutputWithContext(context.Context) ActionsOrganizationVariableRepositoryMapOutput +} + +type ActionsOrganizationVariableRepositoryMap map[string]ActionsOrganizationVariableRepositoryInput + +func (ActionsOrganizationVariableRepositoryMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationVariableRepository)(nil)).Elem() +} + +func (i ActionsOrganizationVariableRepositoryMap) ToActionsOrganizationVariableRepositoryMapOutput() ActionsOrganizationVariableRepositoryMapOutput { + return i.ToActionsOrganizationVariableRepositoryMapOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationVariableRepositoryMap) ToActionsOrganizationVariableRepositoryMapOutputWithContext(ctx context.Context) ActionsOrganizationVariableRepositoryMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationVariableRepositoryMapOutput) +} + +type ActionsOrganizationVariableRepositoryOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationVariableRepositoryOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationVariableRepository)(nil)).Elem() +} + +func (o ActionsOrganizationVariableRepositoryOutput) ToActionsOrganizationVariableRepositoryOutput() ActionsOrganizationVariableRepositoryOutput { + return o +} + +func (o ActionsOrganizationVariableRepositoryOutput) ToActionsOrganizationVariableRepositoryOutputWithContext(ctx context.Context) ActionsOrganizationVariableRepositoryOutput { + return o +} + +// ID of the repository that should be able to access the variable. +func (o ActionsOrganizationVariableRepositoryOutput) RepositoryId() pulumi.IntOutput { + return o.ApplyT(func(v *ActionsOrganizationVariableRepository) pulumi.IntOutput { return v.RepositoryId }).(pulumi.IntOutput) +} + +// Name of the actions organization variable. +func (o ActionsOrganizationVariableRepositoryOutput) VariableName() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationVariableRepository) pulumi.StringOutput { return v.VariableName }).(pulumi.StringOutput) +} + +type ActionsOrganizationVariableRepositoryArrayOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationVariableRepositoryArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationVariableRepository)(nil)).Elem() +} + +func (o ActionsOrganizationVariableRepositoryArrayOutput) ToActionsOrganizationVariableRepositoryArrayOutput() ActionsOrganizationVariableRepositoryArrayOutput { + return o +} + +func (o ActionsOrganizationVariableRepositoryArrayOutput) ToActionsOrganizationVariableRepositoryArrayOutputWithContext(ctx context.Context) ActionsOrganizationVariableRepositoryArrayOutput { + return o +} + +func (o ActionsOrganizationVariableRepositoryArrayOutput) Index(i pulumi.IntInput) ActionsOrganizationVariableRepositoryOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsOrganizationVariableRepository { + return vs[0].([]*ActionsOrganizationVariableRepository)[vs[1].(int)] + }).(ActionsOrganizationVariableRepositoryOutput) +} + +type ActionsOrganizationVariableRepositoryMapOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationVariableRepositoryMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationVariableRepository)(nil)).Elem() +} + +func (o ActionsOrganizationVariableRepositoryMapOutput) ToActionsOrganizationVariableRepositoryMapOutput() ActionsOrganizationVariableRepositoryMapOutput { + return o +} + +func (o ActionsOrganizationVariableRepositoryMapOutput) ToActionsOrganizationVariableRepositoryMapOutputWithContext(ctx context.Context) ActionsOrganizationVariableRepositoryMapOutput { + return o +} + +func (o ActionsOrganizationVariableRepositoryMapOutput) MapIndex(k pulumi.StringInput) ActionsOrganizationVariableRepositoryOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsOrganizationVariableRepository { + return vs[0].(map[string]*ActionsOrganizationVariableRepository)[vs[1].(string)] + }).(ActionsOrganizationVariableRepositoryOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationVariableRepositoryInput)(nil)).Elem(), &ActionsOrganizationVariableRepository{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationVariableRepositoryArrayInput)(nil)).Elem(), ActionsOrganizationVariableRepositoryArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationVariableRepositoryMapInput)(nil)).Elem(), ActionsOrganizationVariableRepositoryMap{}) + pulumi.RegisterOutputType(ActionsOrganizationVariableRepositoryOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationVariableRepositoryArrayOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationVariableRepositoryMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationWorkflowPermissions.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationWorkflowPermissions.go new file mode 100644 index 000000000..acbde1264 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsOrganizationWorkflowPermissions.go @@ -0,0 +1,310 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to manage GitHub Actions workflow permissions for a GitHub Organization account. This controls the default permissions granted to the GITHUB_TOKEN when running workflows and whether GitHub Actions can approve pull request reviews. +// +// You must have organization admin access to use this resource. +// +// ## Example Usage +// +// ```go +// 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 { +// // Basic workflow permissions configuration +// _, err := github.NewActionsOrganizationWorkflowPermissions(ctx, "example", &github.ActionsOrganizationWorkflowPermissionsArgs{ +// OrganizationSlug: pulumi.String("my-organization"), +// DefaultWorkflowPermissions: pulumi.String("read"), +// CanApprovePullRequestReviews: pulumi.Bool(false), +// }) +// if err != nil { +// return err +// } +// // Allow write permissions and PR approvals +// _, err = github.NewActionsOrganizationWorkflowPermissions(ctx, "permissive", &github.ActionsOrganizationWorkflowPermissionsArgs{ +// OrganizationSlug: pulumi.String("my-organization"), +// DefaultWorkflowPermissions: pulumi.String("write"), +// CanApprovePullRequestReviews: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Notes +// +// > **Note:** This resource requires a GitHub Organization account and organization admin permissions. +// +// When this resource is destroyed, the workflow permissions will be reset to safe defaults: +// +// * `defaultWorkflowPermissions` = `read` +// * `canApprovePullRequestReviews` = `false` +// +// ## Import +// +// Organization Actions workflow permissions can be imported using the organization slug: +// +// ```sh +// $ pulumi import github:index/actionsOrganizationWorkflowPermissions:ActionsOrganizationWorkflowPermissions example my-organization +// ``` +type ActionsOrganizationWorkflowPermissions struct { + pulumi.CustomResourceState + + // Whether GitHub Actions can approve pull request reviews. Defaults to `false`. + CanApprovePullRequestReviews pulumi.BoolPtrOutput `pulumi:"canApprovePullRequestReviews"` + // The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be `read` or `write`. Defaults to `read`. + DefaultWorkflowPermissions pulumi.StringPtrOutput `pulumi:"defaultWorkflowPermissions"` + // The slug of the organization. + OrganizationSlug pulumi.StringOutput `pulumi:"organizationSlug"` +} + +// NewActionsOrganizationWorkflowPermissions registers a new resource with the given unique name, arguments, and options. +func NewActionsOrganizationWorkflowPermissions(ctx *pulumi.Context, + name string, args *ActionsOrganizationWorkflowPermissionsArgs, opts ...pulumi.ResourceOption) (*ActionsOrganizationWorkflowPermissions, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.OrganizationSlug == nil { + return nil, errors.New("invalid value for required argument 'OrganizationSlug'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsOrganizationWorkflowPermissions + err := ctx.RegisterResource("github:index/actionsOrganizationWorkflowPermissions:ActionsOrganizationWorkflowPermissions", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsOrganizationWorkflowPermissions gets an existing ActionsOrganizationWorkflowPermissions 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 GetActionsOrganizationWorkflowPermissions(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsOrganizationWorkflowPermissionsState, opts ...pulumi.ResourceOption) (*ActionsOrganizationWorkflowPermissions, error) { + var resource ActionsOrganizationWorkflowPermissions + err := ctx.ReadResource("github:index/actionsOrganizationWorkflowPermissions:ActionsOrganizationWorkflowPermissions", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsOrganizationWorkflowPermissions resources. +type actionsOrganizationWorkflowPermissionsState struct { + // Whether GitHub Actions can approve pull request reviews. Defaults to `false`. + CanApprovePullRequestReviews *bool `pulumi:"canApprovePullRequestReviews"` + // The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be `read` or `write`. Defaults to `read`. + DefaultWorkflowPermissions *string `pulumi:"defaultWorkflowPermissions"` + // The slug of the organization. + OrganizationSlug *string `pulumi:"organizationSlug"` +} + +type ActionsOrganizationWorkflowPermissionsState struct { + // Whether GitHub Actions can approve pull request reviews. Defaults to `false`. + CanApprovePullRequestReviews pulumi.BoolPtrInput + // The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be `read` or `write`. Defaults to `read`. + DefaultWorkflowPermissions pulumi.StringPtrInput + // The slug of the organization. + OrganizationSlug pulumi.StringPtrInput +} + +func (ActionsOrganizationWorkflowPermissionsState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationWorkflowPermissionsState)(nil)).Elem() +} + +type actionsOrganizationWorkflowPermissionsArgs struct { + // Whether GitHub Actions can approve pull request reviews. Defaults to `false`. + CanApprovePullRequestReviews *bool `pulumi:"canApprovePullRequestReviews"` + // The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be `read` or `write`. Defaults to `read`. + DefaultWorkflowPermissions *string `pulumi:"defaultWorkflowPermissions"` + // The slug of the organization. + OrganizationSlug string `pulumi:"organizationSlug"` +} + +// The set of arguments for constructing a ActionsOrganizationWorkflowPermissions resource. +type ActionsOrganizationWorkflowPermissionsArgs struct { + // Whether GitHub Actions can approve pull request reviews. Defaults to `false`. + CanApprovePullRequestReviews pulumi.BoolPtrInput + // The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be `read` or `write`. Defaults to `read`. + DefaultWorkflowPermissions pulumi.StringPtrInput + // The slug of the organization. + OrganizationSlug pulumi.StringInput +} + +func (ActionsOrganizationWorkflowPermissionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsOrganizationWorkflowPermissionsArgs)(nil)).Elem() +} + +type ActionsOrganizationWorkflowPermissionsInput interface { + pulumi.Input + + ToActionsOrganizationWorkflowPermissionsOutput() ActionsOrganizationWorkflowPermissionsOutput + ToActionsOrganizationWorkflowPermissionsOutputWithContext(ctx context.Context) ActionsOrganizationWorkflowPermissionsOutput +} + +func (*ActionsOrganizationWorkflowPermissions) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationWorkflowPermissions)(nil)).Elem() +} + +func (i *ActionsOrganizationWorkflowPermissions) ToActionsOrganizationWorkflowPermissionsOutput() ActionsOrganizationWorkflowPermissionsOutput { + return i.ToActionsOrganizationWorkflowPermissionsOutputWithContext(context.Background()) +} + +func (i *ActionsOrganizationWorkflowPermissions) ToActionsOrganizationWorkflowPermissionsOutputWithContext(ctx context.Context) ActionsOrganizationWorkflowPermissionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationWorkflowPermissionsOutput) +} + +// ActionsOrganizationWorkflowPermissionsArrayInput is an input type that accepts ActionsOrganizationWorkflowPermissionsArray and ActionsOrganizationWorkflowPermissionsArrayOutput values. +// You can construct a concrete instance of `ActionsOrganizationWorkflowPermissionsArrayInput` via: +// +// ActionsOrganizationWorkflowPermissionsArray{ ActionsOrganizationWorkflowPermissionsArgs{...} } +type ActionsOrganizationWorkflowPermissionsArrayInput interface { + pulumi.Input + + ToActionsOrganizationWorkflowPermissionsArrayOutput() ActionsOrganizationWorkflowPermissionsArrayOutput + ToActionsOrganizationWorkflowPermissionsArrayOutputWithContext(context.Context) ActionsOrganizationWorkflowPermissionsArrayOutput +} + +type ActionsOrganizationWorkflowPermissionsArray []ActionsOrganizationWorkflowPermissionsInput + +func (ActionsOrganizationWorkflowPermissionsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationWorkflowPermissions)(nil)).Elem() +} + +func (i ActionsOrganizationWorkflowPermissionsArray) ToActionsOrganizationWorkflowPermissionsArrayOutput() ActionsOrganizationWorkflowPermissionsArrayOutput { + return i.ToActionsOrganizationWorkflowPermissionsArrayOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationWorkflowPermissionsArray) ToActionsOrganizationWorkflowPermissionsArrayOutputWithContext(ctx context.Context) ActionsOrganizationWorkflowPermissionsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationWorkflowPermissionsArrayOutput) +} + +// ActionsOrganizationWorkflowPermissionsMapInput is an input type that accepts ActionsOrganizationWorkflowPermissionsMap and ActionsOrganizationWorkflowPermissionsMapOutput values. +// You can construct a concrete instance of `ActionsOrganizationWorkflowPermissionsMapInput` via: +// +// ActionsOrganizationWorkflowPermissionsMap{ "key": ActionsOrganizationWorkflowPermissionsArgs{...} } +type ActionsOrganizationWorkflowPermissionsMapInput interface { + pulumi.Input + + ToActionsOrganizationWorkflowPermissionsMapOutput() ActionsOrganizationWorkflowPermissionsMapOutput + ToActionsOrganizationWorkflowPermissionsMapOutputWithContext(context.Context) ActionsOrganizationWorkflowPermissionsMapOutput +} + +type ActionsOrganizationWorkflowPermissionsMap map[string]ActionsOrganizationWorkflowPermissionsInput + +func (ActionsOrganizationWorkflowPermissionsMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationWorkflowPermissions)(nil)).Elem() +} + +func (i ActionsOrganizationWorkflowPermissionsMap) ToActionsOrganizationWorkflowPermissionsMapOutput() ActionsOrganizationWorkflowPermissionsMapOutput { + return i.ToActionsOrganizationWorkflowPermissionsMapOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationWorkflowPermissionsMap) ToActionsOrganizationWorkflowPermissionsMapOutputWithContext(ctx context.Context) ActionsOrganizationWorkflowPermissionsMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationWorkflowPermissionsMapOutput) +} + +type ActionsOrganizationWorkflowPermissionsOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationWorkflowPermissionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationWorkflowPermissions)(nil)).Elem() +} + +func (o ActionsOrganizationWorkflowPermissionsOutput) ToActionsOrganizationWorkflowPermissionsOutput() ActionsOrganizationWorkflowPermissionsOutput { + return o +} + +func (o ActionsOrganizationWorkflowPermissionsOutput) ToActionsOrganizationWorkflowPermissionsOutputWithContext(ctx context.Context) ActionsOrganizationWorkflowPermissionsOutput { + return o +} + +// Whether GitHub Actions can approve pull request reviews. Defaults to `false`. +func (o ActionsOrganizationWorkflowPermissionsOutput) CanApprovePullRequestReviews() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ActionsOrganizationWorkflowPermissions) pulumi.BoolPtrOutput { + return v.CanApprovePullRequestReviews + }).(pulumi.BoolPtrOutput) +} + +// The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be `read` or `write`. Defaults to `read`. +func (o ActionsOrganizationWorkflowPermissionsOutput) DefaultWorkflowPermissions() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsOrganizationWorkflowPermissions) pulumi.StringPtrOutput { + return v.DefaultWorkflowPermissions + }).(pulumi.StringPtrOutput) +} + +// The slug of the organization. +func (o ActionsOrganizationWorkflowPermissionsOutput) OrganizationSlug() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsOrganizationWorkflowPermissions) pulumi.StringOutput { return v.OrganizationSlug }).(pulumi.StringOutput) +} + +type ActionsOrganizationWorkflowPermissionsArrayOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationWorkflowPermissionsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsOrganizationWorkflowPermissions)(nil)).Elem() +} + +func (o ActionsOrganizationWorkflowPermissionsArrayOutput) ToActionsOrganizationWorkflowPermissionsArrayOutput() ActionsOrganizationWorkflowPermissionsArrayOutput { + return o +} + +func (o ActionsOrganizationWorkflowPermissionsArrayOutput) ToActionsOrganizationWorkflowPermissionsArrayOutputWithContext(ctx context.Context) ActionsOrganizationWorkflowPermissionsArrayOutput { + return o +} + +func (o ActionsOrganizationWorkflowPermissionsArrayOutput) Index(i pulumi.IntInput) ActionsOrganizationWorkflowPermissionsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsOrganizationWorkflowPermissions { + return vs[0].([]*ActionsOrganizationWorkflowPermissions)[vs[1].(int)] + }).(ActionsOrganizationWorkflowPermissionsOutput) +} + +type ActionsOrganizationWorkflowPermissionsMapOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationWorkflowPermissionsMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsOrganizationWorkflowPermissions)(nil)).Elem() +} + +func (o ActionsOrganizationWorkflowPermissionsMapOutput) ToActionsOrganizationWorkflowPermissionsMapOutput() ActionsOrganizationWorkflowPermissionsMapOutput { + return o +} + +func (o ActionsOrganizationWorkflowPermissionsMapOutput) ToActionsOrganizationWorkflowPermissionsMapOutputWithContext(ctx context.Context) ActionsOrganizationWorkflowPermissionsMapOutput { + return o +} + +func (o ActionsOrganizationWorkflowPermissionsMapOutput) MapIndex(k pulumi.StringInput) ActionsOrganizationWorkflowPermissionsOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsOrganizationWorkflowPermissions { + return vs[0].(map[string]*ActionsOrganizationWorkflowPermissions)[vs[1].(string)] + }).(ActionsOrganizationWorkflowPermissionsOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationWorkflowPermissionsInput)(nil)).Elem(), &ActionsOrganizationWorkflowPermissions{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationWorkflowPermissionsArrayInput)(nil)).Elem(), ActionsOrganizationWorkflowPermissionsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationWorkflowPermissionsMapInput)(nil)).Elem(), ActionsOrganizationWorkflowPermissionsMap{}) + pulumi.RegisterOutputType(ActionsOrganizationWorkflowPermissionsOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationWorkflowPermissionsArrayOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationWorkflowPermissionsMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsRepositoryAccessLevel.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsRepositoryAccessLevel.go new file mode 100644 index 000000000..be2b744de --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsRepositoryAccessLevel.go @@ -0,0 +1,280 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to set the access level of a non-public repositories actions and reusable workflows for use in other repositories. +// You must have admin access to a repository to use this resource. +// +// ## Example Usage +// +// ```go +// 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"), +// Visibility: pulumi.String("private"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewActionsRepositoryAccessLevel(ctx, "test", &github.ActionsRepositoryAccessLevelArgs{ +// AccessLevel: pulumi.String("user"), +// Repository: example.Name, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using the name of the GitHub repository: +// +// ```sh +// $ pulumi import github:index/actionsRepositoryAccessLevel:ActionsRepositoryAccessLevel test my-repository +// ``` +type ActionsRepositoryAccessLevel struct { + pulumi.CustomResourceState + + // Where the actions or reusable workflows of the repository may be used. Possible values are `none`, `user`, `organization`, or `enterprise`. + AccessLevel pulumi.StringOutput `pulumi:"accessLevel"` + // The GitHub repository + Repository pulumi.StringOutput `pulumi:"repository"` +} + +// NewActionsRepositoryAccessLevel registers a new resource with the given unique name, arguments, and options. +func NewActionsRepositoryAccessLevel(ctx *pulumi.Context, + name string, args *ActionsRepositoryAccessLevelArgs, opts ...pulumi.ResourceOption) (*ActionsRepositoryAccessLevel, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.AccessLevel == nil { + return nil, errors.New("invalid value for required argument 'AccessLevel'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsRepositoryAccessLevel + err := ctx.RegisterResource("github:index/actionsRepositoryAccessLevel:ActionsRepositoryAccessLevel", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsRepositoryAccessLevel gets an existing ActionsRepositoryAccessLevel 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 GetActionsRepositoryAccessLevel(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsRepositoryAccessLevelState, opts ...pulumi.ResourceOption) (*ActionsRepositoryAccessLevel, error) { + var resource ActionsRepositoryAccessLevel + err := ctx.ReadResource("github:index/actionsRepositoryAccessLevel:ActionsRepositoryAccessLevel", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsRepositoryAccessLevel resources. +type actionsRepositoryAccessLevelState struct { + // Where the actions or reusable workflows of the repository may be used. Possible values are `none`, `user`, `organization`, or `enterprise`. + AccessLevel *string `pulumi:"accessLevel"` + // The GitHub repository + Repository *string `pulumi:"repository"` +} + +type ActionsRepositoryAccessLevelState struct { + // Where the actions or reusable workflows of the repository may be used. Possible values are `none`, `user`, `organization`, or `enterprise`. + AccessLevel pulumi.StringPtrInput + // The GitHub repository + Repository pulumi.StringPtrInput +} + +func (ActionsRepositoryAccessLevelState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsRepositoryAccessLevelState)(nil)).Elem() +} + +type actionsRepositoryAccessLevelArgs struct { + // Where the actions or reusable workflows of the repository may be used. Possible values are `none`, `user`, `organization`, or `enterprise`. + AccessLevel string `pulumi:"accessLevel"` + // The GitHub repository + Repository string `pulumi:"repository"` +} + +// The set of arguments for constructing a ActionsRepositoryAccessLevel resource. +type ActionsRepositoryAccessLevelArgs struct { + // Where the actions or reusable workflows of the repository may be used. Possible values are `none`, `user`, `organization`, or `enterprise`. + AccessLevel pulumi.StringInput + // The GitHub repository + Repository pulumi.StringInput +} + +func (ActionsRepositoryAccessLevelArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsRepositoryAccessLevelArgs)(nil)).Elem() +} + +type ActionsRepositoryAccessLevelInput interface { + pulumi.Input + + ToActionsRepositoryAccessLevelOutput() ActionsRepositoryAccessLevelOutput + ToActionsRepositoryAccessLevelOutputWithContext(ctx context.Context) ActionsRepositoryAccessLevelOutput +} + +func (*ActionsRepositoryAccessLevel) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsRepositoryAccessLevel)(nil)).Elem() +} + +func (i *ActionsRepositoryAccessLevel) ToActionsRepositoryAccessLevelOutput() ActionsRepositoryAccessLevelOutput { + return i.ToActionsRepositoryAccessLevelOutputWithContext(context.Background()) +} + +func (i *ActionsRepositoryAccessLevel) ToActionsRepositoryAccessLevelOutputWithContext(ctx context.Context) ActionsRepositoryAccessLevelOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsRepositoryAccessLevelOutput) +} + +// ActionsRepositoryAccessLevelArrayInput is an input type that accepts ActionsRepositoryAccessLevelArray and ActionsRepositoryAccessLevelArrayOutput values. +// You can construct a concrete instance of `ActionsRepositoryAccessLevelArrayInput` via: +// +// ActionsRepositoryAccessLevelArray{ ActionsRepositoryAccessLevelArgs{...} } +type ActionsRepositoryAccessLevelArrayInput interface { + pulumi.Input + + ToActionsRepositoryAccessLevelArrayOutput() ActionsRepositoryAccessLevelArrayOutput + ToActionsRepositoryAccessLevelArrayOutputWithContext(context.Context) ActionsRepositoryAccessLevelArrayOutput +} + +type ActionsRepositoryAccessLevelArray []ActionsRepositoryAccessLevelInput + +func (ActionsRepositoryAccessLevelArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsRepositoryAccessLevel)(nil)).Elem() +} + +func (i ActionsRepositoryAccessLevelArray) ToActionsRepositoryAccessLevelArrayOutput() ActionsRepositoryAccessLevelArrayOutput { + return i.ToActionsRepositoryAccessLevelArrayOutputWithContext(context.Background()) +} + +func (i ActionsRepositoryAccessLevelArray) ToActionsRepositoryAccessLevelArrayOutputWithContext(ctx context.Context) ActionsRepositoryAccessLevelArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsRepositoryAccessLevelArrayOutput) +} + +// ActionsRepositoryAccessLevelMapInput is an input type that accepts ActionsRepositoryAccessLevelMap and ActionsRepositoryAccessLevelMapOutput values. +// You can construct a concrete instance of `ActionsRepositoryAccessLevelMapInput` via: +// +// ActionsRepositoryAccessLevelMap{ "key": ActionsRepositoryAccessLevelArgs{...} } +type ActionsRepositoryAccessLevelMapInput interface { + pulumi.Input + + ToActionsRepositoryAccessLevelMapOutput() ActionsRepositoryAccessLevelMapOutput + ToActionsRepositoryAccessLevelMapOutputWithContext(context.Context) ActionsRepositoryAccessLevelMapOutput +} + +type ActionsRepositoryAccessLevelMap map[string]ActionsRepositoryAccessLevelInput + +func (ActionsRepositoryAccessLevelMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsRepositoryAccessLevel)(nil)).Elem() +} + +func (i ActionsRepositoryAccessLevelMap) ToActionsRepositoryAccessLevelMapOutput() ActionsRepositoryAccessLevelMapOutput { + return i.ToActionsRepositoryAccessLevelMapOutputWithContext(context.Background()) +} + +func (i ActionsRepositoryAccessLevelMap) ToActionsRepositoryAccessLevelMapOutputWithContext(ctx context.Context) ActionsRepositoryAccessLevelMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsRepositoryAccessLevelMapOutput) +} + +type ActionsRepositoryAccessLevelOutput struct{ *pulumi.OutputState } + +func (ActionsRepositoryAccessLevelOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsRepositoryAccessLevel)(nil)).Elem() +} + +func (o ActionsRepositoryAccessLevelOutput) ToActionsRepositoryAccessLevelOutput() ActionsRepositoryAccessLevelOutput { + return o +} + +func (o ActionsRepositoryAccessLevelOutput) ToActionsRepositoryAccessLevelOutputWithContext(ctx context.Context) ActionsRepositoryAccessLevelOutput { + return o +} + +// Where the actions or reusable workflows of the repository may be used. Possible values are `none`, `user`, `organization`, or `enterprise`. +func (o ActionsRepositoryAccessLevelOutput) AccessLevel() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsRepositoryAccessLevel) pulumi.StringOutput { return v.AccessLevel }).(pulumi.StringOutput) +} + +// The GitHub repository +func (o ActionsRepositoryAccessLevelOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsRepositoryAccessLevel) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +type ActionsRepositoryAccessLevelArrayOutput struct{ *pulumi.OutputState } + +func (ActionsRepositoryAccessLevelArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsRepositoryAccessLevel)(nil)).Elem() +} + +func (o ActionsRepositoryAccessLevelArrayOutput) ToActionsRepositoryAccessLevelArrayOutput() ActionsRepositoryAccessLevelArrayOutput { + return o +} + +func (o ActionsRepositoryAccessLevelArrayOutput) ToActionsRepositoryAccessLevelArrayOutputWithContext(ctx context.Context) ActionsRepositoryAccessLevelArrayOutput { + return o +} + +func (o ActionsRepositoryAccessLevelArrayOutput) Index(i pulumi.IntInput) ActionsRepositoryAccessLevelOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsRepositoryAccessLevel { + return vs[0].([]*ActionsRepositoryAccessLevel)[vs[1].(int)] + }).(ActionsRepositoryAccessLevelOutput) +} + +type ActionsRepositoryAccessLevelMapOutput struct{ *pulumi.OutputState } + +func (ActionsRepositoryAccessLevelMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsRepositoryAccessLevel)(nil)).Elem() +} + +func (o ActionsRepositoryAccessLevelMapOutput) ToActionsRepositoryAccessLevelMapOutput() ActionsRepositoryAccessLevelMapOutput { + return o +} + +func (o ActionsRepositoryAccessLevelMapOutput) ToActionsRepositoryAccessLevelMapOutputWithContext(ctx context.Context) ActionsRepositoryAccessLevelMapOutput { + return o +} + +func (o ActionsRepositoryAccessLevelMapOutput) MapIndex(k pulumi.StringInput) ActionsRepositoryAccessLevelOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsRepositoryAccessLevel { + return vs[0].(map[string]*ActionsRepositoryAccessLevel)[vs[1].(string)] + }).(ActionsRepositoryAccessLevelOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsRepositoryAccessLevelInput)(nil)).Elem(), &ActionsRepositoryAccessLevel{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsRepositoryAccessLevelArrayInput)(nil)).Elem(), ActionsRepositoryAccessLevelArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsRepositoryAccessLevelMapInput)(nil)).Elem(), ActionsRepositoryAccessLevelMap{}) + pulumi.RegisterOutputType(ActionsRepositoryAccessLevelOutput{}) + pulumi.RegisterOutputType(ActionsRepositoryAccessLevelArrayOutput{}) + pulumi.RegisterOutputType(ActionsRepositoryAccessLevelMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsRepositoryOidcSubjectClaimCustomizationTemplate.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsRepositoryOidcSubjectClaimCustomizationTemplate.go new file mode 100644 index 000000000..ca7364d19 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsRepositoryOidcSubjectClaimCustomizationTemplate.go @@ -0,0 +1,320 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage an OpenID Connect subject claim customization template for a GitHub +// repository. +// +// More information on integrating GitHub with cloud providers using OpenID Connect and a list of available claims is +// available in the [Actions documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect). +// +// The following table lists the behaviour of `useDefault`: +// +// | `useDefault` | `includeClaimKeys` | Template used | +// |---------------|----------------------|-----------------------------------------------------------| +// | `true` | Unset | GitHub's default | +// | `false` | Set | `includeClaimKeys` | +// | `false` | Unset | Organization's default if set, otherwise GitHub's default | +// +// ## Example Usage +// +// ```go +// 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("example-repository"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewActionsRepositoryOidcSubjectClaimCustomizationTemplate(ctx, "example_template", &github.ActionsRepositoryOidcSubjectClaimCustomizationTemplateArgs{ +// Repository: example.Name, +// UseDefault: pulumi.Bool(false), +// IncludeClaimKeys: pulumi.StringArray{ +// pulumi.String("actor"), +// pulumi.String("context"), +// pulumi.String("repository_owner"), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using the repository's name. +// +// ```sh +// $ pulumi import github:index/actionsRepositoryOidcSubjectClaimCustomizationTemplate:ActionsRepositoryOidcSubjectClaimCustomizationTemplate test example_repository +// ``` +type ActionsRepositoryOidcSubjectClaimCustomizationTemplate struct { + pulumi.CustomResourceState + + // A list of OpenID Connect claims. + IncludeClaimKeys pulumi.StringArrayOutput `pulumi:"includeClaimKeys"` + // The name of the repository. + Repository pulumi.StringOutput `pulumi:"repository"` + // Whether to use the default template or not. If `true`, `includeClaimKeys` must not + // be set. + UseDefault pulumi.BoolOutput `pulumi:"useDefault"` +} + +// NewActionsRepositoryOidcSubjectClaimCustomizationTemplate registers a new resource with the given unique name, arguments, and options. +func NewActionsRepositoryOidcSubjectClaimCustomizationTemplate(ctx *pulumi.Context, + name string, args *ActionsRepositoryOidcSubjectClaimCustomizationTemplateArgs, opts ...pulumi.ResourceOption) (*ActionsRepositoryOidcSubjectClaimCustomizationTemplate, 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.UseDefault == nil { + return nil, errors.New("invalid value for required argument 'UseDefault'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsRepositoryOidcSubjectClaimCustomizationTemplate + err := ctx.RegisterResource("github:index/actionsRepositoryOidcSubjectClaimCustomizationTemplate:ActionsRepositoryOidcSubjectClaimCustomizationTemplate", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsRepositoryOidcSubjectClaimCustomizationTemplate gets an existing ActionsRepositoryOidcSubjectClaimCustomizationTemplate 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 GetActionsRepositoryOidcSubjectClaimCustomizationTemplate(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsRepositoryOidcSubjectClaimCustomizationTemplateState, opts ...pulumi.ResourceOption) (*ActionsRepositoryOidcSubjectClaimCustomizationTemplate, error) { + var resource ActionsRepositoryOidcSubjectClaimCustomizationTemplate + err := ctx.ReadResource("github:index/actionsRepositoryOidcSubjectClaimCustomizationTemplate:ActionsRepositoryOidcSubjectClaimCustomizationTemplate", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsRepositoryOidcSubjectClaimCustomizationTemplate resources. +type actionsRepositoryOidcSubjectClaimCustomizationTemplateState struct { + // A list of OpenID Connect claims. + IncludeClaimKeys []string `pulumi:"includeClaimKeys"` + // The name of the repository. + Repository *string `pulumi:"repository"` + // Whether to use the default template or not. If `true`, `includeClaimKeys` must not + // be set. + UseDefault *bool `pulumi:"useDefault"` +} + +type ActionsRepositoryOidcSubjectClaimCustomizationTemplateState struct { + // A list of OpenID Connect claims. + IncludeClaimKeys pulumi.StringArrayInput + // The name of the repository. + Repository pulumi.StringPtrInput + // Whether to use the default template or not. If `true`, `includeClaimKeys` must not + // be set. + UseDefault pulumi.BoolPtrInput +} + +func (ActionsRepositoryOidcSubjectClaimCustomizationTemplateState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsRepositoryOidcSubjectClaimCustomizationTemplateState)(nil)).Elem() +} + +type actionsRepositoryOidcSubjectClaimCustomizationTemplateArgs struct { + // A list of OpenID Connect claims. + IncludeClaimKeys []string `pulumi:"includeClaimKeys"` + // The name of the repository. + Repository string `pulumi:"repository"` + // Whether to use the default template or not. If `true`, `includeClaimKeys` must not + // be set. + UseDefault bool `pulumi:"useDefault"` +} + +// The set of arguments for constructing a ActionsRepositoryOidcSubjectClaimCustomizationTemplate resource. +type ActionsRepositoryOidcSubjectClaimCustomizationTemplateArgs struct { + // A list of OpenID Connect claims. + IncludeClaimKeys pulumi.StringArrayInput + // The name of the repository. + Repository pulumi.StringInput + // Whether to use the default template or not. If `true`, `includeClaimKeys` must not + // be set. + UseDefault pulumi.BoolInput +} + +func (ActionsRepositoryOidcSubjectClaimCustomizationTemplateArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsRepositoryOidcSubjectClaimCustomizationTemplateArgs)(nil)).Elem() +} + +type ActionsRepositoryOidcSubjectClaimCustomizationTemplateInput interface { + pulumi.Input + + ToActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput() ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput + ToActionsRepositoryOidcSubjectClaimCustomizationTemplateOutputWithContext(ctx context.Context) ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput +} + +func (*ActionsRepositoryOidcSubjectClaimCustomizationTemplate) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsRepositoryOidcSubjectClaimCustomizationTemplate)(nil)).Elem() +} + +func (i *ActionsRepositoryOidcSubjectClaimCustomizationTemplate) ToActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput() ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput { + return i.ToActionsRepositoryOidcSubjectClaimCustomizationTemplateOutputWithContext(context.Background()) +} + +func (i *ActionsRepositoryOidcSubjectClaimCustomizationTemplate) ToActionsRepositoryOidcSubjectClaimCustomizationTemplateOutputWithContext(ctx context.Context) ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput) +} + +// ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayInput is an input type that accepts ActionsRepositoryOidcSubjectClaimCustomizationTemplateArray and ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput values. +// You can construct a concrete instance of `ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayInput` via: +// +// ActionsRepositoryOidcSubjectClaimCustomizationTemplateArray{ ActionsRepositoryOidcSubjectClaimCustomizationTemplateArgs{...} } +type ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayInput interface { + pulumi.Input + + ToActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput() ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput + ToActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutputWithContext(context.Context) ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput +} + +type ActionsRepositoryOidcSubjectClaimCustomizationTemplateArray []ActionsRepositoryOidcSubjectClaimCustomizationTemplateInput + +func (ActionsRepositoryOidcSubjectClaimCustomizationTemplateArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsRepositoryOidcSubjectClaimCustomizationTemplate)(nil)).Elem() +} + +func (i ActionsRepositoryOidcSubjectClaimCustomizationTemplateArray) ToActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput() ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput { + return i.ToActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutputWithContext(context.Background()) +} + +func (i ActionsRepositoryOidcSubjectClaimCustomizationTemplateArray) ToActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutputWithContext(ctx context.Context) ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput) +} + +// ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapInput is an input type that accepts ActionsRepositoryOidcSubjectClaimCustomizationTemplateMap and ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput values. +// You can construct a concrete instance of `ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapInput` via: +// +// ActionsRepositoryOidcSubjectClaimCustomizationTemplateMap{ "key": ActionsRepositoryOidcSubjectClaimCustomizationTemplateArgs{...} } +type ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapInput interface { + pulumi.Input + + ToActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput() ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput + ToActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutputWithContext(context.Context) ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput +} + +type ActionsRepositoryOidcSubjectClaimCustomizationTemplateMap map[string]ActionsRepositoryOidcSubjectClaimCustomizationTemplateInput + +func (ActionsRepositoryOidcSubjectClaimCustomizationTemplateMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsRepositoryOidcSubjectClaimCustomizationTemplate)(nil)).Elem() +} + +func (i ActionsRepositoryOidcSubjectClaimCustomizationTemplateMap) ToActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput() ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput { + return i.ToActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutputWithContext(context.Background()) +} + +func (i ActionsRepositoryOidcSubjectClaimCustomizationTemplateMap) ToActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutputWithContext(ctx context.Context) ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput) +} + +type ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput struct{ *pulumi.OutputState } + +func (ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsRepositoryOidcSubjectClaimCustomizationTemplate)(nil)).Elem() +} + +func (o ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput) ToActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput() ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput { + return o +} + +func (o ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput) ToActionsRepositoryOidcSubjectClaimCustomizationTemplateOutputWithContext(ctx context.Context) ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput { + return o +} + +// A list of OpenID Connect claims. +func (o ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput) IncludeClaimKeys() pulumi.StringArrayOutput { + return o.ApplyT(func(v *ActionsRepositoryOidcSubjectClaimCustomizationTemplate) pulumi.StringArrayOutput { + return v.IncludeClaimKeys + }).(pulumi.StringArrayOutput) +} + +// The name of the repository. +func (o ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsRepositoryOidcSubjectClaimCustomizationTemplate) pulumi.StringOutput { + return v.Repository + }).(pulumi.StringOutput) +} + +// Whether to use the default template or not. If `true`, `includeClaimKeys` must not +// be set. +func (o ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput) UseDefault() pulumi.BoolOutput { + return o.ApplyT(func(v *ActionsRepositoryOidcSubjectClaimCustomizationTemplate) pulumi.BoolOutput { return v.UseDefault }).(pulumi.BoolOutput) +} + +type ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput struct{ *pulumi.OutputState } + +func (ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsRepositoryOidcSubjectClaimCustomizationTemplate)(nil)).Elem() +} + +func (o ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput) ToActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput() ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput { + return o +} + +func (o ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput) ToActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutputWithContext(ctx context.Context) ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput { + return o +} + +func (o ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput) Index(i pulumi.IntInput) ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsRepositoryOidcSubjectClaimCustomizationTemplate { + return vs[0].([]*ActionsRepositoryOidcSubjectClaimCustomizationTemplate)[vs[1].(int)] + }).(ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput) +} + +type ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput struct{ *pulumi.OutputState } + +func (ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsRepositoryOidcSubjectClaimCustomizationTemplate)(nil)).Elem() +} + +func (o ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput) ToActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput() ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput { + return o +} + +func (o ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput) ToActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutputWithContext(ctx context.Context) ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput { + return o +} + +func (o ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput) MapIndex(k pulumi.StringInput) ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsRepositoryOidcSubjectClaimCustomizationTemplate { + return vs[0].(map[string]*ActionsRepositoryOidcSubjectClaimCustomizationTemplate)[vs[1].(string)] + }).(ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsRepositoryOidcSubjectClaimCustomizationTemplateInput)(nil)).Elem(), &ActionsRepositoryOidcSubjectClaimCustomizationTemplate{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayInput)(nil)).Elem(), ActionsRepositoryOidcSubjectClaimCustomizationTemplateArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapInput)(nil)).Elem(), ActionsRepositoryOidcSubjectClaimCustomizationTemplateMap{}) + pulumi.RegisterOutputType(ActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput{}) + pulumi.RegisterOutputType(ActionsRepositoryOidcSubjectClaimCustomizationTemplateArrayOutput{}) + pulumi.RegisterOutputType(ActionsRepositoryOidcSubjectClaimCustomizationTemplateMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsRepositoryPermissions.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsRepositoryPermissions.go new file mode 100644 index 000000000..5265f821d --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsRepositoryPermissions.go @@ -0,0 +1,331 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to enable and manage GitHub Actions permissions for a given repository. +// You must have admin access to an repository to use this resource. +// +// ## Example Usage +// +// ```go +// 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.NewActionsRepositoryPermissions(ctx, "test", &github.ActionsRepositoryPermissionsArgs{ +// AllowedActions: pulumi.String("selected"), +// AllowedActionsConfig: &github.ActionsRepositoryPermissionsAllowedActionsConfigArgs{ +// GithubOwnedAllowed: pulumi.Bool(true), +// PatternsAlloweds: pulumi.StringArray{ +// pulumi.String("actions/cache@*"), +// pulumi.String("actions/checkout@*"), +// }, +// VerifiedAllowed: pulumi.Bool(true), +// }, +// Repository: example.Name, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using the name of the GitHub repository: +// +// ```sh +// $ pulumi import github:index/actionsRepositoryPermissions:ActionsRepositoryPermissions test my-repository +// ``` +type ActionsRepositoryPermissions struct { + pulumi.CustomResourceState + + // The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. + AllowedActions pulumi.StringPtrOutput `pulumi:"allowedActions"` + // Sets the actions that are allowed in an repository. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. + AllowedActionsConfig ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput `pulumi:"allowedActionsConfig"` + // Should GitHub actions be enabled on this repository? + Enabled pulumi.BoolPtrOutput `pulumi:"enabled"` + // The GitHub repository + Repository pulumi.StringOutput `pulumi:"repository"` + // Whether pinning to a specific SHA is required for all actions and reusable workflows in the repository. + ShaPinningRequired pulumi.BoolOutput `pulumi:"shaPinningRequired"` +} + +// NewActionsRepositoryPermissions registers a new resource with the given unique name, arguments, and options. +func NewActionsRepositoryPermissions(ctx *pulumi.Context, + name string, args *ActionsRepositoryPermissionsArgs, opts ...pulumi.ResourceOption) (*ActionsRepositoryPermissions, 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'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsRepositoryPermissions + err := ctx.RegisterResource("github:index/actionsRepositoryPermissions:ActionsRepositoryPermissions", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsRepositoryPermissions gets an existing ActionsRepositoryPermissions 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 GetActionsRepositoryPermissions(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsRepositoryPermissionsState, opts ...pulumi.ResourceOption) (*ActionsRepositoryPermissions, error) { + var resource ActionsRepositoryPermissions + err := ctx.ReadResource("github:index/actionsRepositoryPermissions:ActionsRepositoryPermissions", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsRepositoryPermissions resources. +type actionsRepositoryPermissionsState struct { + // The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. + AllowedActions *string `pulumi:"allowedActions"` + // Sets the actions that are allowed in an repository. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. + AllowedActionsConfig *ActionsRepositoryPermissionsAllowedActionsConfig `pulumi:"allowedActionsConfig"` + // Should GitHub actions be enabled on this repository? + Enabled *bool `pulumi:"enabled"` + // The GitHub repository + Repository *string `pulumi:"repository"` + // Whether pinning to a specific SHA is required for all actions and reusable workflows in the repository. + ShaPinningRequired *bool `pulumi:"shaPinningRequired"` +} + +type ActionsRepositoryPermissionsState struct { + // The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. + AllowedActions pulumi.StringPtrInput + // Sets the actions that are allowed in an repository. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. + AllowedActionsConfig ActionsRepositoryPermissionsAllowedActionsConfigPtrInput + // Should GitHub actions be enabled on this repository? + Enabled pulumi.BoolPtrInput + // The GitHub repository + Repository pulumi.StringPtrInput + // Whether pinning to a specific SHA is required for all actions and reusable workflows in the repository. + ShaPinningRequired pulumi.BoolPtrInput +} + +func (ActionsRepositoryPermissionsState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsRepositoryPermissionsState)(nil)).Elem() +} + +type actionsRepositoryPermissionsArgs struct { + // The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. + AllowedActions *string `pulumi:"allowedActions"` + // Sets the actions that are allowed in an repository. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. + AllowedActionsConfig *ActionsRepositoryPermissionsAllowedActionsConfig `pulumi:"allowedActionsConfig"` + // Should GitHub actions be enabled on this repository? + Enabled *bool `pulumi:"enabled"` + // The GitHub repository + Repository string `pulumi:"repository"` + // Whether pinning to a specific SHA is required for all actions and reusable workflows in the repository. + ShaPinningRequired *bool `pulumi:"shaPinningRequired"` +} + +// The set of arguments for constructing a ActionsRepositoryPermissions resource. +type ActionsRepositoryPermissionsArgs struct { + // The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. + AllowedActions pulumi.StringPtrInput + // Sets the actions that are allowed in an repository. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. + AllowedActionsConfig ActionsRepositoryPermissionsAllowedActionsConfigPtrInput + // Should GitHub actions be enabled on this repository? + Enabled pulumi.BoolPtrInput + // The GitHub repository + Repository pulumi.StringInput + // Whether pinning to a specific SHA is required for all actions and reusable workflows in the repository. + ShaPinningRequired pulumi.BoolPtrInput +} + +func (ActionsRepositoryPermissionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsRepositoryPermissionsArgs)(nil)).Elem() +} + +type ActionsRepositoryPermissionsInput interface { + pulumi.Input + + ToActionsRepositoryPermissionsOutput() ActionsRepositoryPermissionsOutput + ToActionsRepositoryPermissionsOutputWithContext(ctx context.Context) ActionsRepositoryPermissionsOutput +} + +func (*ActionsRepositoryPermissions) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsRepositoryPermissions)(nil)).Elem() +} + +func (i *ActionsRepositoryPermissions) ToActionsRepositoryPermissionsOutput() ActionsRepositoryPermissionsOutput { + return i.ToActionsRepositoryPermissionsOutputWithContext(context.Background()) +} + +func (i *ActionsRepositoryPermissions) ToActionsRepositoryPermissionsOutputWithContext(ctx context.Context) ActionsRepositoryPermissionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsRepositoryPermissionsOutput) +} + +// ActionsRepositoryPermissionsArrayInput is an input type that accepts ActionsRepositoryPermissionsArray and ActionsRepositoryPermissionsArrayOutput values. +// You can construct a concrete instance of `ActionsRepositoryPermissionsArrayInput` via: +// +// ActionsRepositoryPermissionsArray{ ActionsRepositoryPermissionsArgs{...} } +type ActionsRepositoryPermissionsArrayInput interface { + pulumi.Input + + ToActionsRepositoryPermissionsArrayOutput() ActionsRepositoryPermissionsArrayOutput + ToActionsRepositoryPermissionsArrayOutputWithContext(context.Context) ActionsRepositoryPermissionsArrayOutput +} + +type ActionsRepositoryPermissionsArray []ActionsRepositoryPermissionsInput + +func (ActionsRepositoryPermissionsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsRepositoryPermissions)(nil)).Elem() +} + +func (i ActionsRepositoryPermissionsArray) ToActionsRepositoryPermissionsArrayOutput() ActionsRepositoryPermissionsArrayOutput { + return i.ToActionsRepositoryPermissionsArrayOutputWithContext(context.Background()) +} + +func (i ActionsRepositoryPermissionsArray) ToActionsRepositoryPermissionsArrayOutputWithContext(ctx context.Context) ActionsRepositoryPermissionsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsRepositoryPermissionsArrayOutput) +} + +// ActionsRepositoryPermissionsMapInput is an input type that accepts ActionsRepositoryPermissionsMap and ActionsRepositoryPermissionsMapOutput values. +// You can construct a concrete instance of `ActionsRepositoryPermissionsMapInput` via: +// +// ActionsRepositoryPermissionsMap{ "key": ActionsRepositoryPermissionsArgs{...} } +type ActionsRepositoryPermissionsMapInput interface { + pulumi.Input + + ToActionsRepositoryPermissionsMapOutput() ActionsRepositoryPermissionsMapOutput + ToActionsRepositoryPermissionsMapOutputWithContext(context.Context) ActionsRepositoryPermissionsMapOutput +} + +type ActionsRepositoryPermissionsMap map[string]ActionsRepositoryPermissionsInput + +func (ActionsRepositoryPermissionsMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsRepositoryPermissions)(nil)).Elem() +} + +func (i ActionsRepositoryPermissionsMap) ToActionsRepositoryPermissionsMapOutput() ActionsRepositoryPermissionsMapOutput { + return i.ToActionsRepositoryPermissionsMapOutputWithContext(context.Background()) +} + +func (i ActionsRepositoryPermissionsMap) ToActionsRepositoryPermissionsMapOutputWithContext(ctx context.Context) ActionsRepositoryPermissionsMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsRepositoryPermissionsMapOutput) +} + +type ActionsRepositoryPermissionsOutput struct{ *pulumi.OutputState } + +func (ActionsRepositoryPermissionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsRepositoryPermissions)(nil)).Elem() +} + +func (o ActionsRepositoryPermissionsOutput) ToActionsRepositoryPermissionsOutput() ActionsRepositoryPermissionsOutput { + return o +} + +func (o ActionsRepositoryPermissionsOutput) ToActionsRepositoryPermissionsOutputWithContext(ctx context.Context) ActionsRepositoryPermissionsOutput { + return o +} + +// The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. +func (o ActionsRepositoryPermissionsOutput) AllowedActions() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsRepositoryPermissions) pulumi.StringPtrOutput { return v.AllowedActions }).(pulumi.StringPtrOutput) +} + +// Sets the actions that are allowed in an repository. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. +func (o ActionsRepositoryPermissionsOutput) AllowedActionsConfig() ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput { + return o.ApplyT(func(v *ActionsRepositoryPermissions) ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput { + return v.AllowedActionsConfig + }).(ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput) +} + +// Should GitHub actions be enabled on this repository? +func (o ActionsRepositoryPermissionsOutput) Enabled() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ActionsRepositoryPermissions) pulumi.BoolPtrOutput { return v.Enabled }).(pulumi.BoolPtrOutput) +} + +// The GitHub repository +func (o ActionsRepositoryPermissionsOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsRepositoryPermissions) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// Whether pinning to a specific SHA is required for all actions and reusable workflows in the repository. +func (o ActionsRepositoryPermissionsOutput) ShaPinningRequired() pulumi.BoolOutput { + return o.ApplyT(func(v *ActionsRepositoryPermissions) pulumi.BoolOutput { return v.ShaPinningRequired }).(pulumi.BoolOutput) +} + +type ActionsRepositoryPermissionsArrayOutput struct{ *pulumi.OutputState } + +func (ActionsRepositoryPermissionsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsRepositoryPermissions)(nil)).Elem() +} + +func (o ActionsRepositoryPermissionsArrayOutput) ToActionsRepositoryPermissionsArrayOutput() ActionsRepositoryPermissionsArrayOutput { + return o +} + +func (o ActionsRepositoryPermissionsArrayOutput) ToActionsRepositoryPermissionsArrayOutputWithContext(ctx context.Context) ActionsRepositoryPermissionsArrayOutput { + return o +} + +func (o ActionsRepositoryPermissionsArrayOutput) Index(i pulumi.IntInput) ActionsRepositoryPermissionsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsRepositoryPermissions { + return vs[0].([]*ActionsRepositoryPermissions)[vs[1].(int)] + }).(ActionsRepositoryPermissionsOutput) +} + +type ActionsRepositoryPermissionsMapOutput struct{ *pulumi.OutputState } + +func (ActionsRepositoryPermissionsMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsRepositoryPermissions)(nil)).Elem() +} + +func (o ActionsRepositoryPermissionsMapOutput) ToActionsRepositoryPermissionsMapOutput() ActionsRepositoryPermissionsMapOutput { + return o +} + +func (o ActionsRepositoryPermissionsMapOutput) ToActionsRepositoryPermissionsMapOutputWithContext(ctx context.Context) ActionsRepositoryPermissionsMapOutput { + return o +} + +func (o ActionsRepositoryPermissionsMapOutput) MapIndex(k pulumi.StringInput) ActionsRepositoryPermissionsOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsRepositoryPermissions { + return vs[0].(map[string]*ActionsRepositoryPermissions)[vs[1].(string)] + }).(ActionsRepositoryPermissionsOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsRepositoryPermissionsInput)(nil)).Elem(), &ActionsRepositoryPermissions{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsRepositoryPermissionsArrayInput)(nil)).Elem(), ActionsRepositoryPermissionsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsRepositoryPermissionsMapInput)(nil)).Elem(), ActionsRepositoryPermissionsMap{}) + pulumi.RegisterOutputType(ActionsRepositoryPermissionsOutput{}) + pulumi.RegisterOutputType(ActionsRepositoryPermissionsArrayOutput{}) + pulumi.RegisterOutputType(ActionsRepositoryPermissionsMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsRunnerGroup.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsRunnerGroup.go new file mode 100644 index 000000000..dc3ba843e --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsRunnerGroup.go @@ -0,0 +1,394 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage GitHub Actions runner groups within your GitHub enterprise organizations. +// You must have admin access to an organization to use this resource. +// +// ## Example Usage +// +// ```go +// 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 +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using the ID of the runner group: +// +// ```sh +// $ pulumi import github:index/actionsRunnerGroup:ActionsRunnerGroup test 7 +// ``` +type ActionsRunnerGroup struct { + pulumi.CustomResourceState + + // Whether public repositories can be added to the runner group. Defaults to false. + AllowsPublicRepositories pulumi.BoolPtrOutput `pulumi:"allowsPublicRepositories"` + // Whether this is the default runner group + Default pulumi.BoolOutput `pulumi:"default"` + // An etag representing the runner group object + Etag pulumi.StringOutput `pulumi:"etag"` + // Whether the runner group is inherited from the enterprise level + Inherited pulumi.BoolOutput `pulumi:"inherited"` + // Name of the runner group + Name pulumi.StringOutput `pulumi:"name"` + // If true, the runner group will be restricted to running only the workflows specified in the selectedWorkflows array. Defaults to false. + RestrictedToWorkflows pulumi.BoolPtrOutput `pulumi:"restrictedToWorkflows"` + // The GitHub API URL for the runner group's runners + RunnersUrl pulumi.StringOutput `pulumi:"runnersUrl"` + // GitHub API URL for the runner group's repositories + SelectedRepositoriesUrl pulumi.StringOutput `pulumi:"selectedRepositoriesUrl"` + // IDs of the repositories which should be added to the runner group + SelectedRepositoryIds pulumi.IntArrayOutput `pulumi:"selectedRepositoryIds"` + // List of workflows the runner group should be allowed to run. This setting will be ignored unless restrictedToWorkflows is set to true. + SelectedWorkflows pulumi.StringArrayOutput `pulumi:"selectedWorkflows"` + // Visibility of a runner group. Whether the runner group can include `all`, `selected`, or `private` repositories. A value of `private` is not currently supported due to limitations in the GitHub API. + Visibility pulumi.StringOutput `pulumi:"visibility"` +} + +// NewActionsRunnerGroup registers a new resource with the given unique name, arguments, and options. +func NewActionsRunnerGroup(ctx *pulumi.Context, + name string, args *ActionsRunnerGroupArgs, opts ...pulumi.ResourceOption) (*ActionsRunnerGroup, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Visibility == nil { + return nil, errors.New("invalid value for required argument 'Visibility'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsRunnerGroup + err := ctx.RegisterResource("github:index/actionsRunnerGroup:ActionsRunnerGroup", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsRunnerGroup gets an existing ActionsRunnerGroup 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 GetActionsRunnerGroup(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsRunnerGroupState, opts ...pulumi.ResourceOption) (*ActionsRunnerGroup, error) { + var resource ActionsRunnerGroup + err := ctx.ReadResource("github:index/actionsRunnerGroup:ActionsRunnerGroup", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsRunnerGroup resources. +type actionsRunnerGroupState struct { + // Whether public repositories can be added to the runner group. Defaults to false. + AllowsPublicRepositories *bool `pulumi:"allowsPublicRepositories"` + // Whether this is the default runner group + Default *bool `pulumi:"default"` + // An etag representing the runner group object + Etag *string `pulumi:"etag"` + // Whether the runner group is inherited from the enterprise level + Inherited *bool `pulumi:"inherited"` + // Name of the runner group + Name *string `pulumi:"name"` + // If true, the runner group will be restricted to running only the workflows specified in the selectedWorkflows array. Defaults to false. + RestrictedToWorkflows *bool `pulumi:"restrictedToWorkflows"` + // The GitHub API URL for the runner group's runners + RunnersUrl *string `pulumi:"runnersUrl"` + // GitHub API URL for the runner group's repositories + SelectedRepositoriesUrl *string `pulumi:"selectedRepositoriesUrl"` + // IDs of the repositories which should be added to the runner group + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` + // List of workflows the runner group should be allowed to run. This setting will be ignored unless restrictedToWorkflows is set to true. + SelectedWorkflows []string `pulumi:"selectedWorkflows"` + // Visibility of a runner group. Whether the runner group can include `all`, `selected`, or `private` repositories. A value of `private` is not currently supported due to limitations in the GitHub API. + Visibility *string `pulumi:"visibility"` +} + +type ActionsRunnerGroupState struct { + // Whether public repositories can be added to the runner group. Defaults to false. + AllowsPublicRepositories pulumi.BoolPtrInput + // Whether this is the default runner group + Default pulumi.BoolPtrInput + // An etag representing the runner group object + Etag pulumi.StringPtrInput + // Whether the runner group is inherited from the enterprise level + Inherited pulumi.BoolPtrInput + // Name of the runner group + Name pulumi.StringPtrInput + // If true, the runner group will be restricted to running only the workflows specified in the selectedWorkflows array. Defaults to false. + RestrictedToWorkflows pulumi.BoolPtrInput + // The GitHub API URL for the runner group's runners + RunnersUrl pulumi.StringPtrInput + // GitHub API URL for the runner group's repositories + SelectedRepositoriesUrl pulumi.StringPtrInput + // IDs of the repositories which should be added to the runner group + SelectedRepositoryIds pulumi.IntArrayInput + // List of workflows the runner group should be allowed to run. This setting will be ignored unless restrictedToWorkflows is set to true. + SelectedWorkflows pulumi.StringArrayInput + // Visibility of a runner group. Whether the runner group can include `all`, `selected`, or `private` repositories. A value of `private` is not currently supported due to limitations in the GitHub API. + Visibility pulumi.StringPtrInput +} + +func (ActionsRunnerGroupState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsRunnerGroupState)(nil)).Elem() +} + +type actionsRunnerGroupArgs struct { + // Whether public repositories can be added to the runner group. Defaults to false. + AllowsPublicRepositories *bool `pulumi:"allowsPublicRepositories"` + // Name of the runner group + Name *string `pulumi:"name"` + // If true, the runner group will be restricted to running only the workflows specified in the selectedWorkflows array. Defaults to false. + RestrictedToWorkflows *bool `pulumi:"restrictedToWorkflows"` + // IDs of the repositories which should be added to the runner group + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` + // List of workflows the runner group should be allowed to run. This setting will be ignored unless restrictedToWorkflows is set to true. + SelectedWorkflows []string `pulumi:"selectedWorkflows"` + // Visibility of a runner group. Whether the runner group can include `all`, `selected`, or `private` repositories. A value of `private` is not currently supported due to limitations in the GitHub API. + Visibility string `pulumi:"visibility"` +} + +// The set of arguments for constructing a ActionsRunnerGroup resource. +type ActionsRunnerGroupArgs struct { + // Whether public repositories can be added to the runner group. Defaults to false. + AllowsPublicRepositories pulumi.BoolPtrInput + // Name of the runner group + Name pulumi.StringPtrInput + // If true, the runner group will be restricted to running only the workflows specified in the selectedWorkflows array. Defaults to false. + RestrictedToWorkflows pulumi.BoolPtrInput + // IDs of the repositories which should be added to the runner group + SelectedRepositoryIds pulumi.IntArrayInput + // List of workflows the runner group should be allowed to run. This setting will be ignored unless restrictedToWorkflows is set to true. + SelectedWorkflows pulumi.StringArrayInput + // Visibility of a runner group. Whether the runner group can include `all`, `selected`, or `private` repositories. A value of `private` is not currently supported due to limitations in the GitHub API. + Visibility pulumi.StringInput +} + +func (ActionsRunnerGroupArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsRunnerGroupArgs)(nil)).Elem() +} + +type ActionsRunnerGroupInput interface { + pulumi.Input + + ToActionsRunnerGroupOutput() ActionsRunnerGroupOutput + ToActionsRunnerGroupOutputWithContext(ctx context.Context) ActionsRunnerGroupOutput +} + +func (*ActionsRunnerGroup) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsRunnerGroup)(nil)).Elem() +} + +func (i *ActionsRunnerGroup) ToActionsRunnerGroupOutput() ActionsRunnerGroupOutput { + return i.ToActionsRunnerGroupOutputWithContext(context.Background()) +} + +func (i *ActionsRunnerGroup) ToActionsRunnerGroupOutputWithContext(ctx context.Context) ActionsRunnerGroupOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsRunnerGroupOutput) +} + +// ActionsRunnerGroupArrayInput is an input type that accepts ActionsRunnerGroupArray and ActionsRunnerGroupArrayOutput values. +// You can construct a concrete instance of `ActionsRunnerGroupArrayInput` via: +// +// ActionsRunnerGroupArray{ ActionsRunnerGroupArgs{...} } +type ActionsRunnerGroupArrayInput interface { + pulumi.Input + + ToActionsRunnerGroupArrayOutput() ActionsRunnerGroupArrayOutput + ToActionsRunnerGroupArrayOutputWithContext(context.Context) ActionsRunnerGroupArrayOutput +} + +type ActionsRunnerGroupArray []ActionsRunnerGroupInput + +func (ActionsRunnerGroupArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsRunnerGroup)(nil)).Elem() +} + +func (i ActionsRunnerGroupArray) ToActionsRunnerGroupArrayOutput() ActionsRunnerGroupArrayOutput { + return i.ToActionsRunnerGroupArrayOutputWithContext(context.Background()) +} + +func (i ActionsRunnerGroupArray) ToActionsRunnerGroupArrayOutputWithContext(ctx context.Context) ActionsRunnerGroupArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsRunnerGroupArrayOutput) +} + +// ActionsRunnerGroupMapInput is an input type that accepts ActionsRunnerGroupMap and ActionsRunnerGroupMapOutput values. +// You can construct a concrete instance of `ActionsRunnerGroupMapInput` via: +// +// ActionsRunnerGroupMap{ "key": ActionsRunnerGroupArgs{...} } +type ActionsRunnerGroupMapInput interface { + pulumi.Input + + ToActionsRunnerGroupMapOutput() ActionsRunnerGroupMapOutput + ToActionsRunnerGroupMapOutputWithContext(context.Context) ActionsRunnerGroupMapOutput +} + +type ActionsRunnerGroupMap map[string]ActionsRunnerGroupInput + +func (ActionsRunnerGroupMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsRunnerGroup)(nil)).Elem() +} + +func (i ActionsRunnerGroupMap) ToActionsRunnerGroupMapOutput() ActionsRunnerGroupMapOutput { + return i.ToActionsRunnerGroupMapOutputWithContext(context.Background()) +} + +func (i ActionsRunnerGroupMap) ToActionsRunnerGroupMapOutputWithContext(ctx context.Context) ActionsRunnerGroupMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsRunnerGroupMapOutput) +} + +type ActionsRunnerGroupOutput struct{ *pulumi.OutputState } + +func (ActionsRunnerGroupOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsRunnerGroup)(nil)).Elem() +} + +func (o ActionsRunnerGroupOutput) ToActionsRunnerGroupOutput() ActionsRunnerGroupOutput { + return o +} + +func (o ActionsRunnerGroupOutput) ToActionsRunnerGroupOutputWithContext(ctx context.Context) ActionsRunnerGroupOutput { + return o +} + +// Whether public repositories can be added to the runner group. Defaults to false. +func (o ActionsRunnerGroupOutput) AllowsPublicRepositories() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ActionsRunnerGroup) pulumi.BoolPtrOutput { return v.AllowsPublicRepositories }).(pulumi.BoolPtrOutput) +} + +// Whether this is the default runner group +func (o ActionsRunnerGroupOutput) Default() pulumi.BoolOutput { + return o.ApplyT(func(v *ActionsRunnerGroup) pulumi.BoolOutput { return v.Default }).(pulumi.BoolOutput) +} + +// An etag representing the runner group object +func (o ActionsRunnerGroupOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsRunnerGroup) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// Whether the runner group is inherited from the enterprise level +func (o ActionsRunnerGroupOutput) Inherited() pulumi.BoolOutput { + return o.ApplyT(func(v *ActionsRunnerGroup) pulumi.BoolOutput { return v.Inherited }).(pulumi.BoolOutput) +} + +// Name of the runner group +func (o ActionsRunnerGroupOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsRunnerGroup) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// If true, the runner group will be restricted to running only the workflows specified in the selectedWorkflows array. Defaults to false. +func (o ActionsRunnerGroupOutput) RestrictedToWorkflows() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ActionsRunnerGroup) pulumi.BoolPtrOutput { return v.RestrictedToWorkflows }).(pulumi.BoolPtrOutput) +} + +// The GitHub API URL for the runner group's runners +func (o ActionsRunnerGroupOutput) RunnersUrl() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsRunnerGroup) pulumi.StringOutput { return v.RunnersUrl }).(pulumi.StringOutput) +} + +// GitHub API URL for the runner group's repositories +func (o ActionsRunnerGroupOutput) SelectedRepositoriesUrl() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsRunnerGroup) pulumi.StringOutput { return v.SelectedRepositoriesUrl }).(pulumi.StringOutput) +} + +// IDs of the repositories which should be added to the runner group +func (o ActionsRunnerGroupOutput) SelectedRepositoryIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v *ActionsRunnerGroup) pulumi.IntArrayOutput { return v.SelectedRepositoryIds }).(pulumi.IntArrayOutput) +} + +// List of workflows the runner group should be allowed to run. This setting will be ignored unless restrictedToWorkflows is set to true. +func (o ActionsRunnerGroupOutput) SelectedWorkflows() pulumi.StringArrayOutput { + return o.ApplyT(func(v *ActionsRunnerGroup) pulumi.StringArrayOutput { return v.SelectedWorkflows }).(pulumi.StringArrayOutput) +} + +// Visibility of a runner group. Whether the runner group can include `all`, `selected`, or `private` repositories. A value of `private` is not currently supported due to limitations in the GitHub API. +func (o ActionsRunnerGroupOutput) Visibility() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsRunnerGroup) pulumi.StringOutput { return v.Visibility }).(pulumi.StringOutput) +} + +type ActionsRunnerGroupArrayOutput struct{ *pulumi.OutputState } + +func (ActionsRunnerGroupArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsRunnerGroup)(nil)).Elem() +} + +func (o ActionsRunnerGroupArrayOutput) ToActionsRunnerGroupArrayOutput() ActionsRunnerGroupArrayOutput { + return o +} + +func (o ActionsRunnerGroupArrayOutput) ToActionsRunnerGroupArrayOutputWithContext(ctx context.Context) ActionsRunnerGroupArrayOutput { + return o +} + +func (o ActionsRunnerGroupArrayOutput) Index(i pulumi.IntInput) ActionsRunnerGroupOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsRunnerGroup { + return vs[0].([]*ActionsRunnerGroup)[vs[1].(int)] + }).(ActionsRunnerGroupOutput) +} + +type ActionsRunnerGroupMapOutput struct{ *pulumi.OutputState } + +func (ActionsRunnerGroupMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsRunnerGroup)(nil)).Elem() +} + +func (o ActionsRunnerGroupMapOutput) ToActionsRunnerGroupMapOutput() ActionsRunnerGroupMapOutput { + return o +} + +func (o ActionsRunnerGroupMapOutput) ToActionsRunnerGroupMapOutputWithContext(ctx context.Context) ActionsRunnerGroupMapOutput { + return o +} + +func (o ActionsRunnerGroupMapOutput) MapIndex(k pulumi.StringInput) ActionsRunnerGroupOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsRunnerGroup { + return vs[0].(map[string]*ActionsRunnerGroup)[vs[1].(string)] + }).(ActionsRunnerGroupOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsRunnerGroupInput)(nil)).Elem(), &ActionsRunnerGroup{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsRunnerGroupArrayInput)(nil)).Elem(), ActionsRunnerGroupArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsRunnerGroupMapInput)(nil)).Elem(), ActionsRunnerGroupMap{}) + pulumi.RegisterOutputType(ActionsRunnerGroupOutput{}) + pulumi.RegisterOutputType(ActionsRunnerGroupArrayOutput{}) + pulumi.RegisterOutputType(ActionsRunnerGroupMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsSecret.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsSecret.go new file mode 100644 index 000000000..4b053fc8f --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsSecret.go @@ -0,0 +1,528 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage GitHub Actions secrets within your GitHub repositories. +// You must have write access to a repository to use this resource. +// +// Secret values are encrypted using the [Go '/crypto/box' module](https://godoc.org/golang.org/x/crypto/nacl/box) which is +// interoperable with [libsodium](https://libsodium.gitbook.io/doc/). Libsodium is used by GitHub to decrypt secret values. +// +// For the purposes of security, the contents of the `value` field have been marked as `sensitive` to Terraform, +// but it is important to note that **this does not hide it from state files**. You should treat state as sensitive always. +// It is also advised that you do not store plaintext values in your code but rather populate the `valueEncrypted` +// using fields from a resource, data source or variable as, while encrypted in state, these will be easily accessible +// in your code. See below for an example of this abstraction. +// +// ## Example Usage +// +// ```go +// 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.NewActionsSecret(ctx, "example_plaintext", &github.ActionsSecretArgs{ +// Repository: pulumi.String("example_repository"), +// SecretName: pulumi.String("example_secret_name"), +// Value: pulumi.Any(someSecretString), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewActionsSecret(ctx, "example_encrypted", &github.ActionsSecretArgs{ +// Repository: pulumi.String("example_repository"), +// SecretName: pulumi.String("example_secret_name"), +// ValueEncrypted: pulumi.Any(someEncryptedSecretString), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Example Lifecycle Ignore Changes +// +// This resource supports using the `lifecycle` `ignoreChanges` block on `remoteUpdatedAt` to support use cases where a secret value is created using a placeholder value and then modified after creation outside the scope of Terraform. This approach ensures only the initial placeholder value is referenced in your code and in the resulting state file. +// +// ```go +// 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.NewActionsSecret(ctx, "example_allow_drift", &github.ActionsSecretArgs{ +// Repository: pulumi.String("example_repository"), +// SecretName: pulumi.String("example_secret_name"), +// Value: pulumi.String("placeholder"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using an ID made of the repository name, and secret name separated by a `:`. +// +// > **Note**: When importing secrets, the `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` fields will not be populated in the state. You may need to ignore changes for these as a workaround if you're not planning on updating the secret through Terraform. +// +// ### Import Command +// +// The following command imports a GitHub actions secret named `mysecret` for the repo `myrepo` to a `ActionsSecret` resource named `example`. +// +// ```sh +// $ pulumi import github:index/actionsSecret:ActionsSecret example myrepo:mysecret +// ``` +type ActionsSecret struct { + pulumi.CustomResourceState + + // Date the secret was created. + CreatedAt pulumi.StringOutput `pulumi:"createdAt"` + // (Optional) This is ignored as drift detection is built into the resource. + // + // > **Note**: One of either `encryptedValue` or `plaintextValue` must be specified. + // + // Deprecated: This is no longer required and will be removed in a future release. Drift detection is now always performed, and external changes will result in the secret being updated to match the Terraform configuration. If you want to ignore external changes, you can use the `lifecycle` block with `ignoreChanges` on the `remoteUpdatedAt` field. + DestroyOnDrift pulumi.BoolPtrOutput `pulumi:"destroyOnDrift"` + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue pulumi.StringPtrOutput `pulumi:"encryptedValue"` + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId pulumi.StringOutput `pulumi:"keyId"` + // (Optional) Please use `value`. + // + // Deprecated: Use value. + PlaintextValue pulumi.StringPtrOutput `pulumi:"plaintextValue"` + // Date the secret was last updated in GitHub. + RemoteUpdatedAt pulumi.StringOutput `pulumi:"remoteUpdatedAt"` + // Name of the repository. + Repository pulumi.StringOutput `pulumi:"repository"` + // ID of the repository. + RepositoryId pulumi.IntOutput `pulumi:"repositoryId"` + // Name of the secret. + SecretName pulumi.StringOutput `pulumi:"secretName"` + // Date the secret was last updated by the provider. + UpdatedAt pulumi.StringOutput `pulumi:"updatedAt"` + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value pulumi.StringPtrOutput `pulumi:"value"` + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted pulumi.StringPtrOutput `pulumi:"valueEncrypted"` +} + +// NewActionsSecret registers a new resource with the given unique name, arguments, and options. +func NewActionsSecret(ctx *pulumi.Context, + name string, args *ActionsSecretArgs, opts ...pulumi.ResourceOption) (*ActionsSecret, 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.SecretName == nil { + return nil, errors.New("invalid value for required argument 'SecretName'") + } + if args.EncryptedValue != nil { + args.EncryptedValue = pulumi.ToSecret(args.EncryptedValue).(pulumi.StringPtrInput) + } + if args.PlaintextValue != nil { + args.PlaintextValue = pulumi.ToSecret(args.PlaintextValue).(pulumi.StringPtrInput) + } + if args.Value != nil { + args.Value = pulumi.ToSecret(args.Value).(pulumi.StringPtrInput) + } + if args.ValueEncrypted != nil { + args.ValueEncrypted = pulumi.ToSecret(args.ValueEncrypted).(pulumi.StringPtrInput) + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "encryptedValue", + "plaintextValue", + "value", + "valueEncrypted", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsSecret + err := ctx.RegisterResource("github:index/actionsSecret:ActionsSecret", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsSecret gets an existing ActionsSecret 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 GetActionsSecret(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsSecretState, opts ...pulumi.ResourceOption) (*ActionsSecret, error) { + var resource ActionsSecret + err := ctx.ReadResource("github:index/actionsSecret:ActionsSecret", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsSecret resources. +type actionsSecretState struct { + // Date the secret was created. + CreatedAt *string `pulumi:"createdAt"` + // (Optional) This is ignored as drift detection is built into the resource. + // + // > **Note**: One of either `encryptedValue` or `plaintextValue` must be specified. + // + // Deprecated: This is no longer required and will be removed in a future release. Drift detection is now always performed, and external changes will result in the secret being updated to match the Terraform configuration. If you want to ignore external changes, you can use the `lifecycle` block with `ignoreChanges` on the `remoteUpdatedAt` field. + DestroyOnDrift *bool `pulumi:"destroyOnDrift"` + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue *string `pulumi:"encryptedValue"` + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId *string `pulumi:"keyId"` + // (Optional) Please use `value`. + // + // Deprecated: Use value. + PlaintextValue *string `pulumi:"plaintextValue"` + // Date the secret was last updated in GitHub. + RemoteUpdatedAt *string `pulumi:"remoteUpdatedAt"` + // Name of the repository. + Repository *string `pulumi:"repository"` + // ID of the repository. + RepositoryId *int `pulumi:"repositoryId"` + // Name of the secret. + SecretName *string `pulumi:"secretName"` + // Date the secret was last updated by the provider. + UpdatedAt *string `pulumi:"updatedAt"` + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value *string `pulumi:"value"` + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted *string `pulumi:"valueEncrypted"` +} + +type ActionsSecretState struct { + // Date the secret was created. + CreatedAt pulumi.StringPtrInput + // (Optional) This is ignored as drift detection is built into the resource. + // + // > **Note**: One of either `encryptedValue` or `plaintextValue` must be specified. + // + // Deprecated: This is no longer required and will be removed in a future release. Drift detection is now always performed, and external changes will result in the secret being updated to match the Terraform configuration. If you want to ignore external changes, you can use the `lifecycle` block with `ignoreChanges` on the `remoteUpdatedAt` field. + DestroyOnDrift pulumi.BoolPtrInput + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue pulumi.StringPtrInput + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId pulumi.StringPtrInput + // (Optional) Please use `value`. + // + // Deprecated: Use value. + PlaintextValue pulumi.StringPtrInput + // Date the secret was last updated in GitHub. + RemoteUpdatedAt pulumi.StringPtrInput + // Name of the repository. + Repository pulumi.StringPtrInput + // ID of the repository. + RepositoryId pulumi.IntPtrInput + // Name of the secret. + SecretName pulumi.StringPtrInput + // Date the secret was last updated by the provider. + UpdatedAt pulumi.StringPtrInput + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value pulumi.StringPtrInput + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted pulumi.StringPtrInput +} + +func (ActionsSecretState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsSecretState)(nil)).Elem() +} + +type actionsSecretArgs struct { + // (Optional) This is ignored as drift detection is built into the resource. + // + // > **Note**: One of either `encryptedValue` or `plaintextValue` must be specified. + // + // Deprecated: This is no longer required and will be removed in a future release. Drift detection is now always performed, and external changes will result in the secret being updated to match the Terraform configuration. If you want to ignore external changes, you can use the `lifecycle` block with `ignoreChanges` on the `remoteUpdatedAt` field. + DestroyOnDrift *bool `pulumi:"destroyOnDrift"` + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue *string `pulumi:"encryptedValue"` + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId *string `pulumi:"keyId"` + // (Optional) Please use `value`. + // + // Deprecated: Use value. + PlaintextValue *string `pulumi:"plaintextValue"` + // Name of the repository. + Repository string `pulumi:"repository"` + // Name of the secret. + SecretName string `pulumi:"secretName"` + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value *string `pulumi:"value"` + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted *string `pulumi:"valueEncrypted"` +} + +// The set of arguments for constructing a ActionsSecret resource. +type ActionsSecretArgs struct { + // (Optional) This is ignored as drift detection is built into the resource. + // + // > **Note**: One of either `encryptedValue` or `plaintextValue` must be specified. + // + // Deprecated: This is no longer required and will be removed in a future release. Drift detection is now always performed, and external changes will result in the secret being updated to match the Terraform configuration. If you want to ignore external changes, you can use the `lifecycle` block with `ignoreChanges` on the `remoteUpdatedAt` field. + DestroyOnDrift pulumi.BoolPtrInput + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue pulumi.StringPtrInput + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId pulumi.StringPtrInput + // (Optional) Please use `value`. + // + // Deprecated: Use value. + PlaintextValue pulumi.StringPtrInput + // Name of the repository. + Repository pulumi.StringInput + // Name of the secret. + SecretName pulumi.StringInput + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value pulumi.StringPtrInput + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted pulumi.StringPtrInput +} + +func (ActionsSecretArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsSecretArgs)(nil)).Elem() +} + +type ActionsSecretInput interface { + pulumi.Input + + ToActionsSecretOutput() ActionsSecretOutput + ToActionsSecretOutputWithContext(ctx context.Context) ActionsSecretOutput +} + +func (*ActionsSecret) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsSecret)(nil)).Elem() +} + +func (i *ActionsSecret) ToActionsSecretOutput() ActionsSecretOutput { + return i.ToActionsSecretOutputWithContext(context.Background()) +} + +func (i *ActionsSecret) ToActionsSecretOutputWithContext(ctx context.Context) ActionsSecretOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsSecretOutput) +} + +// ActionsSecretArrayInput is an input type that accepts ActionsSecretArray and ActionsSecretArrayOutput values. +// You can construct a concrete instance of `ActionsSecretArrayInput` via: +// +// ActionsSecretArray{ ActionsSecretArgs{...} } +type ActionsSecretArrayInput interface { + pulumi.Input + + ToActionsSecretArrayOutput() ActionsSecretArrayOutput + ToActionsSecretArrayOutputWithContext(context.Context) ActionsSecretArrayOutput +} + +type ActionsSecretArray []ActionsSecretInput + +func (ActionsSecretArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsSecret)(nil)).Elem() +} + +func (i ActionsSecretArray) ToActionsSecretArrayOutput() ActionsSecretArrayOutput { + return i.ToActionsSecretArrayOutputWithContext(context.Background()) +} + +func (i ActionsSecretArray) ToActionsSecretArrayOutputWithContext(ctx context.Context) ActionsSecretArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsSecretArrayOutput) +} + +// ActionsSecretMapInput is an input type that accepts ActionsSecretMap and ActionsSecretMapOutput values. +// You can construct a concrete instance of `ActionsSecretMapInput` via: +// +// ActionsSecretMap{ "key": ActionsSecretArgs{...} } +type ActionsSecretMapInput interface { + pulumi.Input + + ToActionsSecretMapOutput() ActionsSecretMapOutput + ToActionsSecretMapOutputWithContext(context.Context) ActionsSecretMapOutput +} + +type ActionsSecretMap map[string]ActionsSecretInput + +func (ActionsSecretMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsSecret)(nil)).Elem() +} + +func (i ActionsSecretMap) ToActionsSecretMapOutput() ActionsSecretMapOutput { + return i.ToActionsSecretMapOutputWithContext(context.Background()) +} + +func (i ActionsSecretMap) ToActionsSecretMapOutputWithContext(ctx context.Context) ActionsSecretMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsSecretMapOutput) +} + +type ActionsSecretOutput struct{ *pulumi.OutputState } + +func (ActionsSecretOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsSecret)(nil)).Elem() +} + +func (o ActionsSecretOutput) ToActionsSecretOutput() ActionsSecretOutput { + return o +} + +func (o ActionsSecretOutput) ToActionsSecretOutputWithContext(ctx context.Context) ActionsSecretOutput { + return o +} + +// Date the secret was created. +func (o ActionsSecretOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsSecret) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) +} + +// (Optional) This is ignored as drift detection is built into the resource. +// +// > **Note**: One of either `encryptedValue` or `plaintextValue` must be specified. +// +// Deprecated: This is no longer required and will be removed in a future release. Drift detection is now always performed, and external changes will result in the secret being updated to match the Terraform configuration. If you want to ignore external changes, you can use the `lifecycle` block with `ignoreChanges` on the `remoteUpdatedAt` field. +func (o ActionsSecretOutput) DestroyOnDrift() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ActionsSecret) pulumi.BoolPtrOutput { return v.DestroyOnDrift }).(pulumi.BoolPtrOutput) +} + +// (Optional) Please use `valueEncrypted`. +// +// Deprecated: Use valueEncrypted and key_id. +func (o ActionsSecretOutput) EncryptedValue() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsSecret) pulumi.StringPtrOutput { return v.EncryptedValue }).(pulumi.StringPtrOutput) +} + +// ID of the public key used to encrypt the secret, required when setting `encryptedValue`. +func (o ActionsSecretOutput) KeyId() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsSecret) pulumi.StringOutput { return v.KeyId }).(pulumi.StringOutput) +} + +// (Optional) Please use `value`. +// +// Deprecated: Use value. +func (o ActionsSecretOutput) PlaintextValue() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsSecret) pulumi.StringPtrOutput { return v.PlaintextValue }).(pulumi.StringPtrOutput) +} + +// Date the secret was last updated in GitHub. +func (o ActionsSecretOutput) RemoteUpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsSecret) pulumi.StringOutput { return v.RemoteUpdatedAt }).(pulumi.StringOutput) +} + +// Name of the repository. +func (o ActionsSecretOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsSecret) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// ID of the repository. +func (o ActionsSecretOutput) RepositoryId() pulumi.IntOutput { + return o.ApplyT(func(v *ActionsSecret) pulumi.IntOutput { return v.RepositoryId }).(pulumi.IntOutput) +} + +// Name of the secret. +func (o ActionsSecretOutput) SecretName() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsSecret) pulumi.StringOutput { return v.SecretName }).(pulumi.StringOutput) +} + +// Date the secret was last updated by the provider. +func (o ActionsSecretOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsSecret) pulumi.StringOutput { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. +func (o ActionsSecretOutput) Value() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsSecret) pulumi.StringPtrOutput { return v.Value }).(pulumi.StringPtrOutput) +} + +// Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. +func (o ActionsSecretOutput) ValueEncrypted() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsSecret) pulumi.StringPtrOutput { return v.ValueEncrypted }).(pulumi.StringPtrOutput) +} + +type ActionsSecretArrayOutput struct{ *pulumi.OutputState } + +func (ActionsSecretArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsSecret)(nil)).Elem() +} + +func (o ActionsSecretArrayOutput) ToActionsSecretArrayOutput() ActionsSecretArrayOutput { + return o +} + +func (o ActionsSecretArrayOutput) ToActionsSecretArrayOutputWithContext(ctx context.Context) ActionsSecretArrayOutput { + return o +} + +func (o ActionsSecretArrayOutput) Index(i pulumi.IntInput) ActionsSecretOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsSecret { + return vs[0].([]*ActionsSecret)[vs[1].(int)] + }).(ActionsSecretOutput) +} + +type ActionsSecretMapOutput struct{ *pulumi.OutputState } + +func (ActionsSecretMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsSecret)(nil)).Elem() +} + +func (o ActionsSecretMapOutput) ToActionsSecretMapOutput() ActionsSecretMapOutput { + return o +} + +func (o ActionsSecretMapOutput) ToActionsSecretMapOutputWithContext(ctx context.Context) ActionsSecretMapOutput { + return o +} + +func (o ActionsSecretMapOutput) MapIndex(k pulumi.StringInput) ActionsSecretOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsSecret { + return vs[0].(map[string]*ActionsSecret)[vs[1].(string)] + }).(ActionsSecretOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsSecretInput)(nil)).Elem(), &ActionsSecret{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsSecretArrayInput)(nil)).Elem(), ActionsSecretArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsSecretMapInput)(nil)).Elem(), ActionsSecretMap{}) + pulumi.RegisterOutputType(ActionsSecretOutput{}) + pulumi.RegisterOutputType(ActionsSecretArrayOutput{}) + pulumi.RegisterOutputType(ActionsSecretMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsVariable.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsVariable.go new file mode 100644 index 000000000..6fa6bed67 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/actionsVariable.go @@ -0,0 +1,329 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage GitHub Actions variables within your GitHub repositories. +// You must have write access to a repository to use this resource. +// +// ## Example Usage +// +// ```go +// 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.NewActionsVariable(ctx, "example_variable", &github.ActionsVariableArgs{ +// Repository: pulumi.String("example_repository"), +// VariableName: pulumi.String("example_variable_name"), +// Value: pulumi.String("example_variable_value"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using an ID made of the repository name, and variable name separated by a `:`. +// +// ### Import Command +// +// The following command imports a GitHub actions variable named `myvariable` for the repo `myrepo` to a `ActionsVariable` resource named `example`. +// +// ```sh +// $ pulumi import github:index/actionsVariable:ActionsVariable example myrepo:myvariable +// ``` +type ActionsVariable struct { + pulumi.CustomResourceState + + // Date the variable was created. + CreatedAt pulumi.StringOutput `pulumi:"createdAt"` + // Name of the repository. + Repository pulumi.StringOutput `pulumi:"repository"` + // ID of the repository. + RepositoryId pulumi.IntOutput `pulumi:"repositoryId"` + // Date the variable was last updated. + UpdatedAt pulumi.StringOutput `pulumi:"updatedAt"` + // Value of the variable. + Value pulumi.StringOutput `pulumi:"value"` + // Name of the variable. + VariableName pulumi.StringOutput `pulumi:"variableName"` +} + +// NewActionsVariable registers a new resource with the given unique name, arguments, and options. +func NewActionsVariable(ctx *pulumi.Context, + name string, args *ActionsVariableArgs, opts ...pulumi.ResourceOption) (*ActionsVariable, 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.Value == nil { + return nil, errors.New("invalid value for required argument 'Value'") + } + if args.VariableName == nil { + return nil, errors.New("invalid value for required argument 'VariableName'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ActionsVariable + err := ctx.RegisterResource("github:index/actionsVariable:ActionsVariable", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetActionsVariable gets an existing ActionsVariable 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 GetActionsVariable(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ActionsVariableState, opts ...pulumi.ResourceOption) (*ActionsVariable, error) { + var resource ActionsVariable + err := ctx.ReadResource("github:index/actionsVariable:ActionsVariable", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ActionsVariable resources. +type actionsVariableState struct { + // Date the variable was created. + CreatedAt *string `pulumi:"createdAt"` + // Name of the repository. + Repository *string `pulumi:"repository"` + // ID of the repository. + RepositoryId *int `pulumi:"repositoryId"` + // Date the variable was last updated. + UpdatedAt *string `pulumi:"updatedAt"` + // Value of the variable. + Value *string `pulumi:"value"` + // Name of the variable. + VariableName *string `pulumi:"variableName"` +} + +type ActionsVariableState struct { + // Date the variable was created. + CreatedAt pulumi.StringPtrInput + // Name of the repository. + Repository pulumi.StringPtrInput + // ID of the repository. + RepositoryId pulumi.IntPtrInput + // Date the variable was last updated. + UpdatedAt pulumi.StringPtrInput + // Value of the variable. + Value pulumi.StringPtrInput + // Name of the variable. + VariableName pulumi.StringPtrInput +} + +func (ActionsVariableState) ElementType() reflect.Type { + return reflect.TypeOf((*actionsVariableState)(nil)).Elem() +} + +type actionsVariableArgs struct { + // Name of the repository. + Repository string `pulumi:"repository"` + // Value of the variable. + Value string `pulumi:"value"` + // Name of the variable. + VariableName string `pulumi:"variableName"` +} + +// The set of arguments for constructing a ActionsVariable resource. +type ActionsVariableArgs struct { + // Name of the repository. + Repository pulumi.StringInput + // Value of the variable. + Value pulumi.StringInput + // Name of the variable. + VariableName pulumi.StringInput +} + +func (ActionsVariableArgs) ElementType() reflect.Type { + return reflect.TypeOf((*actionsVariableArgs)(nil)).Elem() +} + +type ActionsVariableInput interface { + pulumi.Input + + ToActionsVariableOutput() ActionsVariableOutput + ToActionsVariableOutputWithContext(ctx context.Context) ActionsVariableOutput +} + +func (*ActionsVariable) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsVariable)(nil)).Elem() +} + +func (i *ActionsVariable) ToActionsVariableOutput() ActionsVariableOutput { + return i.ToActionsVariableOutputWithContext(context.Background()) +} + +func (i *ActionsVariable) ToActionsVariableOutputWithContext(ctx context.Context) ActionsVariableOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsVariableOutput) +} + +// ActionsVariableArrayInput is an input type that accepts ActionsVariableArray and ActionsVariableArrayOutput values. +// You can construct a concrete instance of `ActionsVariableArrayInput` via: +// +// ActionsVariableArray{ ActionsVariableArgs{...} } +type ActionsVariableArrayInput interface { + pulumi.Input + + ToActionsVariableArrayOutput() ActionsVariableArrayOutput + ToActionsVariableArrayOutputWithContext(context.Context) ActionsVariableArrayOutput +} + +type ActionsVariableArray []ActionsVariableInput + +func (ActionsVariableArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsVariable)(nil)).Elem() +} + +func (i ActionsVariableArray) ToActionsVariableArrayOutput() ActionsVariableArrayOutput { + return i.ToActionsVariableArrayOutputWithContext(context.Background()) +} + +func (i ActionsVariableArray) ToActionsVariableArrayOutputWithContext(ctx context.Context) ActionsVariableArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsVariableArrayOutput) +} + +// ActionsVariableMapInput is an input type that accepts ActionsVariableMap and ActionsVariableMapOutput values. +// You can construct a concrete instance of `ActionsVariableMapInput` via: +// +// ActionsVariableMap{ "key": ActionsVariableArgs{...} } +type ActionsVariableMapInput interface { + pulumi.Input + + ToActionsVariableMapOutput() ActionsVariableMapOutput + ToActionsVariableMapOutputWithContext(context.Context) ActionsVariableMapOutput +} + +type ActionsVariableMap map[string]ActionsVariableInput + +func (ActionsVariableMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsVariable)(nil)).Elem() +} + +func (i ActionsVariableMap) ToActionsVariableMapOutput() ActionsVariableMapOutput { + return i.ToActionsVariableMapOutputWithContext(context.Background()) +} + +func (i ActionsVariableMap) ToActionsVariableMapOutputWithContext(ctx context.Context) ActionsVariableMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsVariableMapOutput) +} + +type ActionsVariableOutput struct{ *pulumi.OutputState } + +func (ActionsVariableOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsVariable)(nil)).Elem() +} + +func (o ActionsVariableOutput) ToActionsVariableOutput() ActionsVariableOutput { + return o +} + +func (o ActionsVariableOutput) ToActionsVariableOutputWithContext(ctx context.Context) ActionsVariableOutput { + return o +} + +// Date the variable was created. +func (o ActionsVariableOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsVariable) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) +} + +// Name of the repository. +func (o ActionsVariableOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsVariable) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// ID of the repository. +func (o ActionsVariableOutput) RepositoryId() pulumi.IntOutput { + return o.ApplyT(func(v *ActionsVariable) pulumi.IntOutput { return v.RepositoryId }).(pulumi.IntOutput) +} + +// Date the variable was last updated. +func (o ActionsVariableOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsVariable) pulumi.StringOutput { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// Value of the variable. +func (o ActionsVariableOutput) Value() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsVariable) pulumi.StringOutput { return v.Value }).(pulumi.StringOutput) +} + +// Name of the variable. +func (o ActionsVariableOutput) VariableName() pulumi.StringOutput { + return o.ApplyT(func(v *ActionsVariable) pulumi.StringOutput { return v.VariableName }).(pulumi.StringOutput) +} + +type ActionsVariableArrayOutput struct{ *pulumi.OutputState } + +func (ActionsVariableArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ActionsVariable)(nil)).Elem() +} + +func (o ActionsVariableArrayOutput) ToActionsVariableArrayOutput() ActionsVariableArrayOutput { + return o +} + +func (o ActionsVariableArrayOutput) ToActionsVariableArrayOutputWithContext(ctx context.Context) ActionsVariableArrayOutput { + return o +} + +func (o ActionsVariableArrayOutput) Index(i pulumi.IntInput) ActionsVariableOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ActionsVariable { + return vs[0].([]*ActionsVariable)[vs[1].(int)] + }).(ActionsVariableOutput) +} + +type ActionsVariableMapOutput struct{ *pulumi.OutputState } + +func (ActionsVariableMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ActionsVariable)(nil)).Elem() +} + +func (o ActionsVariableMapOutput) ToActionsVariableMapOutput() ActionsVariableMapOutput { + return o +} + +func (o ActionsVariableMapOutput) ToActionsVariableMapOutputWithContext(ctx context.Context) ActionsVariableMapOutput { + return o +} + +func (o ActionsVariableMapOutput) MapIndex(k pulumi.StringInput) ActionsVariableOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ActionsVariable { + return vs[0].(map[string]*ActionsVariable)[vs[1].(string)] + }).(ActionsVariableOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsVariableInput)(nil)).Elem(), &ActionsVariable{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsVariableArrayInput)(nil)).Elem(), ActionsVariableArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsVariableMapInput)(nil)).Elem(), ActionsVariableMap{}) + pulumi.RegisterOutputType(ActionsVariableOutput{}) + pulumi.RegisterOutputType(ActionsVariableArrayOutput{}) + pulumi.RegisterOutputType(ActionsVariableMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/appInstallationRepositories.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/appInstallationRepositories.go new file mode 100644 index 000000000..a85c2d396 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/appInstallationRepositories.go @@ -0,0 +1,268 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// > **Note**: This resource is not compatible with the GitHub App Installation authentication method. +// +// This resource manages relationships between app installations and repositories +// in your GitHub organization or your user account. +// +// Creating this resource installs a particular app on multiple repositories. +// +// The app installation and the repositories must all belong to the same +// organization or user account on GitHub. Note: you can review your organization's installations +// by the following the instructions at this +// [link](https://docs.github.com/en/github/setting-up-and-managing-organizations-and-teams/reviewing-your-organizations-installed-integrations) or for your user account at this [link](https://docs.github.com/en/apps/using-github-apps/reviewing-and-modifying-installed-github-apps). +// +// ## Import +// +// GitHub App Installation Repositories can be imported +// using an ID made up of `installationId`, e.g. +// +// ```sh +// $ pulumi import github:index/appInstallationRepositories:AppInstallationRepositories some_app_repos 1234567 +// ``` +type AppInstallationRepositories struct { + pulumi.CustomResourceState + + // The GitHub app installation id. + InstallationId pulumi.StringOutput `pulumi:"installationId"` + // A list of repository names to install the app on. + // + // > **Note**: Due to how GitHub implements app installations, apps cannot be installed with no repositories selected. Therefore deleting this resource will leave one repository with the app installed. Manually uninstall the app or set the installation to all repositories via the GUI as after deleting this resource. + SelectedRepositories pulumi.StringArrayOutput `pulumi:"selectedRepositories"` +} + +// NewAppInstallationRepositories registers a new resource with the given unique name, arguments, and options. +func NewAppInstallationRepositories(ctx *pulumi.Context, + name string, args *AppInstallationRepositoriesArgs, opts ...pulumi.ResourceOption) (*AppInstallationRepositories, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InstallationId == nil { + return nil, errors.New("invalid value for required argument 'InstallationId'") + } + if args.SelectedRepositories == nil { + return nil, errors.New("invalid value for required argument 'SelectedRepositories'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource AppInstallationRepositories + err := ctx.RegisterResource("github:index/appInstallationRepositories:AppInstallationRepositories", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetAppInstallationRepositories gets an existing AppInstallationRepositories 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 GetAppInstallationRepositories(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *AppInstallationRepositoriesState, opts ...pulumi.ResourceOption) (*AppInstallationRepositories, error) { + var resource AppInstallationRepositories + err := ctx.ReadResource("github:index/appInstallationRepositories:AppInstallationRepositories", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering AppInstallationRepositories resources. +type appInstallationRepositoriesState struct { + // The GitHub app installation id. + InstallationId *string `pulumi:"installationId"` + // A list of repository names to install the app on. + // + // > **Note**: Due to how GitHub implements app installations, apps cannot be installed with no repositories selected. Therefore deleting this resource will leave one repository with the app installed. Manually uninstall the app or set the installation to all repositories via the GUI as after deleting this resource. + SelectedRepositories []string `pulumi:"selectedRepositories"` +} + +type AppInstallationRepositoriesState struct { + // The GitHub app installation id. + InstallationId pulumi.StringPtrInput + // A list of repository names to install the app on. + // + // > **Note**: Due to how GitHub implements app installations, apps cannot be installed with no repositories selected. Therefore deleting this resource will leave one repository with the app installed. Manually uninstall the app or set the installation to all repositories via the GUI as after deleting this resource. + SelectedRepositories pulumi.StringArrayInput +} + +func (AppInstallationRepositoriesState) ElementType() reflect.Type { + return reflect.TypeOf((*appInstallationRepositoriesState)(nil)).Elem() +} + +type appInstallationRepositoriesArgs struct { + // The GitHub app installation id. + InstallationId string `pulumi:"installationId"` + // A list of repository names to install the app on. + // + // > **Note**: Due to how GitHub implements app installations, apps cannot be installed with no repositories selected. Therefore deleting this resource will leave one repository with the app installed. Manually uninstall the app or set the installation to all repositories via the GUI as after deleting this resource. + SelectedRepositories []string `pulumi:"selectedRepositories"` +} + +// The set of arguments for constructing a AppInstallationRepositories resource. +type AppInstallationRepositoriesArgs struct { + // The GitHub app installation id. + InstallationId pulumi.StringInput + // A list of repository names to install the app on. + // + // > **Note**: Due to how GitHub implements app installations, apps cannot be installed with no repositories selected. Therefore deleting this resource will leave one repository with the app installed. Manually uninstall the app or set the installation to all repositories via the GUI as after deleting this resource. + SelectedRepositories pulumi.StringArrayInput +} + +func (AppInstallationRepositoriesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*appInstallationRepositoriesArgs)(nil)).Elem() +} + +type AppInstallationRepositoriesInput interface { + pulumi.Input + + ToAppInstallationRepositoriesOutput() AppInstallationRepositoriesOutput + ToAppInstallationRepositoriesOutputWithContext(ctx context.Context) AppInstallationRepositoriesOutput +} + +func (*AppInstallationRepositories) ElementType() reflect.Type { + return reflect.TypeOf((**AppInstallationRepositories)(nil)).Elem() +} + +func (i *AppInstallationRepositories) ToAppInstallationRepositoriesOutput() AppInstallationRepositoriesOutput { + return i.ToAppInstallationRepositoriesOutputWithContext(context.Background()) +} + +func (i *AppInstallationRepositories) ToAppInstallationRepositoriesOutputWithContext(ctx context.Context) AppInstallationRepositoriesOutput { + return pulumi.ToOutputWithContext(ctx, i).(AppInstallationRepositoriesOutput) +} + +// AppInstallationRepositoriesArrayInput is an input type that accepts AppInstallationRepositoriesArray and AppInstallationRepositoriesArrayOutput values. +// You can construct a concrete instance of `AppInstallationRepositoriesArrayInput` via: +// +// AppInstallationRepositoriesArray{ AppInstallationRepositoriesArgs{...} } +type AppInstallationRepositoriesArrayInput interface { + pulumi.Input + + ToAppInstallationRepositoriesArrayOutput() AppInstallationRepositoriesArrayOutput + ToAppInstallationRepositoriesArrayOutputWithContext(context.Context) AppInstallationRepositoriesArrayOutput +} + +type AppInstallationRepositoriesArray []AppInstallationRepositoriesInput + +func (AppInstallationRepositoriesArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*AppInstallationRepositories)(nil)).Elem() +} + +func (i AppInstallationRepositoriesArray) ToAppInstallationRepositoriesArrayOutput() AppInstallationRepositoriesArrayOutput { + return i.ToAppInstallationRepositoriesArrayOutputWithContext(context.Background()) +} + +func (i AppInstallationRepositoriesArray) ToAppInstallationRepositoriesArrayOutputWithContext(ctx context.Context) AppInstallationRepositoriesArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(AppInstallationRepositoriesArrayOutput) +} + +// AppInstallationRepositoriesMapInput is an input type that accepts AppInstallationRepositoriesMap and AppInstallationRepositoriesMapOutput values. +// You can construct a concrete instance of `AppInstallationRepositoriesMapInput` via: +// +// AppInstallationRepositoriesMap{ "key": AppInstallationRepositoriesArgs{...} } +type AppInstallationRepositoriesMapInput interface { + pulumi.Input + + ToAppInstallationRepositoriesMapOutput() AppInstallationRepositoriesMapOutput + ToAppInstallationRepositoriesMapOutputWithContext(context.Context) AppInstallationRepositoriesMapOutput +} + +type AppInstallationRepositoriesMap map[string]AppInstallationRepositoriesInput + +func (AppInstallationRepositoriesMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*AppInstallationRepositories)(nil)).Elem() +} + +func (i AppInstallationRepositoriesMap) ToAppInstallationRepositoriesMapOutput() AppInstallationRepositoriesMapOutput { + return i.ToAppInstallationRepositoriesMapOutputWithContext(context.Background()) +} + +func (i AppInstallationRepositoriesMap) ToAppInstallationRepositoriesMapOutputWithContext(ctx context.Context) AppInstallationRepositoriesMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(AppInstallationRepositoriesMapOutput) +} + +type AppInstallationRepositoriesOutput struct{ *pulumi.OutputState } + +func (AppInstallationRepositoriesOutput) ElementType() reflect.Type { + return reflect.TypeOf((**AppInstallationRepositories)(nil)).Elem() +} + +func (o AppInstallationRepositoriesOutput) ToAppInstallationRepositoriesOutput() AppInstallationRepositoriesOutput { + return o +} + +func (o AppInstallationRepositoriesOutput) ToAppInstallationRepositoriesOutputWithContext(ctx context.Context) AppInstallationRepositoriesOutput { + return o +} + +// The GitHub app installation id. +func (o AppInstallationRepositoriesOutput) InstallationId() pulumi.StringOutput { + return o.ApplyT(func(v *AppInstallationRepositories) pulumi.StringOutput { return v.InstallationId }).(pulumi.StringOutput) +} + +// A list of repository names to install the app on. +// +// > **Note**: Due to how GitHub implements app installations, apps cannot be installed with no repositories selected. Therefore deleting this resource will leave one repository with the app installed. Manually uninstall the app or set the installation to all repositories via the GUI as after deleting this resource. +func (o AppInstallationRepositoriesOutput) SelectedRepositories() pulumi.StringArrayOutput { + return o.ApplyT(func(v *AppInstallationRepositories) pulumi.StringArrayOutput { return v.SelectedRepositories }).(pulumi.StringArrayOutput) +} + +type AppInstallationRepositoriesArrayOutput struct{ *pulumi.OutputState } + +func (AppInstallationRepositoriesArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*AppInstallationRepositories)(nil)).Elem() +} + +func (o AppInstallationRepositoriesArrayOutput) ToAppInstallationRepositoriesArrayOutput() AppInstallationRepositoriesArrayOutput { + return o +} + +func (o AppInstallationRepositoriesArrayOutput) ToAppInstallationRepositoriesArrayOutputWithContext(ctx context.Context) AppInstallationRepositoriesArrayOutput { + return o +} + +func (o AppInstallationRepositoriesArrayOutput) Index(i pulumi.IntInput) AppInstallationRepositoriesOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *AppInstallationRepositories { + return vs[0].([]*AppInstallationRepositories)[vs[1].(int)] + }).(AppInstallationRepositoriesOutput) +} + +type AppInstallationRepositoriesMapOutput struct{ *pulumi.OutputState } + +func (AppInstallationRepositoriesMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*AppInstallationRepositories)(nil)).Elem() +} + +func (o AppInstallationRepositoriesMapOutput) ToAppInstallationRepositoriesMapOutput() AppInstallationRepositoriesMapOutput { + return o +} + +func (o AppInstallationRepositoriesMapOutput) ToAppInstallationRepositoriesMapOutputWithContext(ctx context.Context) AppInstallationRepositoriesMapOutput { + return o +} + +func (o AppInstallationRepositoriesMapOutput) MapIndex(k pulumi.StringInput) AppInstallationRepositoriesOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *AppInstallationRepositories { + return vs[0].(map[string]*AppInstallationRepositories)[vs[1].(string)] + }).(AppInstallationRepositoriesOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*AppInstallationRepositoriesInput)(nil)).Elem(), &AppInstallationRepositories{}) + pulumi.RegisterInputType(reflect.TypeOf((*AppInstallationRepositoriesArrayInput)(nil)).Elem(), AppInstallationRepositoriesArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*AppInstallationRepositoriesMapInput)(nil)).Elem(), AppInstallationRepositoriesMap{}) + pulumi.RegisterOutputType(AppInstallationRepositoriesOutput{}) + pulumi.RegisterOutputType(AppInstallationRepositoriesArrayOutput{}) + pulumi.RegisterOutputType(AppInstallationRepositoriesMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/appInstallationRepository.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/appInstallationRepository.go new file mode 100644 index 000000000..190d103f9 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/appInstallationRepository.go @@ -0,0 +1,297 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// > **Note**: This resource is not compatible with the GitHub App Installation authentication method. +// +// This resource manages relationships between app installations and repositories +// in your GitHub organization or your user account. +// +// Creating this resource installs a particular app on a particular repository. +// +// The app installation and the repository must both belong to the same +// organization or user account on GitHub. Note: you can review your organization's installations +// by the following the instructions at this +// [link](https://docs.github.com/en/github/setting-up-and-managing-organizations-and-teams/reviewing-your-organizations-installed-integrations) or for your user account at this [link](https://docs.github.com/en/apps/using-github-apps/reviewing-and-modifying-installed-github-apps). +// +// ## Example Usage +// +// ```go +// 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 { +// // Create a repository. +// someRepo, err := github.NewRepository(ctx, "some_repo", &github.RepositoryArgs{ +// Name: pulumi.String("some-repo"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewAppInstallationRepository(ctx, "some_app_repo", &github.AppInstallationRepositoryArgs{ +// InstallationId: pulumi.String("1234567"), +// Repository: someRepo.Name, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub App Installation Repository can be imported +// using an ID made up of `installation_id:repository`, e.g. +// +// ```sh +// $ pulumi import github:index/appInstallationRepository:AppInstallationRepository terraform_repo 1234567:terraform +// ``` +type AppInstallationRepository struct { + pulumi.CustomResourceState + + // The GitHub app installation id. + InstallationId pulumi.StringOutput `pulumi:"installationId"` + RepoId pulumi.IntOutput `pulumi:"repoId"` + // The repository to install the app on. + Repository pulumi.StringOutput `pulumi:"repository"` +} + +// NewAppInstallationRepository registers a new resource with the given unique name, arguments, and options. +func NewAppInstallationRepository(ctx *pulumi.Context, + name string, args *AppInstallationRepositoryArgs, opts ...pulumi.ResourceOption) (*AppInstallationRepository, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.InstallationId == nil { + return nil, errors.New("invalid value for required argument 'InstallationId'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource AppInstallationRepository + err := ctx.RegisterResource("github:index/appInstallationRepository:AppInstallationRepository", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetAppInstallationRepository gets an existing AppInstallationRepository 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 GetAppInstallationRepository(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *AppInstallationRepositoryState, opts ...pulumi.ResourceOption) (*AppInstallationRepository, error) { + var resource AppInstallationRepository + err := ctx.ReadResource("github:index/appInstallationRepository:AppInstallationRepository", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering AppInstallationRepository resources. +type appInstallationRepositoryState struct { + // The GitHub app installation id. + InstallationId *string `pulumi:"installationId"` + RepoId *int `pulumi:"repoId"` + // The repository to install the app on. + Repository *string `pulumi:"repository"` +} + +type AppInstallationRepositoryState struct { + // The GitHub app installation id. + InstallationId pulumi.StringPtrInput + RepoId pulumi.IntPtrInput + // The repository to install the app on. + Repository pulumi.StringPtrInput +} + +func (AppInstallationRepositoryState) ElementType() reflect.Type { + return reflect.TypeOf((*appInstallationRepositoryState)(nil)).Elem() +} + +type appInstallationRepositoryArgs struct { + // The GitHub app installation id. + InstallationId string `pulumi:"installationId"` + // The repository to install the app on. + Repository string `pulumi:"repository"` +} + +// The set of arguments for constructing a AppInstallationRepository resource. +type AppInstallationRepositoryArgs struct { + // The GitHub app installation id. + InstallationId pulumi.StringInput + // The repository to install the app on. + Repository pulumi.StringInput +} + +func (AppInstallationRepositoryArgs) ElementType() reflect.Type { + return reflect.TypeOf((*appInstallationRepositoryArgs)(nil)).Elem() +} + +type AppInstallationRepositoryInput interface { + pulumi.Input + + ToAppInstallationRepositoryOutput() AppInstallationRepositoryOutput + ToAppInstallationRepositoryOutputWithContext(ctx context.Context) AppInstallationRepositoryOutput +} + +func (*AppInstallationRepository) ElementType() reflect.Type { + return reflect.TypeOf((**AppInstallationRepository)(nil)).Elem() +} + +func (i *AppInstallationRepository) ToAppInstallationRepositoryOutput() AppInstallationRepositoryOutput { + return i.ToAppInstallationRepositoryOutputWithContext(context.Background()) +} + +func (i *AppInstallationRepository) ToAppInstallationRepositoryOutputWithContext(ctx context.Context) AppInstallationRepositoryOutput { + return pulumi.ToOutputWithContext(ctx, i).(AppInstallationRepositoryOutput) +} + +// AppInstallationRepositoryArrayInput is an input type that accepts AppInstallationRepositoryArray and AppInstallationRepositoryArrayOutput values. +// You can construct a concrete instance of `AppInstallationRepositoryArrayInput` via: +// +// AppInstallationRepositoryArray{ AppInstallationRepositoryArgs{...} } +type AppInstallationRepositoryArrayInput interface { + pulumi.Input + + ToAppInstallationRepositoryArrayOutput() AppInstallationRepositoryArrayOutput + ToAppInstallationRepositoryArrayOutputWithContext(context.Context) AppInstallationRepositoryArrayOutput +} + +type AppInstallationRepositoryArray []AppInstallationRepositoryInput + +func (AppInstallationRepositoryArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*AppInstallationRepository)(nil)).Elem() +} + +func (i AppInstallationRepositoryArray) ToAppInstallationRepositoryArrayOutput() AppInstallationRepositoryArrayOutput { + return i.ToAppInstallationRepositoryArrayOutputWithContext(context.Background()) +} + +func (i AppInstallationRepositoryArray) ToAppInstallationRepositoryArrayOutputWithContext(ctx context.Context) AppInstallationRepositoryArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(AppInstallationRepositoryArrayOutput) +} + +// AppInstallationRepositoryMapInput is an input type that accepts AppInstallationRepositoryMap and AppInstallationRepositoryMapOutput values. +// You can construct a concrete instance of `AppInstallationRepositoryMapInput` via: +// +// AppInstallationRepositoryMap{ "key": AppInstallationRepositoryArgs{...} } +type AppInstallationRepositoryMapInput interface { + pulumi.Input + + ToAppInstallationRepositoryMapOutput() AppInstallationRepositoryMapOutput + ToAppInstallationRepositoryMapOutputWithContext(context.Context) AppInstallationRepositoryMapOutput +} + +type AppInstallationRepositoryMap map[string]AppInstallationRepositoryInput + +func (AppInstallationRepositoryMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*AppInstallationRepository)(nil)).Elem() +} + +func (i AppInstallationRepositoryMap) ToAppInstallationRepositoryMapOutput() AppInstallationRepositoryMapOutput { + return i.ToAppInstallationRepositoryMapOutputWithContext(context.Background()) +} + +func (i AppInstallationRepositoryMap) ToAppInstallationRepositoryMapOutputWithContext(ctx context.Context) AppInstallationRepositoryMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(AppInstallationRepositoryMapOutput) +} + +type AppInstallationRepositoryOutput struct{ *pulumi.OutputState } + +func (AppInstallationRepositoryOutput) ElementType() reflect.Type { + return reflect.TypeOf((**AppInstallationRepository)(nil)).Elem() +} + +func (o AppInstallationRepositoryOutput) ToAppInstallationRepositoryOutput() AppInstallationRepositoryOutput { + return o +} + +func (o AppInstallationRepositoryOutput) ToAppInstallationRepositoryOutputWithContext(ctx context.Context) AppInstallationRepositoryOutput { + return o +} + +// The GitHub app installation id. +func (o AppInstallationRepositoryOutput) InstallationId() pulumi.StringOutput { + return o.ApplyT(func(v *AppInstallationRepository) pulumi.StringOutput { return v.InstallationId }).(pulumi.StringOutput) +} + +func (o AppInstallationRepositoryOutput) RepoId() pulumi.IntOutput { + return o.ApplyT(func(v *AppInstallationRepository) pulumi.IntOutput { return v.RepoId }).(pulumi.IntOutput) +} + +// The repository to install the app on. +func (o AppInstallationRepositoryOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *AppInstallationRepository) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +type AppInstallationRepositoryArrayOutput struct{ *pulumi.OutputState } + +func (AppInstallationRepositoryArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*AppInstallationRepository)(nil)).Elem() +} + +func (o AppInstallationRepositoryArrayOutput) ToAppInstallationRepositoryArrayOutput() AppInstallationRepositoryArrayOutput { + return o +} + +func (o AppInstallationRepositoryArrayOutput) ToAppInstallationRepositoryArrayOutputWithContext(ctx context.Context) AppInstallationRepositoryArrayOutput { + return o +} + +func (o AppInstallationRepositoryArrayOutput) Index(i pulumi.IntInput) AppInstallationRepositoryOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *AppInstallationRepository { + return vs[0].([]*AppInstallationRepository)[vs[1].(int)] + }).(AppInstallationRepositoryOutput) +} + +type AppInstallationRepositoryMapOutput struct{ *pulumi.OutputState } + +func (AppInstallationRepositoryMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*AppInstallationRepository)(nil)).Elem() +} + +func (o AppInstallationRepositoryMapOutput) ToAppInstallationRepositoryMapOutput() AppInstallationRepositoryMapOutput { + return o +} + +func (o AppInstallationRepositoryMapOutput) ToAppInstallationRepositoryMapOutputWithContext(ctx context.Context) AppInstallationRepositoryMapOutput { + return o +} + +func (o AppInstallationRepositoryMapOutput) MapIndex(k pulumi.StringInput) AppInstallationRepositoryOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *AppInstallationRepository { + return vs[0].(map[string]*AppInstallationRepository)[vs[1].(string)] + }).(AppInstallationRepositoryOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*AppInstallationRepositoryInput)(nil)).Elem(), &AppInstallationRepository{}) + pulumi.RegisterInputType(reflect.TypeOf((*AppInstallationRepositoryArrayInput)(nil)).Elem(), AppInstallationRepositoryArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*AppInstallationRepositoryMapInput)(nil)).Elem(), AppInstallationRepositoryMap{}) + pulumi.RegisterOutputType(AppInstallationRepositoryOutput{}) + pulumi.RegisterOutputType(AppInstallationRepositoryArrayOutput{}) + pulumi.RegisterOutputType(AppInstallationRepositoryMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/branch.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/branch.go new file mode 100644 index 000000000..c7c475439 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/branch.go @@ -0,0 +1,355 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage branches within your repository. +// +// Additional constraints can be applied to ensure your branch is created from +// another branch or commit. +// +// ## Example Usage +// +// ```go +// 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.NewBranch(ctx, "development", &github.BranchArgs{ +// Repository: pulumi.String("example"), +// Branch: pulumi.String("development"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Branch can be imported using an ID made up of `repository:branch`, e.g. +// +// ```sh +// $ pulumi import github:index/branch:Branch terraform terraform:main +// ``` +// +// Importing github branch into an instance object (when using a for each block to manage multiple branches) +// +// ```sh +// $ pulumi import github:index/branch:Branch terraform["terraform"] terraform:main +// ``` +// +// Optionally, a source branch may be specified using an ID of `repository:branch:source_branch`. +// This is useful for importing branches that do not branch directly off main. +// +// ```sh +// $ pulumi import github:index/branch:Branch terraform terraform:feature-branch:dev +// ``` +type Branch struct { + pulumi.CustomResourceState + + // The repository branch to create. + Branch pulumi.StringOutput `pulumi:"branch"` + // An etag representing the Branch object. + Etag pulumi.StringOutput `pulumi:"etag"` + // A string representing a branch reference, in the form of `refs/heads/`. + Ref pulumi.StringOutput `pulumi:"ref"` + // The GitHub repository name. + Repository pulumi.StringOutput `pulumi:"repository"` + // A string storing the reference's `HEAD` commit's SHA1. + Sha pulumi.StringOutput `pulumi:"sha"` + // The branch name to start from. Defaults to `main`. + SourceBranch pulumi.StringPtrOutput `pulumi:"sourceBranch"` + // The commit hash to start from. Defaults to the tip of `sourceBranch`. If provided, `sourceBranch` is ignored. + SourceSha pulumi.StringOutput `pulumi:"sourceSha"` +} + +// NewBranch registers a new resource with the given unique name, arguments, and options. +func NewBranch(ctx *pulumi.Context, + name string, args *BranchArgs, opts ...pulumi.ResourceOption) (*Branch, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Branch == nil { + return nil, errors.New("invalid value for required argument 'Branch'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource Branch + err := ctx.RegisterResource("github:index/branch:Branch", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetBranch gets an existing Branch 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 GetBranch(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *BranchState, opts ...pulumi.ResourceOption) (*Branch, error) { + var resource Branch + err := ctx.ReadResource("github:index/branch:Branch", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering Branch resources. +type branchState struct { + // The repository branch to create. + Branch *string `pulumi:"branch"` + // An etag representing the Branch object. + Etag *string `pulumi:"etag"` + // A string representing a branch reference, in the form of `refs/heads/`. + Ref *string `pulumi:"ref"` + // The GitHub repository name. + Repository *string `pulumi:"repository"` + // A string storing the reference's `HEAD` commit's SHA1. + Sha *string `pulumi:"sha"` + // The branch name to start from. Defaults to `main`. + SourceBranch *string `pulumi:"sourceBranch"` + // The commit hash to start from. Defaults to the tip of `sourceBranch`. If provided, `sourceBranch` is ignored. + SourceSha *string `pulumi:"sourceSha"` +} + +type BranchState struct { + // The repository branch to create. + Branch pulumi.StringPtrInput + // An etag representing the Branch object. + Etag pulumi.StringPtrInput + // A string representing a branch reference, in the form of `refs/heads/`. + Ref pulumi.StringPtrInput + // The GitHub repository name. + Repository pulumi.StringPtrInput + // A string storing the reference's `HEAD` commit's SHA1. + Sha pulumi.StringPtrInput + // The branch name to start from. Defaults to `main`. + SourceBranch pulumi.StringPtrInput + // The commit hash to start from. Defaults to the tip of `sourceBranch`. If provided, `sourceBranch` is ignored. + SourceSha pulumi.StringPtrInput +} + +func (BranchState) ElementType() reflect.Type { + return reflect.TypeOf((*branchState)(nil)).Elem() +} + +type branchArgs struct { + // The repository branch to create. + Branch string `pulumi:"branch"` + // An etag representing the Branch object. + Etag *string `pulumi:"etag"` + // The GitHub repository name. + Repository string `pulumi:"repository"` + // The branch name to start from. Defaults to `main`. + SourceBranch *string `pulumi:"sourceBranch"` + // The commit hash to start from. Defaults to the tip of `sourceBranch`. If provided, `sourceBranch` is ignored. + SourceSha *string `pulumi:"sourceSha"` +} + +// The set of arguments for constructing a Branch resource. +type BranchArgs struct { + // The repository branch to create. + Branch pulumi.StringInput + // An etag representing the Branch object. + Etag pulumi.StringPtrInput + // The GitHub repository name. + Repository pulumi.StringInput + // The branch name to start from. Defaults to `main`. + SourceBranch pulumi.StringPtrInput + // The commit hash to start from. Defaults to the tip of `sourceBranch`. If provided, `sourceBranch` is ignored. + SourceSha pulumi.StringPtrInput +} + +func (BranchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*branchArgs)(nil)).Elem() +} + +type BranchInput interface { + pulumi.Input + + ToBranchOutput() BranchOutput + ToBranchOutputWithContext(ctx context.Context) BranchOutput +} + +func (*Branch) ElementType() reflect.Type { + return reflect.TypeOf((**Branch)(nil)).Elem() +} + +func (i *Branch) ToBranchOutput() BranchOutput { + return i.ToBranchOutputWithContext(context.Background()) +} + +func (i *Branch) ToBranchOutputWithContext(ctx context.Context) BranchOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchOutput) +} + +// BranchArrayInput is an input type that accepts BranchArray and BranchArrayOutput values. +// You can construct a concrete instance of `BranchArrayInput` via: +// +// BranchArray{ BranchArgs{...} } +type BranchArrayInput interface { + pulumi.Input + + ToBranchArrayOutput() BranchArrayOutput + ToBranchArrayOutputWithContext(context.Context) BranchArrayOutput +} + +type BranchArray []BranchInput + +func (BranchArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Branch)(nil)).Elem() +} + +func (i BranchArray) ToBranchArrayOutput() BranchArrayOutput { + return i.ToBranchArrayOutputWithContext(context.Background()) +} + +func (i BranchArray) ToBranchArrayOutputWithContext(ctx context.Context) BranchArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchArrayOutput) +} + +// BranchMapInput is an input type that accepts BranchMap and BranchMapOutput values. +// You can construct a concrete instance of `BranchMapInput` via: +// +// BranchMap{ "key": BranchArgs{...} } +type BranchMapInput interface { + pulumi.Input + + ToBranchMapOutput() BranchMapOutput + ToBranchMapOutputWithContext(context.Context) BranchMapOutput +} + +type BranchMap map[string]BranchInput + +func (BranchMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Branch)(nil)).Elem() +} + +func (i BranchMap) ToBranchMapOutput() BranchMapOutput { + return i.ToBranchMapOutputWithContext(context.Background()) +} + +func (i BranchMap) ToBranchMapOutputWithContext(ctx context.Context) BranchMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchMapOutput) +} + +type BranchOutput struct{ *pulumi.OutputState } + +func (BranchOutput) ElementType() reflect.Type { + return reflect.TypeOf((**Branch)(nil)).Elem() +} + +func (o BranchOutput) ToBranchOutput() BranchOutput { + return o +} + +func (o BranchOutput) ToBranchOutputWithContext(ctx context.Context) BranchOutput { + return o +} + +// The repository branch to create. +func (o BranchOutput) Branch() pulumi.StringOutput { + return o.ApplyT(func(v *Branch) pulumi.StringOutput { return v.Branch }).(pulumi.StringOutput) +} + +// An etag representing the Branch object. +func (o BranchOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *Branch) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// A string representing a branch reference, in the form of `refs/heads/`. +func (o BranchOutput) Ref() pulumi.StringOutput { + return o.ApplyT(func(v *Branch) pulumi.StringOutput { return v.Ref }).(pulumi.StringOutput) +} + +// The GitHub repository name. +func (o BranchOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *Branch) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// A string storing the reference's `HEAD` commit's SHA1. +func (o BranchOutput) Sha() pulumi.StringOutput { + return o.ApplyT(func(v *Branch) pulumi.StringOutput { return v.Sha }).(pulumi.StringOutput) +} + +// The branch name to start from. Defaults to `main`. +func (o BranchOutput) SourceBranch() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Branch) pulumi.StringPtrOutput { return v.SourceBranch }).(pulumi.StringPtrOutput) +} + +// The commit hash to start from. Defaults to the tip of `sourceBranch`. If provided, `sourceBranch` is ignored. +func (o BranchOutput) SourceSha() pulumi.StringOutput { + return o.ApplyT(func(v *Branch) pulumi.StringOutput { return v.SourceSha }).(pulumi.StringOutput) +} + +type BranchArrayOutput struct{ *pulumi.OutputState } + +func (BranchArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Branch)(nil)).Elem() +} + +func (o BranchArrayOutput) ToBranchArrayOutput() BranchArrayOutput { + return o +} + +func (o BranchArrayOutput) ToBranchArrayOutputWithContext(ctx context.Context) BranchArrayOutput { + return o +} + +func (o BranchArrayOutput) Index(i pulumi.IntInput) BranchOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Branch { + return vs[0].([]*Branch)[vs[1].(int)] + }).(BranchOutput) +} + +type BranchMapOutput struct{ *pulumi.OutputState } + +func (BranchMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Branch)(nil)).Elem() +} + +func (o BranchMapOutput) ToBranchMapOutput() BranchMapOutput { + return o +} + +func (o BranchMapOutput) ToBranchMapOutputWithContext(ctx context.Context) BranchMapOutput { + return o +} + +func (o BranchMapOutput) MapIndex(k pulumi.StringInput) BranchOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Branch { + return vs[0].(map[string]*Branch)[vs[1].(string)] + }).(BranchOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*BranchInput)(nil)).Elem(), &Branch{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchArrayInput)(nil)).Elem(), BranchArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchMapInput)(nil)).Elem(), BranchMap{}) + pulumi.RegisterOutputType(BranchOutput{}) + pulumi.RegisterOutputType(BranchArrayOutput{}) + pulumi.RegisterOutputType(BranchMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/branchDefault.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/branchDefault.go new file mode 100644 index 000000000..daf56f202 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/branchDefault.go @@ -0,0 +1,353 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Provides a GitHub branch default resource. +// +// This resource allows you to set the default branch for a given repository. +// +// Note that use of this resource is incompatible with the `defaultBranch` option of the `Repository` resource. Using both will result in plans always showing a diff. +// +// ## Example Usage +// +// Basic usage: +// +// ```go +// 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("example"), +// Description: pulumi.String("My awesome codebase"), +// AutoInit: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// development, err := github.NewBranch(ctx, "development", &github.BranchArgs{ +// Repository: example.Name, +// Branch: pulumi.String("development"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewBranchDefault(ctx, "default", &github.BranchDefaultArgs{ +// Repository: example.Name, +// Branch: development.Branch, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// Renaming to a branch that doesn't exist: +// +// ```go +// 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("example"), +// Description: pulumi.String("My awesome codebase"), +// AutoInit: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewBranchDefault(ctx, "default", &github.BranchDefaultArgs{ +// Repository: example.Name, +// Branch: pulumi.String("development"), +// Rename: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Branch Defaults can be imported using an ID made up of `repository`, e.g. +// +// ```sh +// $ pulumi import github:index/branchDefault:BranchDefault branch_default my-repo +// ``` +type BranchDefault struct { + pulumi.CustomResourceState + + // The branch (e.g. `main`) + Branch pulumi.StringOutput `pulumi:"branch"` + Etag pulumi.StringOutput `pulumi:"etag"` + // Indicate if it should rename the branch rather than use an existing branch. Defaults to `false`. + Rename pulumi.BoolPtrOutput `pulumi:"rename"` + // The GitHub repository + Repository pulumi.StringOutput `pulumi:"repository"` +} + +// NewBranchDefault registers a new resource with the given unique name, arguments, and options. +func NewBranchDefault(ctx *pulumi.Context, + name string, args *BranchDefaultArgs, opts ...pulumi.ResourceOption) (*BranchDefault, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Branch == nil { + return nil, errors.New("invalid value for required argument 'Branch'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource BranchDefault + err := ctx.RegisterResource("github:index/branchDefault:BranchDefault", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetBranchDefault gets an existing BranchDefault 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 GetBranchDefault(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *BranchDefaultState, opts ...pulumi.ResourceOption) (*BranchDefault, error) { + var resource BranchDefault + err := ctx.ReadResource("github:index/branchDefault:BranchDefault", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering BranchDefault resources. +type branchDefaultState struct { + // The branch (e.g. `main`) + Branch *string `pulumi:"branch"` + Etag *string `pulumi:"etag"` + // Indicate if it should rename the branch rather than use an existing branch. Defaults to `false`. + Rename *bool `pulumi:"rename"` + // The GitHub repository + Repository *string `pulumi:"repository"` +} + +type BranchDefaultState struct { + // The branch (e.g. `main`) + Branch pulumi.StringPtrInput + Etag pulumi.StringPtrInput + // Indicate if it should rename the branch rather than use an existing branch. Defaults to `false`. + Rename pulumi.BoolPtrInput + // The GitHub repository + Repository pulumi.StringPtrInput +} + +func (BranchDefaultState) ElementType() reflect.Type { + return reflect.TypeOf((*branchDefaultState)(nil)).Elem() +} + +type branchDefaultArgs struct { + // The branch (e.g. `main`) + Branch string `pulumi:"branch"` + Etag *string `pulumi:"etag"` + // Indicate if it should rename the branch rather than use an existing branch. Defaults to `false`. + Rename *bool `pulumi:"rename"` + // The GitHub repository + Repository string `pulumi:"repository"` +} + +// The set of arguments for constructing a BranchDefault resource. +type BranchDefaultArgs struct { + // The branch (e.g. `main`) + Branch pulumi.StringInput + Etag pulumi.StringPtrInput + // Indicate if it should rename the branch rather than use an existing branch. Defaults to `false`. + Rename pulumi.BoolPtrInput + // The GitHub repository + Repository pulumi.StringInput +} + +func (BranchDefaultArgs) ElementType() reflect.Type { + return reflect.TypeOf((*branchDefaultArgs)(nil)).Elem() +} + +type BranchDefaultInput interface { + pulumi.Input + + ToBranchDefaultOutput() BranchDefaultOutput + ToBranchDefaultOutputWithContext(ctx context.Context) BranchDefaultOutput +} + +func (*BranchDefault) ElementType() reflect.Type { + return reflect.TypeOf((**BranchDefault)(nil)).Elem() +} + +func (i *BranchDefault) ToBranchDefaultOutput() BranchDefaultOutput { + return i.ToBranchDefaultOutputWithContext(context.Background()) +} + +func (i *BranchDefault) ToBranchDefaultOutputWithContext(ctx context.Context) BranchDefaultOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchDefaultOutput) +} + +// BranchDefaultArrayInput is an input type that accepts BranchDefaultArray and BranchDefaultArrayOutput values. +// You can construct a concrete instance of `BranchDefaultArrayInput` via: +// +// BranchDefaultArray{ BranchDefaultArgs{...} } +type BranchDefaultArrayInput interface { + pulumi.Input + + ToBranchDefaultArrayOutput() BranchDefaultArrayOutput + ToBranchDefaultArrayOutputWithContext(context.Context) BranchDefaultArrayOutput +} + +type BranchDefaultArray []BranchDefaultInput + +func (BranchDefaultArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*BranchDefault)(nil)).Elem() +} + +func (i BranchDefaultArray) ToBranchDefaultArrayOutput() BranchDefaultArrayOutput { + return i.ToBranchDefaultArrayOutputWithContext(context.Background()) +} + +func (i BranchDefaultArray) ToBranchDefaultArrayOutputWithContext(ctx context.Context) BranchDefaultArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchDefaultArrayOutput) +} + +// BranchDefaultMapInput is an input type that accepts BranchDefaultMap and BranchDefaultMapOutput values. +// You can construct a concrete instance of `BranchDefaultMapInput` via: +// +// BranchDefaultMap{ "key": BranchDefaultArgs{...} } +type BranchDefaultMapInput interface { + pulumi.Input + + ToBranchDefaultMapOutput() BranchDefaultMapOutput + ToBranchDefaultMapOutputWithContext(context.Context) BranchDefaultMapOutput +} + +type BranchDefaultMap map[string]BranchDefaultInput + +func (BranchDefaultMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*BranchDefault)(nil)).Elem() +} + +func (i BranchDefaultMap) ToBranchDefaultMapOutput() BranchDefaultMapOutput { + return i.ToBranchDefaultMapOutputWithContext(context.Background()) +} + +func (i BranchDefaultMap) ToBranchDefaultMapOutputWithContext(ctx context.Context) BranchDefaultMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchDefaultMapOutput) +} + +type BranchDefaultOutput struct{ *pulumi.OutputState } + +func (BranchDefaultOutput) ElementType() reflect.Type { + return reflect.TypeOf((**BranchDefault)(nil)).Elem() +} + +func (o BranchDefaultOutput) ToBranchDefaultOutput() BranchDefaultOutput { + return o +} + +func (o BranchDefaultOutput) ToBranchDefaultOutputWithContext(ctx context.Context) BranchDefaultOutput { + return o +} + +// The branch (e.g. `main`) +func (o BranchDefaultOutput) Branch() pulumi.StringOutput { + return o.ApplyT(func(v *BranchDefault) pulumi.StringOutput { return v.Branch }).(pulumi.StringOutput) +} + +func (o BranchDefaultOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *BranchDefault) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// Indicate if it should rename the branch rather than use an existing branch. Defaults to `false`. +func (o BranchDefaultOutput) Rename() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchDefault) pulumi.BoolPtrOutput { return v.Rename }).(pulumi.BoolPtrOutput) +} + +// The GitHub repository +func (o BranchDefaultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *BranchDefault) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +type BranchDefaultArrayOutput struct{ *pulumi.OutputState } + +func (BranchDefaultArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*BranchDefault)(nil)).Elem() +} + +func (o BranchDefaultArrayOutput) ToBranchDefaultArrayOutput() BranchDefaultArrayOutput { + return o +} + +func (o BranchDefaultArrayOutput) ToBranchDefaultArrayOutputWithContext(ctx context.Context) BranchDefaultArrayOutput { + return o +} + +func (o BranchDefaultArrayOutput) Index(i pulumi.IntInput) BranchDefaultOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *BranchDefault { + return vs[0].([]*BranchDefault)[vs[1].(int)] + }).(BranchDefaultOutput) +} + +type BranchDefaultMapOutput struct{ *pulumi.OutputState } + +func (BranchDefaultMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*BranchDefault)(nil)).Elem() +} + +func (o BranchDefaultMapOutput) ToBranchDefaultMapOutput() BranchDefaultMapOutput { + return o +} + +func (o BranchDefaultMapOutput) ToBranchDefaultMapOutputWithContext(ctx context.Context) BranchDefaultMapOutput { + return o +} + +func (o BranchDefaultMapOutput) MapIndex(k pulumi.StringInput) BranchDefaultOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *BranchDefault { + return vs[0].(map[string]*BranchDefault)[vs[1].(string)] + }).(BranchDefaultOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*BranchDefaultInput)(nil)).Elem(), &BranchDefault{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchDefaultArrayInput)(nil)).Elem(), BranchDefaultArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchDefaultMapInput)(nil)).Elem(), BranchDefaultMap{}) + pulumi.RegisterOutputType(BranchDefaultOutput{}) + pulumi.RegisterOutputType(BranchDefaultArrayOutput{}) + pulumi.RegisterOutputType(BranchDefaultMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/branchProtection.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/branchProtection.go new file mode 100644 index 000000000..d4c25d8ff --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/branchProtection.go @@ -0,0 +1,510 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Protects a GitHub branch. +// +// This resource allows you to configure branch protection for repositories in your organization. When applied, the branch will be protected from forced pushes and deletion. Additional constraints, such as required status checks or restrictions on users, teams, and apps, can also be configured. +// +// Note: for the `pushAllowances` a given user or team must have specific write access to the repository. If specific write access not provided, github will reject the given actor, which will be the cause of terraform drift. +// +// ## Example Usage +// +// ```go +// 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 { +// exampleRepository, err := github.NewRepository(ctx, "example", &github.RepositoryArgs{ +// Name: pulumi.String("test"), +// }) +// if err != nil { +// return err +// } +// example, err := github.GetUser(ctx, &github.GetUserArgs{ +// Username: "example", +// }, nil) +// if err != nil { +// return err +// } +// exampleTeam, err := github.NewTeam(ctx, "example", &github.TeamArgs{ +// Name: pulumi.String("Example Name"), +// }) +// if err != nil { +// return err +// } +// // Protect the main branch of the foo repository. Additionally, require that +// // the "ci/travis" context to be passing and only allow the engineers team merge +// // to the branch. +// _, err = github.NewBranchProtection(ctx, "example", &github.BranchProtectionArgs{ +// RepositoryId: exampleRepository.NodeId, +// Pattern: pulumi.String("main"), +// EnforceAdmins: pulumi.Bool(true), +// AllowsDeletions: pulumi.Bool(true), +// RequiredStatusChecks: github.BranchProtectionRequiredStatusCheckArray{ +// &github.BranchProtectionRequiredStatusCheckArgs{ +// Strict: pulumi.Bool(false), +// Contexts: pulumi.StringArray{ +// pulumi.String("ci/travis"), +// }, +// }, +// }, +// RequiredPullRequestReviews: github.BranchProtectionRequiredPullRequestReviewArray{ +// &github.BranchProtectionRequiredPullRequestReviewArgs{ +// DismissStaleReviews: pulumi.Bool(true), +// RestrictDismissals: pulumi.Bool(true), +// DismissalRestrictions: pulumi.StringArray{ +// pulumi.String(example.NodeId), +// exampleTeam.NodeId, +// pulumi.String("/exampleuser"), +// pulumi.String("exampleorganization/exampleteam"), +// }, +// }, +// }, +// RestrictPushes: github.BranchProtectionRestrictPushArray{ +// &github.BranchProtectionRestrictPushArgs{ +// PushAllowances: pulumi.StringArray{ +// pulumi.String(example.NodeId), +// pulumi.String("/exampleuser"), +// pulumi.String("exampleorganization/exampleteam"), +// }, +// }, +// }, +// ForcePushBypassers: pulumi.StringArray{ +// pulumi.String(pulumi.String(example.NodeId)), +// pulumi.String("/exampleuser"), +// pulumi.String("exampleorganization/exampleteam"), +// }, +// }) +// if err != nil { +// return err +// } +// _, err = github.NewTeamRepository(ctx, "example", &github.TeamRepositoryArgs{ +// TeamId: exampleTeam.ID(), +// Repository: exampleRepository.Name, +// Permission: pulumi.String("pull"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Branch Protection can be imported using an ID made up of `repository:pattern`, e.g. +// +// ```sh +// $ pulumi import github:index/branchProtection:BranchProtection terraform terraform:main +// ``` +type BranchProtection struct { + pulumi.CustomResourceState + + // Boolean, setting this to `true` to allow the branch to be deleted. + AllowsDeletions pulumi.BoolPtrOutput `pulumi:"allowsDeletions"` + // Boolean, setting this to `true` to allow force pushes on the branch to everyone. Set it to `false` if you specify `forcePushBypassers`. + AllowsForcePushes pulumi.BoolPtrOutput `pulumi:"allowsForcePushes"` + // Boolean, setting this to `true` enforces status checks for repository administrators. + EnforceAdmins pulumi.BoolPtrOutput `pulumi:"enforceAdmins"` + // The list of actor Names/IDs that are allowed to bypass force push restrictions. Actor names must either begin with a "/" for users or the organization name followed by a "/" for teams. If the list is not empty, `allowsForcePushes` should be set to `false`. + ForcePushBypassers pulumi.StringArrayOutput `pulumi:"forcePushBypassers"` + // Boolean, Setting this to `true` will make the branch read-only and preventing any pushes to it. Defaults to `false` + LockBranch pulumi.BoolPtrOutput `pulumi:"lockBranch"` + // Identifies the protection rule pattern. + Pattern pulumi.StringOutput `pulumi:"pattern"` + // The name or node ID of the repository associated with this branch protection rule. + RepositoryId pulumi.StringOutput `pulumi:"repositoryId"` + // Boolean, setting this to `true` requires all conversations on code must be resolved before a pull request can be merged. + RequireConversationResolution pulumi.BoolPtrOutput `pulumi:"requireConversationResolution"` + // Boolean, setting this to `true` requires all commits to be signed with GPG. + RequireSignedCommits pulumi.BoolPtrOutput `pulumi:"requireSignedCommits"` + // Boolean, setting this to `true` enforces a linear commit Git history, which prevents anyone from pushing merge commits to a branch + RequiredLinearHistory pulumi.BoolPtrOutput `pulumi:"requiredLinearHistory"` + // Enforce restrictions for pull request reviews. See Required Pull Request Reviews below for details. + RequiredPullRequestReviews BranchProtectionRequiredPullRequestReviewArrayOutput `pulumi:"requiredPullRequestReviews"` + // Enforce restrictions for required status checks. See Required Status Checks below for details. + RequiredStatusChecks BranchProtectionRequiredStatusCheckArrayOutput `pulumi:"requiredStatusChecks"` + // Restrict pushes to matching branches. See Restrict Pushes below for details. + RestrictPushes BranchProtectionRestrictPushArrayOutput `pulumi:"restrictPushes"` +} + +// NewBranchProtection registers a new resource with the given unique name, arguments, and options. +func NewBranchProtection(ctx *pulumi.Context, + name string, args *BranchProtectionArgs, opts ...pulumi.ResourceOption) (*BranchProtection, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Pattern == nil { + return nil, errors.New("invalid value for required argument 'Pattern'") + } + if args.RepositoryId == nil { + return nil, errors.New("invalid value for required argument 'RepositoryId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource BranchProtection + err := ctx.RegisterResource("github:index/branchProtection:BranchProtection", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetBranchProtection gets an existing BranchProtection 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 GetBranchProtection(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *BranchProtectionState, opts ...pulumi.ResourceOption) (*BranchProtection, error) { + var resource BranchProtection + err := ctx.ReadResource("github:index/branchProtection:BranchProtection", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering BranchProtection resources. +type branchProtectionState struct { + // Boolean, setting this to `true` to allow the branch to be deleted. + AllowsDeletions *bool `pulumi:"allowsDeletions"` + // Boolean, setting this to `true` to allow force pushes on the branch to everyone. Set it to `false` if you specify `forcePushBypassers`. + AllowsForcePushes *bool `pulumi:"allowsForcePushes"` + // Boolean, setting this to `true` enforces status checks for repository administrators. + EnforceAdmins *bool `pulumi:"enforceAdmins"` + // The list of actor Names/IDs that are allowed to bypass force push restrictions. Actor names must either begin with a "/" for users or the organization name followed by a "/" for teams. If the list is not empty, `allowsForcePushes` should be set to `false`. + ForcePushBypassers []string `pulumi:"forcePushBypassers"` + // Boolean, Setting this to `true` will make the branch read-only and preventing any pushes to it. Defaults to `false` + LockBranch *bool `pulumi:"lockBranch"` + // Identifies the protection rule pattern. + Pattern *string `pulumi:"pattern"` + // The name or node ID of the repository associated with this branch protection rule. + RepositoryId *string `pulumi:"repositoryId"` + // Boolean, setting this to `true` requires all conversations on code must be resolved before a pull request can be merged. + RequireConversationResolution *bool `pulumi:"requireConversationResolution"` + // Boolean, setting this to `true` requires all commits to be signed with GPG. + RequireSignedCommits *bool `pulumi:"requireSignedCommits"` + // Boolean, setting this to `true` enforces a linear commit Git history, which prevents anyone from pushing merge commits to a branch + RequiredLinearHistory *bool `pulumi:"requiredLinearHistory"` + // Enforce restrictions for pull request reviews. See Required Pull Request Reviews below for details. + RequiredPullRequestReviews []BranchProtectionRequiredPullRequestReview `pulumi:"requiredPullRequestReviews"` + // Enforce restrictions for required status checks. See Required Status Checks below for details. + RequiredStatusChecks []BranchProtectionRequiredStatusCheck `pulumi:"requiredStatusChecks"` + // Restrict pushes to matching branches. See Restrict Pushes below for details. + RestrictPushes []BranchProtectionRestrictPush `pulumi:"restrictPushes"` +} + +type BranchProtectionState struct { + // Boolean, setting this to `true` to allow the branch to be deleted. + AllowsDeletions pulumi.BoolPtrInput + // Boolean, setting this to `true` to allow force pushes on the branch to everyone. Set it to `false` if you specify `forcePushBypassers`. + AllowsForcePushes pulumi.BoolPtrInput + // Boolean, setting this to `true` enforces status checks for repository administrators. + EnforceAdmins pulumi.BoolPtrInput + // The list of actor Names/IDs that are allowed to bypass force push restrictions. Actor names must either begin with a "/" for users or the organization name followed by a "/" for teams. If the list is not empty, `allowsForcePushes` should be set to `false`. + ForcePushBypassers pulumi.StringArrayInput + // Boolean, Setting this to `true` will make the branch read-only and preventing any pushes to it. Defaults to `false` + LockBranch pulumi.BoolPtrInput + // Identifies the protection rule pattern. + Pattern pulumi.StringPtrInput + // The name or node ID of the repository associated with this branch protection rule. + RepositoryId pulumi.StringPtrInput + // Boolean, setting this to `true` requires all conversations on code must be resolved before a pull request can be merged. + RequireConversationResolution pulumi.BoolPtrInput + // Boolean, setting this to `true` requires all commits to be signed with GPG. + RequireSignedCommits pulumi.BoolPtrInput + // Boolean, setting this to `true` enforces a linear commit Git history, which prevents anyone from pushing merge commits to a branch + RequiredLinearHistory pulumi.BoolPtrInput + // Enforce restrictions for pull request reviews. See Required Pull Request Reviews below for details. + RequiredPullRequestReviews BranchProtectionRequiredPullRequestReviewArrayInput + // Enforce restrictions for required status checks. See Required Status Checks below for details. + RequiredStatusChecks BranchProtectionRequiredStatusCheckArrayInput + // Restrict pushes to matching branches. See Restrict Pushes below for details. + RestrictPushes BranchProtectionRestrictPushArrayInput +} + +func (BranchProtectionState) ElementType() reflect.Type { + return reflect.TypeOf((*branchProtectionState)(nil)).Elem() +} + +type branchProtectionArgs struct { + // Boolean, setting this to `true` to allow the branch to be deleted. + AllowsDeletions *bool `pulumi:"allowsDeletions"` + // Boolean, setting this to `true` to allow force pushes on the branch to everyone. Set it to `false` if you specify `forcePushBypassers`. + AllowsForcePushes *bool `pulumi:"allowsForcePushes"` + // Boolean, setting this to `true` enforces status checks for repository administrators. + EnforceAdmins *bool `pulumi:"enforceAdmins"` + // The list of actor Names/IDs that are allowed to bypass force push restrictions. Actor names must either begin with a "/" for users or the organization name followed by a "/" for teams. If the list is not empty, `allowsForcePushes` should be set to `false`. + ForcePushBypassers []string `pulumi:"forcePushBypassers"` + // Boolean, Setting this to `true` will make the branch read-only and preventing any pushes to it. Defaults to `false` + LockBranch *bool `pulumi:"lockBranch"` + // Identifies the protection rule pattern. + Pattern string `pulumi:"pattern"` + // The name or node ID of the repository associated with this branch protection rule. + RepositoryId string `pulumi:"repositoryId"` + // Boolean, setting this to `true` requires all conversations on code must be resolved before a pull request can be merged. + RequireConversationResolution *bool `pulumi:"requireConversationResolution"` + // Boolean, setting this to `true` requires all commits to be signed with GPG. + RequireSignedCommits *bool `pulumi:"requireSignedCommits"` + // Boolean, setting this to `true` enforces a linear commit Git history, which prevents anyone from pushing merge commits to a branch + RequiredLinearHistory *bool `pulumi:"requiredLinearHistory"` + // Enforce restrictions for pull request reviews. See Required Pull Request Reviews below for details. + RequiredPullRequestReviews []BranchProtectionRequiredPullRequestReview `pulumi:"requiredPullRequestReviews"` + // Enforce restrictions for required status checks. See Required Status Checks below for details. + RequiredStatusChecks []BranchProtectionRequiredStatusCheck `pulumi:"requiredStatusChecks"` + // Restrict pushes to matching branches. See Restrict Pushes below for details. + RestrictPushes []BranchProtectionRestrictPush `pulumi:"restrictPushes"` +} + +// The set of arguments for constructing a BranchProtection resource. +type BranchProtectionArgs struct { + // Boolean, setting this to `true` to allow the branch to be deleted. + AllowsDeletions pulumi.BoolPtrInput + // Boolean, setting this to `true` to allow force pushes on the branch to everyone. Set it to `false` if you specify `forcePushBypassers`. + AllowsForcePushes pulumi.BoolPtrInput + // Boolean, setting this to `true` enforces status checks for repository administrators. + EnforceAdmins pulumi.BoolPtrInput + // The list of actor Names/IDs that are allowed to bypass force push restrictions. Actor names must either begin with a "/" for users or the organization name followed by a "/" for teams. If the list is not empty, `allowsForcePushes` should be set to `false`. + ForcePushBypassers pulumi.StringArrayInput + // Boolean, Setting this to `true` will make the branch read-only and preventing any pushes to it. Defaults to `false` + LockBranch pulumi.BoolPtrInput + // Identifies the protection rule pattern. + Pattern pulumi.StringInput + // The name or node ID of the repository associated with this branch protection rule. + RepositoryId pulumi.StringInput + // Boolean, setting this to `true` requires all conversations on code must be resolved before a pull request can be merged. + RequireConversationResolution pulumi.BoolPtrInput + // Boolean, setting this to `true` requires all commits to be signed with GPG. + RequireSignedCommits pulumi.BoolPtrInput + // Boolean, setting this to `true` enforces a linear commit Git history, which prevents anyone from pushing merge commits to a branch + RequiredLinearHistory pulumi.BoolPtrInput + // Enforce restrictions for pull request reviews. See Required Pull Request Reviews below for details. + RequiredPullRequestReviews BranchProtectionRequiredPullRequestReviewArrayInput + // Enforce restrictions for required status checks. See Required Status Checks below for details. + RequiredStatusChecks BranchProtectionRequiredStatusCheckArrayInput + // Restrict pushes to matching branches. See Restrict Pushes below for details. + RestrictPushes BranchProtectionRestrictPushArrayInput +} + +func (BranchProtectionArgs) ElementType() reflect.Type { + return reflect.TypeOf((*branchProtectionArgs)(nil)).Elem() +} + +type BranchProtectionInput interface { + pulumi.Input + + ToBranchProtectionOutput() BranchProtectionOutput + ToBranchProtectionOutputWithContext(ctx context.Context) BranchProtectionOutput +} + +func (*BranchProtection) ElementType() reflect.Type { + return reflect.TypeOf((**BranchProtection)(nil)).Elem() +} + +func (i *BranchProtection) ToBranchProtectionOutput() BranchProtectionOutput { + return i.ToBranchProtectionOutputWithContext(context.Background()) +} + +func (i *BranchProtection) ToBranchProtectionOutputWithContext(ctx context.Context) BranchProtectionOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionOutput) +} + +// BranchProtectionArrayInput is an input type that accepts BranchProtectionArray and BranchProtectionArrayOutput values. +// You can construct a concrete instance of `BranchProtectionArrayInput` via: +// +// BranchProtectionArray{ BranchProtectionArgs{...} } +type BranchProtectionArrayInput interface { + pulumi.Input + + ToBranchProtectionArrayOutput() BranchProtectionArrayOutput + ToBranchProtectionArrayOutputWithContext(context.Context) BranchProtectionArrayOutput +} + +type BranchProtectionArray []BranchProtectionInput + +func (BranchProtectionArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*BranchProtection)(nil)).Elem() +} + +func (i BranchProtectionArray) ToBranchProtectionArrayOutput() BranchProtectionArrayOutput { + return i.ToBranchProtectionArrayOutputWithContext(context.Background()) +} + +func (i BranchProtectionArray) ToBranchProtectionArrayOutputWithContext(ctx context.Context) BranchProtectionArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionArrayOutput) +} + +// BranchProtectionMapInput is an input type that accepts BranchProtectionMap and BranchProtectionMapOutput values. +// You can construct a concrete instance of `BranchProtectionMapInput` via: +// +// BranchProtectionMap{ "key": BranchProtectionArgs{...} } +type BranchProtectionMapInput interface { + pulumi.Input + + ToBranchProtectionMapOutput() BranchProtectionMapOutput + ToBranchProtectionMapOutputWithContext(context.Context) BranchProtectionMapOutput +} + +type BranchProtectionMap map[string]BranchProtectionInput + +func (BranchProtectionMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*BranchProtection)(nil)).Elem() +} + +func (i BranchProtectionMap) ToBranchProtectionMapOutput() BranchProtectionMapOutput { + return i.ToBranchProtectionMapOutputWithContext(context.Background()) +} + +func (i BranchProtectionMap) ToBranchProtectionMapOutputWithContext(ctx context.Context) BranchProtectionMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionMapOutput) +} + +type BranchProtectionOutput struct{ *pulumi.OutputState } + +func (BranchProtectionOutput) ElementType() reflect.Type { + return reflect.TypeOf((**BranchProtection)(nil)).Elem() +} + +func (o BranchProtectionOutput) ToBranchProtectionOutput() BranchProtectionOutput { + return o +} + +func (o BranchProtectionOutput) ToBranchProtectionOutputWithContext(ctx context.Context) BranchProtectionOutput { + return o +} + +// Boolean, setting this to `true` to allow the branch to be deleted. +func (o BranchProtectionOutput) AllowsDeletions() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchProtection) pulumi.BoolPtrOutput { return v.AllowsDeletions }).(pulumi.BoolPtrOutput) +} + +// Boolean, setting this to `true` to allow force pushes on the branch to everyone. Set it to `false` if you specify `forcePushBypassers`. +func (o BranchProtectionOutput) AllowsForcePushes() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchProtection) pulumi.BoolPtrOutput { return v.AllowsForcePushes }).(pulumi.BoolPtrOutput) +} + +// Boolean, setting this to `true` enforces status checks for repository administrators. +func (o BranchProtectionOutput) EnforceAdmins() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchProtection) pulumi.BoolPtrOutput { return v.EnforceAdmins }).(pulumi.BoolPtrOutput) +} + +// The list of actor Names/IDs that are allowed to bypass force push restrictions. Actor names must either begin with a "/" for users or the organization name followed by a "/" for teams. If the list is not empty, `allowsForcePushes` should be set to `false`. +func (o BranchProtectionOutput) ForcePushBypassers() pulumi.StringArrayOutput { + return o.ApplyT(func(v *BranchProtection) pulumi.StringArrayOutput { return v.ForcePushBypassers }).(pulumi.StringArrayOutput) +} + +// Boolean, Setting this to `true` will make the branch read-only and preventing any pushes to it. Defaults to `false` +func (o BranchProtectionOutput) LockBranch() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchProtection) pulumi.BoolPtrOutput { return v.LockBranch }).(pulumi.BoolPtrOutput) +} + +// Identifies the protection rule pattern. +func (o BranchProtectionOutput) Pattern() pulumi.StringOutput { + return o.ApplyT(func(v *BranchProtection) pulumi.StringOutput { return v.Pattern }).(pulumi.StringOutput) +} + +// The name or node ID of the repository associated with this branch protection rule. +func (o BranchProtectionOutput) RepositoryId() pulumi.StringOutput { + return o.ApplyT(func(v *BranchProtection) pulumi.StringOutput { return v.RepositoryId }).(pulumi.StringOutput) +} + +// Boolean, setting this to `true` requires all conversations on code must be resolved before a pull request can be merged. +func (o BranchProtectionOutput) RequireConversationResolution() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchProtection) pulumi.BoolPtrOutput { return v.RequireConversationResolution }).(pulumi.BoolPtrOutput) +} + +// Boolean, setting this to `true` requires all commits to be signed with GPG. +func (o BranchProtectionOutput) RequireSignedCommits() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchProtection) pulumi.BoolPtrOutput { return v.RequireSignedCommits }).(pulumi.BoolPtrOutput) +} + +// Boolean, setting this to `true` enforces a linear commit Git history, which prevents anyone from pushing merge commits to a branch +func (o BranchProtectionOutput) RequiredLinearHistory() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchProtection) pulumi.BoolPtrOutput { return v.RequiredLinearHistory }).(pulumi.BoolPtrOutput) +} + +// Enforce restrictions for pull request reviews. See Required Pull Request Reviews below for details. +func (o BranchProtectionOutput) RequiredPullRequestReviews() BranchProtectionRequiredPullRequestReviewArrayOutput { + return o.ApplyT(func(v *BranchProtection) BranchProtectionRequiredPullRequestReviewArrayOutput { + return v.RequiredPullRequestReviews + }).(BranchProtectionRequiredPullRequestReviewArrayOutput) +} + +// Enforce restrictions for required status checks. See Required Status Checks below for details. +func (o BranchProtectionOutput) RequiredStatusChecks() BranchProtectionRequiredStatusCheckArrayOutput { + return o.ApplyT(func(v *BranchProtection) BranchProtectionRequiredStatusCheckArrayOutput { + return v.RequiredStatusChecks + }).(BranchProtectionRequiredStatusCheckArrayOutput) +} + +// Restrict pushes to matching branches. See Restrict Pushes below for details. +func (o BranchProtectionOutput) RestrictPushes() BranchProtectionRestrictPushArrayOutput { + return o.ApplyT(func(v *BranchProtection) BranchProtectionRestrictPushArrayOutput { return v.RestrictPushes }).(BranchProtectionRestrictPushArrayOutput) +} + +type BranchProtectionArrayOutput struct{ *pulumi.OutputState } + +func (BranchProtectionArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*BranchProtection)(nil)).Elem() +} + +func (o BranchProtectionArrayOutput) ToBranchProtectionArrayOutput() BranchProtectionArrayOutput { + return o +} + +func (o BranchProtectionArrayOutput) ToBranchProtectionArrayOutputWithContext(ctx context.Context) BranchProtectionArrayOutput { + return o +} + +func (o BranchProtectionArrayOutput) Index(i pulumi.IntInput) BranchProtectionOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *BranchProtection { + return vs[0].([]*BranchProtection)[vs[1].(int)] + }).(BranchProtectionOutput) +} + +type BranchProtectionMapOutput struct{ *pulumi.OutputState } + +func (BranchProtectionMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*BranchProtection)(nil)).Elem() +} + +func (o BranchProtectionMapOutput) ToBranchProtectionMapOutput() BranchProtectionMapOutput { + return o +} + +func (o BranchProtectionMapOutput) ToBranchProtectionMapOutputWithContext(ctx context.Context) BranchProtectionMapOutput { + return o +} + +func (o BranchProtectionMapOutput) MapIndex(k pulumi.StringInput) BranchProtectionOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *BranchProtection { + return vs[0].(map[string]*BranchProtection)[vs[1].(string)] + }).(BranchProtectionOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionInput)(nil)).Elem(), &BranchProtection{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionArrayInput)(nil)).Elem(), BranchProtectionArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionMapInput)(nil)).Elem(), BranchProtectionMap{}) + pulumi.RegisterOutputType(BranchProtectionOutput{}) + pulumi.RegisterOutputType(BranchProtectionArrayOutput{}) + pulumi.RegisterOutputType(BranchProtectionMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/branchProtectionV3.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/branchProtectionV3.go new file mode 100644 index 000000000..27141179b --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/branchProtectionV3.go @@ -0,0 +1,472 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Protects a GitHub branch. +// +// The `BranchProtection` resource has moved to the GraphQL API, while this resource will continue to leverage the REST API. +// +// This resource allows you to configure branch protection for repositories in your organization. When applied, the branch will be protected from forced pushes and deletion. Additional constraints, such as required status checks or restrictions on users, teams, and apps, can also be configured. +// +// ## Example Usage +// +// ```go +// 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 { +// // Protect the main branch of the foo repository. Only allow a specific user to merge to the branch. +// _, err := github.NewBranchProtectionV3(ctx, "example", &github.BranchProtectionV3Args{ +// Repository: pulumi.Any(exampleGithubRepository.Name), +// Branch: pulumi.String("main"), +// Restrictions: &github.BranchProtectionV3RestrictionsArgs{ +// Users: pulumi.StringArray{ +// pulumi.String("foo-user"), +// }, +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ```go +// 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 { +// exampleRepository, err := github.NewRepository(ctx, "example", &github.RepositoryArgs{ +// Name: pulumi.String("example"), +// }) +// if err != nil { +// return err +// } +// exampleTeam, err := github.NewTeam(ctx, "example", &github.TeamArgs{ +// Name: pulumi.String("Example Name"), +// }) +// if err != nil { +// return err +// } +// // Protect the main branch of the foo repository. Additionally, require that +// // the "ci/check" check ran by the Github Actions app is passing and only allow +// // the engineers team merge to the branch. +// _, err = github.NewBranchProtectionV3(ctx, "example", &github.BranchProtectionV3Args{ +// Repository: exampleRepository.Name, +// Branch: pulumi.String("main"), +// EnforceAdmins: pulumi.Bool(true), +// RequiredStatusChecks: &github.BranchProtectionV3RequiredStatusChecksArgs{ +// Strict: pulumi.Bool(false), +// Checks: pulumi.StringArray{ +// pulumi.String("ci/check:824642007264"), +// }, +// }, +// RequiredPullRequestReviews: &github.BranchProtectionV3RequiredPullRequestReviewsArgs{ +// DismissStaleReviews: pulumi.Bool(true), +// DismissalUsers: pulumi.StringArray{ +// pulumi.String("foo-user"), +// }, +// DismissalTeams: pulumi.StringArray{ +// exampleTeam.Slug, +// }, +// DismissalApp: []string{ +// "foo-app", +// }, +// BypassPullRequestAllowances: &github.BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesArgs{ +// Users: pulumi.StringArray{ +// pulumi.String("foo-user"), +// }, +// Teams: pulumi.StringArray{ +// exampleTeam.Slug, +// }, +// Apps: pulumi.StringArray{ +// pulumi.String("foo-app"), +// }, +// }, +// }, +// Restrictions: &github.BranchProtectionV3RestrictionsArgs{ +// Users: pulumi.StringArray{ +// pulumi.String("foo-user"), +// }, +// Teams: pulumi.StringArray{ +// exampleTeam.Slug, +// }, +// Apps: pulumi.StringArray{ +// pulumi.String("foo-app"), +// }, +// }, +// }) +// if err != nil { +// return err +// } +// _, err = github.NewTeamRepository(ctx, "example", &github.TeamRepositoryArgs{ +// TeamId: exampleTeam.ID(), +// Repository: exampleRepository.Name, +// Permission: pulumi.String("pull"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Branch Protection can be imported using an ID made up of `repository:branch`, e.g. +// +// ```sh +// $ pulumi import github:index/branchProtectionV3:BranchProtectionV3 terraform terraform:main +// ``` +type BranchProtectionV3 struct { + pulumi.CustomResourceState + + // The Git branch to protect. + Branch pulumi.StringOutput `pulumi:"branch"` + // Boolean, setting this to `true` enforces status checks for repository administrators. + EnforceAdmins pulumi.BoolPtrOutput `pulumi:"enforceAdmins"` + Etag pulumi.StringOutput `pulumi:"etag"` + // The GitHub repository name. + Repository pulumi.StringOutput `pulumi:"repository"` + // Boolean, setting this to `true` requires all conversations on code must be resolved before a pull request can be merged. + RequireConversationResolution pulumi.BoolPtrOutput `pulumi:"requireConversationResolution"` + // Boolean, setting this to `true` requires all commits to be signed with GPG. + RequireSignedCommits pulumi.BoolPtrOutput `pulumi:"requireSignedCommits"` + // Enforce restrictions for pull request reviews. See Required Pull Request Reviews below for details. + RequiredPullRequestReviews BranchProtectionV3RequiredPullRequestReviewsPtrOutput `pulumi:"requiredPullRequestReviews"` + // Enforce restrictions for required status checks. See Required Status Checks below for details. + RequiredStatusChecks BranchProtectionV3RequiredStatusChecksPtrOutput `pulumi:"requiredStatusChecks"` + // Enforce restrictions for the users and teams that may push to the branch. See Restrictions below for details. + Restrictions BranchProtectionV3RestrictionsPtrOutput `pulumi:"restrictions"` +} + +// NewBranchProtectionV3 registers a new resource with the given unique name, arguments, and options. +func NewBranchProtectionV3(ctx *pulumi.Context, + name string, args *BranchProtectionV3Args, opts ...pulumi.ResourceOption) (*BranchProtectionV3, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Branch == nil { + return nil, errors.New("invalid value for required argument 'Branch'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource BranchProtectionV3 + err := ctx.RegisterResource("github:index/branchProtectionV3:BranchProtectionV3", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetBranchProtectionV3 gets an existing BranchProtectionV3 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 GetBranchProtectionV3(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *BranchProtectionV3State, opts ...pulumi.ResourceOption) (*BranchProtectionV3, error) { + var resource BranchProtectionV3 + err := ctx.ReadResource("github:index/branchProtectionV3:BranchProtectionV3", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering BranchProtectionV3 resources. +type branchProtectionV3State struct { + // The Git branch to protect. + Branch *string `pulumi:"branch"` + // Boolean, setting this to `true` enforces status checks for repository administrators. + EnforceAdmins *bool `pulumi:"enforceAdmins"` + Etag *string `pulumi:"etag"` + // The GitHub repository name. + Repository *string `pulumi:"repository"` + // Boolean, setting this to `true` requires all conversations on code must be resolved before a pull request can be merged. + RequireConversationResolution *bool `pulumi:"requireConversationResolution"` + // Boolean, setting this to `true` requires all commits to be signed with GPG. + RequireSignedCommits *bool `pulumi:"requireSignedCommits"` + // Enforce restrictions for pull request reviews. See Required Pull Request Reviews below for details. + RequiredPullRequestReviews *BranchProtectionV3RequiredPullRequestReviews `pulumi:"requiredPullRequestReviews"` + // Enforce restrictions for required status checks. See Required Status Checks below for details. + RequiredStatusChecks *BranchProtectionV3RequiredStatusChecks `pulumi:"requiredStatusChecks"` + // Enforce restrictions for the users and teams that may push to the branch. See Restrictions below for details. + Restrictions *BranchProtectionV3Restrictions `pulumi:"restrictions"` +} + +type BranchProtectionV3State struct { + // The Git branch to protect. + Branch pulumi.StringPtrInput + // Boolean, setting this to `true` enforces status checks for repository administrators. + EnforceAdmins pulumi.BoolPtrInput + Etag pulumi.StringPtrInput + // The GitHub repository name. + Repository pulumi.StringPtrInput + // Boolean, setting this to `true` requires all conversations on code must be resolved before a pull request can be merged. + RequireConversationResolution pulumi.BoolPtrInput + // Boolean, setting this to `true` requires all commits to be signed with GPG. + RequireSignedCommits pulumi.BoolPtrInput + // Enforce restrictions for pull request reviews. See Required Pull Request Reviews below for details. + RequiredPullRequestReviews BranchProtectionV3RequiredPullRequestReviewsPtrInput + // Enforce restrictions for required status checks. See Required Status Checks below for details. + RequiredStatusChecks BranchProtectionV3RequiredStatusChecksPtrInput + // Enforce restrictions for the users and teams that may push to the branch. See Restrictions below for details. + Restrictions BranchProtectionV3RestrictionsPtrInput +} + +func (BranchProtectionV3State) ElementType() reflect.Type { + return reflect.TypeOf((*branchProtectionV3State)(nil)).Elem() +} + +type branchProtectionV3Args struct { + // The Git branch to protect. + Branch string `pulumi:"branch"` + // Boolean, setting this to `true` enforces status checks for repository administrators. + EnforceAdmins *bool `pulumi:"enforceAdmins"` + // The GitHub repository name. + Repository string `pulumi:"repository"` + // Boolean, setting this to `true` requires all conversations on code must be resolved before a pull request can be merged. + RequireConversationResolution *bool `pulumi:"requireConversationResolution"` + // Boolean, setting this to `true` requires all commits to be signed with GPG. + RequireSignedCommits *bool `pulumi:"requireSignedCommits"` + // Enforce restrictions for pull request reviews. See Required Pull Request Reviews below for details. + RequiredPullRequestReviews *BranchProtectionV3RequiredPullRequestReviews `pulumi:"requiredPullRequestReviews"` + // Enforce restrictions for required status checks. See Required Status Checks below for details. + RequiredStatusChecks *BranchProtectionV3RequiredStatusChecks `pulumi:"requiredStatusChecks"` + // Enforce restrictions for the users and teams that may push to the branch. See Restrictions below for details. + Restrictions *BranchProtectionV3Restrictions `pulumi:"restrictions"` +} + +// The set of arguments for constructing a BranchProtectionV3 resource. +type BranchProtectionV3Args struct { + // The Git branch to protect. + Branch pulumi.StringInput + // Boolean, setting this to `true` enforces status checks for repository administrators. + EnforceAdmins pulumi.BoolPtrInput + // The GitHub repository name. + Repository pulumi.StringInput + // Boolean, setting this to `true` requires all conversations on code must be resolved before a pull request can be merged. + RequireConversationResolution pulumi.BoolPtrInput + // Boolean, setting this to `true` requires all commits to be signed with GPG. + RequireSignedCommits pulumi.BoolPtrInput + // Enforce restrictions for pull request reviews. See Required Pull Request Reviews below for details. + RequiredPullRequestReviews BranchProtectionV3RequiredPullRequestReviewsPtrInput + // Enforce restrictions for required status checks. See Required Status Checks below for details. + RequiredStatusChecks BranchProtectionV3RequiredStatusChecksPtrInput + // Enforce restrictions for the users and teams that may push to the branch. See Restrictions below for details. + Restrictions BranchProtectionV3RestrictionsPtrInput +} + +func (BranchProtectionV3Args) ElementType() reflect.Type { + return reflect.TypeOf((*branchProtectionV3Args)(nil)).Elem() +} + +type BranchProtectionV3Input interface { + pulumi.Input + + ToBranchProtectionV3Output() BranchProtectionV3Output + ToBranchProtectionV3OutputWithContext(ctx context.Context) BranchProtectionV3Output +} + +func (*BranchProtectionV3) ElementType() reflect.Type { + return reflect.TypeOf((**BranchProtectionV3)(nil)).Elem() +} + +func (i *BranchProtectionV3) ToBranchProtectionV3Output() BranchProtectionV3Output { + return i.ToBranchProtectionV3OutputWithContext(context.Background()) +} + +func (i *BranchProtectionV3) ToBranchProtectionV3OutputWithContext(ctx context.Context) BranchProtectionV3Output { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionV3Output) +} + +// BranchProtectionV3ArrayInput is an input type that accepts BranchProtectionV3Array and BranchProtectionV3ArrayOutput values. +// You can construct a concrete instance of `BranchProtectionV3ArrayInput` via: +// +// BranchProtectionV3Array{ BranchProtectionV3Args{...} } +type BranchProtectionV3ArrayInput interface { + pulumi.Input + + ToBranchProtectionV3ArrayOutput() BranchProtectionV3ArrayOutput + ToBranchProtectionV3ArrayOutputWithContext(context.Context) BranchProtectionV3ArrayOutput +} + +type BranchProtectionV3Array []BranchProtectionV3Input + +func (BranchProtectionV3Array) ElementType() reflect.Type { + return reflect.TypeOf((*[]*BranchProtectionV3)(nil)).Elem() +} + +func (i BranchProtectionV3Array) ToBranchProtectionV3ArrayOutput() BranchProtectionV3ArrayOutput { + return i.ToBranchProtectionV3ArrayOutputWithContext(context.Background()) +} + +func (i BranchProtectionV3Array) ToBranchProtectionV3ArrayOutputWithContext(ctx context.Context) BranchProtectionV3ArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionV3ArrayOutput) +} + +// BranchProtectionV3MapInput is an input type that accepts BranchProtectionV3Map and BranchProtectionV3MapOutput values. +// You can construct a concrete instance of `BranchProtectionV3MapInput` via: +// +// BranchProtectionV3Map{ "key": BranchProtectionV3Args{...} } +type BranchProtectionV3MapInput interface { + pulumi.Input + + ToBranchProtectionV3MapOutput() BranchProtectionV3MapOutput + ToBranchProtectionV3MapOutputWithContext(context.Context) BranchProtectionV3MapOutput +} + +type BranchProtectionV3Map map[string]BranchProtectionV3Input + +func (BranchProtectionV3Map) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*BranchProtectionV3)(nil)).Elem() +} + +func (i BranchProtectionV3Map) ToBranchProtectionV3MapOutput() BranchProtectionV3MapOutput { + return i.ToBranchProtectionV3MapOutputWithContext(context.Background()) +} + +func (i BranchProtectionV3Map) ToBranchProtectionV3MapOutputWithContext(ctx context.Context) BranchProtectionV3MapOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionV3MapOutput) +} + +type BranchProtectionV3Output struct{ *pulumi.OutputState } + +func (BranchProtectionV3Output) ElementType() reflect.Type { + return reflect.TypeOf((**BranchProtectionV3)(nil)).Elem() +} + +func (o BranchProtectionV3Output) ToBranchProtectionV3Output() BranchProtectionV3Output { + return o +} + +func (o BranchProtectionV3Output) ToBranchProtectionV3OutputWithContext(ctx context.Context) BranchProtectionV3Output { + return o +} + +// The Git branch to protect. +func (o BranchProtectionV3Output) Branch() pulumi.StringOutput { + return o.ApplyT(func(v *BranchProtectionV3) pulumi.StringOutput { return v.Branch }).(pulumi.StringOutput) +} + +// Boolean, setting this to `true` enforces status checks for repository administrators. +func (o BranchProtectionV3Output) EnforceAdmins() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchProtectionV3) pulumi.BoolPtrOutput { return v.EnforceAdmins }).(pulumi.BoolPtrOutput) +} + +func (o BranchProtectionV3Output) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *BranchProtectionV3) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// The GitHub repository name. +func (o BranchProtectionV3Output) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *BranchProtectionV3) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// Boolean, setting this to `true` requires all conversations on code must be resolved before a pull request can be merged. +func (o BranchProtectionV3Output) RequireConversationResolution() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchProtectionV3) pulumi.BoolPtrOutput { return v.RequireConversationResolution }).(pulumi.BoolPtrOutput) +} + +// Boolean, setting this to `true` requires all commits to be signed with GPG. +func (o BranchProtectionV3Output) RequireSignedCommits() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchProtectionV3) pulumi.BoolPtrOutput { return v.RequireSignedCommits }).(pulumi.BoolPtrOutput) +} + +// Enforce restrictions for pull request reviews. See Required Pull Request Reviews below for details. +func (o BranchProtectionV3Output) RequiredPullRequestReviews() BranchProtectionV3RequiredPullRequestReviewsPtrOutput { + return o.ApplyT(func(v *BranchProtectionV3) BranchProtectionV3RequiredPullRequestReviewsPtrOutput { + return v.RequiredPullRequestReviews + }).(BranchProtectionV3RequiredPullRequestReviewsPtrOutput) +} + +// Enforce restrictions for required status checks. See Required Status Checks below for details. +func (o BranchProtectionV3Output) RequiredStatusChecks() BranchProtectionV3RequiredStatusChecksPtrOutput { + return o.ApplyT(func(v *BranchProtectionV3) BranchProtectionV3RequiredStatusChecksPtrOutput { + return v.RequiredStatusChecks + }).(BranchProtectionV3RequiredStatusChecksPtrOutput) +} + +// Enforce restrictions for the users and teams that may push to the branch. See Restrictions below for details. +func (o BranchProtectionV3Output) Restrictions() BranchProtectionV3RestrictionsPtrOutput { + return o.ApplyT(func(v *BranchProtectionV3) BranchProtectionV3RestrictionsPtrOutput { return v.Restrictions }).(BranchProtectionV3RestrictionsPtrOutput) +} + +type BranchProtectionV3ArrayOutput struct{ *pulumi.OutputState } + +func (BranchProtectionV3ArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*BranchProtectionV3)(nil)).Elem() +} + +func (o BranchProtectionV3ArrayOutput) ToBranchProtectionV3ArrayOutput() BranchProtectionV3ArrayOutput { + return o +} + +func (o BranchProtectionV3ArrayOutput) ToBranchProtectionV3ArrayOutputWithContext(ctx context.Context) BranchProtectionV3ArrayOutput { + return o +} + +func (o BranchProtectionV3ArrayOutput) Index(i pulumi.IntInput) BranchProtectionV3Output { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *BranchProtectionV3 { + return vs[0].([]*BranchProtectionV3)[vs[1].(int)] + }).(BranchProtectionV3Output) +} + +type BranchProtectionV3MapOutput struct{ *pulumi.OutputState } + +func (BranchProtectionV3MapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*BranchProtectionV3)(nil)).Elem() +} + +func (o BranchProtectionV3MapOutput) ToBranchProtectionV3MapOutput() BranchProtectionV3MapOutput { + return o +} + +func (o BranchProtectionV3MapOutput) ToBranchProtectionV3MapOutputWithContext(ctx context.Context) BranchProtectionV3MapOutput { + return o +} + +func (o BranchProtectionV3MapOutput) MapIndex(k pulumi.StringInput) BranchProtectionV3Output { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *BranchProtectionV3 { + return vs[0].(map[string]*BranchProtectionV3)[vs[1].(string)] + }).(BranchProtectionV3Output) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionV3Input)(nil)).Elem(), &BranchProtectionV3{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionV3ArrayInput)(nil)).Elem(), BranchProtectionV3Array{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionV3MapInput)(nil)).Elem(), BranchProtectionV3Map{}) + pulumi.RegisterOutputType(BranchProtectionV3Output{}) + pulumi.RegisterOutputType(BranchProtectionV3ArrayOutput{}) + pulumi.RegisterOutputType(BranchProtectionV3MapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/codespacesOrganizationSecret.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/codespacesOrganizationSecret.go new file mode 100644 index 000000000..1a52a427d --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/codespacesOrganizationSecret.go @@ -0,0 +1,342 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage GitHub Codespaces secrets within your GitHub organization. +// You must have write access to a repository to use this resource. +// +// Secret values are encrypted using the [Go '/crypto/box' module](https://godoc.org/golang.org/x/crypto/nacl/box) which is +// interoperable with [libsodium](https://libsodium.gitbook.io/doc/). Libsodium is used by GitHub to decrypt secret values. +// +// For the purposes of security, the contents of the `plaintextValue` field have been marked as `sensitive` to Terraform, +// but it is important to note that **this does not hide it from state files**. You should treat state as sensitive always. +// It is also advised that you do not store plaintext values in your code but rather populate the `encryptedValue` +// using fields from a resource, data source or variable as, while encrypted in state, these will be easily accessible +// in your code. See below for an example of this abstraction. +// +// ## Import +// +// This resource can be imported using an ID made up of the secret name: +// +// ```sh +// $ pulumi import github:index/codespacesOrganizationSecret:CodespacesOrganizationSecret test_secret test_secret_name +// ``` +// +// NOTE: the implementation is limited in that it won't fetch the value of the +// `plaintextValue` or `encryptedValue` fields when importing. You may need to ignore changes for these as a workaround. +type CodespacesOrganizationSecret struct { + pulumi.CustomResourceState + + // Date of codespacesSecret creation. + CreatedAt pulumi.StringOutput `pulumi:"createdAt"` + // Encrypted value of the secret using the GitHub public key in Base64 format. + EncryptedValue pulumi.StringPtrOutput `pulumi:"encryptedValue"` + // Plaintext value of the secret to be encrypted + PlaintextValue pulumi.StringPtrOutput `pulumi:"plaintextValue"` + // Name of the secret + SecretName pulumi.StringOutput `pulumi:"secretName"` + // An array of repository ids that can access the organization secret. + SelectedRepositoryIds pulumi.IntArrayOutput `pulumi:"selectedRepositoryIds"` + // Date of codespacesSecret update. + UpdatedAt pulumi.StringOutput `pulumi:"updatedAt"` + // Configures the access that repositories have to the organization secret. + // Must be one of `all`, `private`, `selected`. `selectedRepositoryIds` is required if set to `selected`. + Visibility pulumi.StringOutput `pulumi:"visibility"` +} + +// NewCodespacesOrganizationSecret registers a new resource with the given unique name, arguments, and options. +func NewCodespacesOrganizationSecret(ctx *pulumi.Context, + name string, args *CodespacesOrganizationSecretArgs, opts ...pulumi.ResourceOption) (*CodespacesOrganizationSecret, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.SecretName == nil { + return nil, errors.New("invalid value for required argument 'SecretName'") + } + if args.Visibility == nil { + return nil, errors.New("invalid value for required argument 'Visibility'") + } + if args.EncryptedValue != nil { + args.EncryptedValue = pulumi.ToSecret(args.EncryptedValue).(pulumi.StringPtrInput) + } + if args.PlaintextValue != nil { + args.PlaintextValue = pulumi.ToSecret(args.PlaintextValue).(pulumi.StringPtrInput) + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "encryptedValue", + "plaintextValue", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource CodespacesOrganizationSecret + err := ctx.RegisterResource("github:index/codespacesOrganizationSecret:CodespacesOrganizationSecret", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetCodespacesOrganizationSecret gets an existing CodespacesOrganizationSecret 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 GetCodespacesOrganizationSecret(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *CodespacesOrganizationSecretState, opts ...pulumi.ResourceOption) (*CodespacesOrganizationSecret, error) { + var resource CodespacesOrganizationSecret + err := ctx.ReadResource("github:index/codespacesOrganizationSecret:CodespacesOrganizationSecret", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering CodespacesOrganizationSecret resources. +type codespacesOrganizationSecretState struct { + // Date of codespacesSecret creation. + CreatedAt *string `pulumi:"createdAt"` + // Encrypted value of the secret using the GitHub public key in Base64 format. + EncryptedValue *string `pulumi:"encryptedValue"` + // Plaintext value of the secret to be encrypted + PlaintextValue *string `pulumi:"plaintextValue"` + // Name of the secret + SecretName *string `pulumi:"secretName"` + // An array of repository ids that can access the organization secret. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` + // Date of codespacesSecret update. + UpdatedAt *string `pulumi:"updatedAt"` + // Configures the access that repositories have to the organization secret. + // Must be one of `all`, `private`, `selected`. `selectedRepositoryIds` is required if set to `selected`. + Visibility *string `pulumi:"visibility"` +} + +type CodespacesOrganizationSecretState struct { + // Date of codespacesSecret creation. + CreatedAt pulumi.StringPtrInput + // Encrypted value of the secret using the GitHub public key in Base64 format. + EncryptedValue pulumi.StringPtrInput + // Plaintext value of the secret to be encrypted + PlaintextValue pulumi.StringPtrInput + // Name of the secret + SecretName pulumi.StringPtrInput + // An array of repository ids that can access the organization secret. + SelectedRepositoryIds pulumi.IntArrayInput + // Date of codespacesSecret update. + UpdatedAt pulumi.StringPtrInput + // Configures the access that repositories have to the organization secret. + // Must be one of `all`, `private`, `selected`. `selectedRepositoryIds` is required if set to `selected`. + Visibility pulumi.StringPtrInput +} + +func (CodespacesOrganizationSecretState) ElementType() reflect.Type { + return reflect.TypeOf((*codespacesOrganizationSecretState)(nil)).Elem() +} + +type codespacesOrganizationSecretArgs struct { + // Encrypted value of the secret using the GitHub public key in Base64 format. + EncryptedValue *string `pulumi:"encryptedValue"` + // Plaintext value of the secret to be encrypted + PlaintextValue *string `pulumi:"plaintextValue"` + // Name of the secret + SecretName string `pulumi:"secretName"` + // An array of repository ids that can access the organization secret. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` + // Configures the access that repositories have to the organization secret. + // Must be one of `all`, `private`, `selected`. `selectedRepositoryIds` is required if set to `selected`. + Visibility string `pulumi:"visibility"` +} + +// The set of arguments for constructing a CodespacesOrganizationSecret resource. +type CodespacesOrganizationSecretArgs struct { + // Encrypted value of the secret using the GitHub public key in Base64 format. + EncryptedValue pulumi.StringPtrInput + // Plaintext value of the secret to be encrypted + PlaintextValue pulumi.StringPtrInput + // Name of the secret + SecretName pulumi.StringInput + // An array of repository ids that can access the organization secret. + SelectedRepositoryIds pulumi.IntArrayInput + // Configures the access that repositories have to the organization secret. + // Must be one of `all`, `private`, `selected`. `selectedRepositoryIds` is required if set to `selected`. + Visibility pulumi.StringInput +} + +func (CodespacesOrganizationSecretArgs) ElementType() reflect.Type { + return reflect.TypeOf((*codespacesOrganizationSecretArgs)(nil)).Elem() +} + +type CodespacesOrganizationSecretInput interface { + pulumi.Input + + ToCodespacesOrganizationSecretOutput() CodespacesOrganizationSecretOutput + ToCodespacesOrganizationSecretOutputWithContext(ctx context.Context) CodespacesOrganizationSecretOutput +} + +func (*CodespacesOrganizationSecret) ElementType() reflect.Type { + return reflect.TypeOf((**CodespacesOrganizationSecret)(nil)).Elem() +} + +func (i *CodespacesOrganizationSecret) ToCodespacesOrganizationSecretOutput() CodespacesOrganizationSecretOutput { + return i.ToCodespacesOrganizationSecretOutputWithContext(context.Background()) +} + +func (i *CodespacesOrganizationSecret) ToCodespacesOrganizationSecretOutputWithContext(ctx context.Context) CodespacesOrganizationSecretOutput { + return pulumi.ToOutputWithContext(ctx, i).(CodespacesOrganizationSecretOutput) +} + +// CodespacesOrganizationSecretArrayInput is an input type that accepts CodespacesOrganizationSecretArray and CodespacesOrganizationSecretArrayOutput values. +// You can construct a concrete instance of `CodespacesOrganizationSecretArrayInput` via: +// +// CodespacesOrganizationSecretArray{ CodespacesOrganizationSecretArgs{...} } +type CodespacesOrganizationSecretArrayInput interface { + pulumi.Input + + ToCodespacesOrganizationSecretArrayOutput() CodespacesOrganizationSecretArrayOutput + ToCodespacesOrganizationSecretArrayOutputWithContext(context.Context) CodespacesOrganizationSecretArrayOutput +} + +type CodespacesOrganizationSecretArray []CodespacesOrganizationSecretInput + +func (CodespacesOrganizationSecretArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*CodespacesOrganizationSecret)(nil)).Elem() +} + +func (i CodespacesOrganizationSecretArray) ToCodespacesOrganizationSecretArrayOutput() CodespacesOrganizationSecretArrayOutput { + return i.ToCodespacesOrganizationSecretArrayOutputWithContext(context.Background()) +} + +func (i CodespacesOrganizationSecretArray) ToCodespacesOrganizationSecretArrayOutputWithContext(ctx context.Context) CodespacesOrganizationSecretArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(CodespacesOrganizationSecretArrayOutput) +} + +// CodespacesOrganizationSecretMapInput is an input type that accepts CodespacesOrganizationSecretMap and CodespacesOrganizationSecretMapOutput values. +// You can construct a concrete instance of `CodespacesOrganizationSecretMapInput` via: +// +// CodespacesOrganizationSecretMap{ "key": CodespacesOrganizationSecretArgs{...} } +type CodespacesOrganizationSecretMapInput interface { + pulumi.Input + + ToCodespacesOrganizationSecretMapOutput() CodespacesOrganizationSecretMapOutput + ToCodespacesOrganizationSecretMapOutputWithContext(context.Context) CodespacesOrganizationSecretMapOutput +} + +type CodespacesOrganizationSecretMap map[string]CodespacesOrganizationSecretInput + +func (CodespacesOrganizationSecretMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*CodespacesOrganizationSecret)(nil)).Elem() +} + +func (i CodespacesOrganizationSecretMap) ToCodespacesOrganizationSecretMapOutput() CodespacesOrganizationSecretMapOutput { + return i.ToCodespacesOrganizationSecretMapOutputWithContext(context.Background()) +} + +func (i CodespacesOrganizationSecretMap) ToCodespacesOrganizationSecretMapOutputWithContext(ctx context.Context) CodespacesOrganizationSecretMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(CodespacesOrganizationSecretMapOutput) +} + +type CodespacesOrganizationSecretOutput struct{ *pulumi.OutputState } + +func (CodespacesOrganizationSecretOutput) ElementType() reflect.Type { + return reflect.TypeOf((**CodespacesOrganizationSecret)(nil)).Elem() +} + +func (o CodespacesOrganizationSecretOutput) ToCodespacesOrganizationSecretOutput() CodespacesOrganizationSecretOutput { + return o +} + +func (o CodespacesOrganizationSecretOutput) ToCodespacesOrganizationSecretOutputWithContext(ctx context.Context) CodespacesOrganizationSecretOutput { + return o +} + +// Date of codespacesSecret creation. +func (o CodespacesOrganizationSecretOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *CodespacesOrganizationSecret) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) +} + +// Encrypted value of the secret using the GitHub public key in Base64 format. +func (o CodespacesOrganizationSecretOutput) EncryptedValue() pulumi.StringPtrOutput { + return o.ApplyT(func(v *CodespacesOrganizationSecret) pulumi.StringPtrOutput { return v.EncryptedValue }).(pulumi.StringPtrOutput) +} + +// Plaintext value of the secret to be encrypted +func (o CodespacesOrganizationSecretOutput) PlaintextValue() pulumi.StringPtrOutput { + return o.ApplyT(func(v *CodespacesOrganizationSecret) pulumi.StringPtrOutput { return v.PlaintextValue }).(pulumi.StringPtrOutput) +} + +// Name of the secret +func (o CodespacesOrganizationSecretOutput) SecretName() pulumi.StringOutput { + return o.ApplyT(func(v *CodespacesOrganizationSecret) pulumi.StringOutput { return v.SecretName }).(pulumi.StringOutput) +} + +// An array of repository ids that can access the organization secret. +func (o CodespacesOrganizationSecretOutput) SelectedRepositoryIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v *CodespacesOrganizationSecret) pulumi.IntArrayOutput { return v.SelectedRepositoryIds }).(pulumi.IntArrayOutput) +} + +// Date of codespacesSecret update. +func (o CodespacesOrganizationSecretOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *CodespacesOrganizationSecret) pulumi.StringOutput { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// Configures the access that repositories have to the organization secret. +// Must be one of `all`, `private`, `selected`. `selectedRepositoryIds` is required if set to `selected`. +func (o CodespacesOrganizationSecretOutput) Visibility() pulumi.StringOutput { + return o.ApplyT(func(v *CodespacesOrganizationSecret) pulumi.StringOutput { return v.Visibility }).(pulumi.StringOutput) +} + +type CodespacesOrganizationSecretArrayOutput struct{ *pulumi.OutputState } + +func (CodespacesOrganizationSecretArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*CodespacesOrganizationSecret)(nil)).Elem() +} + +func (o CodespacesOrganizationSecretArrayOutput) ToCodespacesOrganizationSecretArrayOutput() CodespacesOrganizationSecretArrayOutput { + return o +} + +func (o CodespacesOrganizationSecretArrayOutput) ToCodespacesOrganizationSecretArrayOutputWithContext(ctx context.Context) CodespacesOrganizationSecretArrayOutput { + return o +} + +func (o CodespacesOrganizationSecretArrayOutput) Index(i pulumi.IntInput) CodespacesOrganizationSecretOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CodespacesOrganizationSecret { + return vs[0].([]*CodespacesOrganizationSecret)[vs[1].(int)] + }).(CodespacesOrganizationSecretOutput) +} + +type CodespacesOrganizationSecretMapOutput struct{ *pulumi.OutputState } + +func (CodespacesOrganizationSecretMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*CodespacesOrganizationSecret)(nil)).Elem() +} + +func (o CodespacesOrganizationSecretMapOutput) ToCodespacesOrganizationSecretMapOutput() CodespacesOrganizationSecretMapOutput { + return o +} + +func (o CodespacesOrganizationSecretMapOutput) ToCodespacesOrganizationSecretMapOutputWithContext(ctx context.Context) CodespacesOrganizationSecretMapOutput { + return o +} + +func (o CodespacesOrganizationSecretMapOutput) MapIndex(k pulumi.StringInput) CodespacesOrganizationSecretOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CodespacesOrganizationSecret { + return vs[0].(map[string]*CodespacesOrganizationSecret)[vs[1].(string)] + }).(CodespacesOrganizationSecretOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*CodespacesOrganizationSecretInput)(nil)).Elem(), &CodespacesOrganizationSecret{}) + pulumi.RegisterInputType(reflect.TypeOf((*CodespacesOrganizationSecretArrayInput)(nil)).Elem(), CodespacesOrganizationSecretArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*CodespacesOrganizationSecretMapInput)(nil)).Elem(), CodespacesOrganizationSecretMap{}) + pulumi.RegisterOutputType(CodespacesOrganizationSecretOutput{}) + pulumi.RegisterOutputType(CodespacesOrganizationSecretArrayOutput{}) + pulumi.RegisterOutputType(CodespacesOrganizationSecretMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/codespacesOrganizationSecretRepositories.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/codespacesOrganizationSecretRepositories.go new file mode 100644 index 000000000..92b486599 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/codespacesOrganizationSecretRepositories.go @@ -0,0 +1,286 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to manage repository allow list for existing GitHub Codespaces secrets within your GitHub organization. +// +// You must have write access to an organization secret to use this resource. +// +// This resource is only applicable when `visibility` of the existing organization secret has been set to `selected`. +// +// ## Example Usage +// +// ```go +// 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 { +// repo, err := github.GetRepository(ctx, &github.LookupRepositoryArgs{ +// FullName: pulumi.StringRef("my-org/repo"), +// }, nil) +// if err != nil { +// return err +// } +// _, err = github.NewCodespacesOrganizationSecretRepositories(ctx, "org_secret_repos", &github.CodespacesOrganizationSecretRepositoriesArgs{ +// SecretName: pulumi.String("existing_secret_name"), +// SelectedRepositoryIds: pulumi.IntArray{ +// pulumi.Int(pulumi.Int(repo.RepoId)), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using an ID made up of the secret name: +// +// ```sh +// $ pulumi import github:index/codespacesOrganizationSecretRepositories:CodespacesOrganizationSecretRepositories org_secret_repos existing_secret_name +// ``` +type CodespacesOrganizationSecretRepositories struct { + pulumi.CustomResourceState + + // Name of the existing secret + SecretName pulumi.StringOutput `pulumi:"secretName"` + // An array of repository ids that can access the organization secret. + SelectedRepositoryIds pulumi.IntArrayOutput `pulumi:"selectedRepositoryIds"` +} + +// NewCodespacesOrganizationSecretRepositories registers a new resource with the given unique name, arguments, and options. +func NewCodespacesOrganizationSecretRepositories(ctx *pulumi.Context, + name string, args *CodespacesOrganizationSecretRepositoriesArgs, opts ...pulumi.ResourceOption) (*CodespacesOrganizationSecretRepositories, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.SecretName == nil { + return nil, errors.New("invalid value for required argument 'SecretName'") + } + if args.SelectedRepositoryIds == nil { + return nil, errors.New("invalid value for required argument 'SelectedRepositoryIds'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource CodespacesOrganizationSecretRepositories + err := ctx.RegisterResource("github:index/codespacesOrganizationSecretRepositories:CodespacesOrganizationSecretRepositories", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetCodespacesOrganizationSecretRepositories gets an existing CodespacesOrganizationSecretRepositories 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 GetCodespacesOrganizationSecretRepositories(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *CodespacesOrganizationSecretRepositoriesState, opts ...pulumi.ResourceOption) (*CodespacesOrganizationSecretRepositories, error) { + var resource CodespacesOrganizationSecretRepositories + err := ctx.ReadResource("github:index/codespacesOrganizationSecretRepositories:CodespacesOrganizationSecretRepositories", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering CodespacesOrganizationSecretRepositories resources. +type codespacesOrganizationSecretRepositoriesState struct { + // Name of the existing secret + SecretName *string `pulumi:"secretName"` + // An array of repository ids that can access the organization secret. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` +} + +type CodespacesOrganizationSecretRepositoriesState struct { + // Name of the existing secret + SecretName pulumi.StringPtrInput + // An array of repository ids that can access the organization secret. + SelectedRepositoryIds pulumi.IntArrayInput +} + +func (CodespacesOrganizationSecretRepositoriesState) ElementType() reflect.Type { + return reflect.TypeOf((*codespacesOrganizationSecretRepositoriesState)(nil)).Elem() +} + +type codespacesOrganizationSecretRepositoriesArgs struct { + // Name of the existing secret + SecretName string `pulumi:"secretName"` + // An array of repository ids that can access the organization secret. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` +} + +// The set of arguments for constructing a CodespacesOrganizationSecretRepositories resource. +type CodespacesOrganizationSecretRepositoriesArgs struct { + // Name of the existing secret + SecretName pulumi.StringInput + // An array of repository ids that can access the organization secret. + SelectedRepositoryIds pulumi.IntArrayInput +} + +func (CodespacesOrganizationSecretRepositoriesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*codespacesOrganizationSecretRepositoriesArgs)(nil)).Elem() +} + +type CodespacesOrganizationSecretRepositoriesInput interface { + pulumi.Input + + ToCodespacesOrganizationSecretRepositoriesOutput() CodespacesOrganizationSecretRepositoriesOutput + ToCodespacesOrganizationSecretRepositoriesOutputWithContext(ctx context.Context) CodespacesOrganizationSecretRepositoriesOutput +} + +func (*CodespacesOrganizationSecretRepositories) ElementType() reflect.Type { + return reflect.TypeOf((**CodespacesOrganizationSecretRepositories)(nil)).Elem() +} + +func (i *CodespacesOrganizationSecretRepositories) ToCodespacesOrganizationSecretRepositoriesOutput() CodespacesOrganizationSecretRepositoriesOutput { + return i.ToCodespacesOrganizationSecretRepositoriesOutputWithContext(context.Background()) +} + +func (i *CodespacesOrganizationSecretRepositories) ToCodespacesOrganizationSecretRepositoriesOutputWithContext(ctx context.Context) CodespacesOrganizationSecretRepositoriesOutput { + return pulumi.ToOutputWithContext(ctx, i).(CodespacesOrganizationSecretRepositoriesOutput) +} + +// CodespacesOrganizationSecretRepositoriesArrayInput is an input type that accepts CodespacesOrganizationSecretRepositoriesArray and CodespacesOrganizationSecretRepositoriesArrayOutput values. +// You can construct a concrete instance of `CodespacesOrganizationSecretRepositoriesArrayInput` via: +// +// CodespacesOrganizationSecretRepositoriesArray{ CodespacesOrganizationSecretRepositoriesArgs{...} } +type CodespacesOrganizationSecretRepositoriesArrayInput interface { + pulumi.Input + + ToCodespacesOrganizationSecretRepositoriesArrayOutput() CodespacesOrganizationSecretRepositoriesArrayOutput + ToCodespacesOrganizationSecretRepositoriesArrayOutputWithContext(context.Context) CodespacesOrganizationSecretRepositoriesArrayOutput +} + +type CodespacesOrganizationSecretRepositoriesArray []CodespacesOrganizationSecretRepositoriesInput + +func (CodespacesOrganizationSecretRepositoriesArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*CodespacesOrganizationSecretRepositories)(nil)).Elem() +} + +func (i CodespacesOrganizationSecretRepositoriesArray) ToCodespacesOrganizationSecretRepositoriesArrayOutput() CodespacesOrganizationSecretRepositoriesArrayOutput { + return i.ToCodespacesOrganizationSecretRepositoriesArrayOutputWithContext(context.Background()) +} + +func (i CodespacesOrganizationSecretRepositoriesArray) ToCodespacesOrganizationSecretRepositoriesArrayOutputWithContext(ctx context.Context) CodespacesOrganizationSecretRepositoriesArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(CodespacesOrganizationSecretRepositoriesArrayOutput) +} + +// CodespacesOrganizationSecretRepositoriesMapInput is an input type that accepts CodespacesOrganizationSecretRepositoriesMap and CodespacesOrganizationSecretRepositoriesMapOutput values. +// You can construct a concrete instance of `CodespacesOrganizationSecretRepositoriesMapInput` via: +// +// CodespacesOrganizationSecretRepositoriesMap{ "key": CodespacesOrganizationSecretRepositoriesArgs{...} } +type CodespacesOrganizationSecretRepositoriesMapInput interface { + pulumi.Input + + ToCodespacesOrganizationSecretRepositoriesMapOutput() CodespacesOrganizationSecretRepositoriesMapOutput + ToCodespacesOrganizationSecretRepositoriesMapOutputWithContext(context.Context) CodespacesOrganizationSecretRepositoriesMapOutput +} + +type CodespacesOrganizationSecretRepositoriesMap map[string]CodespacesOrganizationSecretRepositoriesInput + +func (CodespacesOrganizationSecretRepositoriesMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*CodespacesOrganizationSecretRepositories)(nil)).Elem() +} + +func (i CodespacesOrganizationSecretRepositoriesMap) ToCodespacesOrganizationSecretRepositoriesMapOutput() CodespacesOrganizationSecretRepositoriesMapOutput { + return i.ToCodespacesOrganizationSecretRepositoriesMapOutputWithContext(context.Background()) +} + +func (i CodespacesOrganizationSecretRepositoriesMap) ToCodespacesOrganizationSecretRepositoriesMapOutputWithContext(ctx context.Context) CodespacesOrganizationSecretRepositoriesMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(CodespacesOrganizationSecretRepositoriesMapOutput) +} + +type CodespacesOrganizationSecretRepositoriesOutput struct{ *pulumi.OutputState } + +func (CodespacesOrganizationSecretRepositoriesOutput) ElementType() reflect.Type { + return reflect.TypeOf((**CodespacesOrganizationSecretRepositories)(nil)).Elem() +} + +func (o CodespacesOrganizationSecretRepositoriesOutput) ToCodespacesOrganizationSecretRepositoriesOutput() CodespacesOrganizationSecretRepositoriesOutput { + return o +} + +func (o CodespacesOrganizationSecretRepositoriesOutput) ToCodespacesOrganizationSecretRepositoriesOutputWithContext(ctx context.Context) CodespacesOrganizationSecretRepositoriesOutput { + return o +} + +// Name of the existing secret +func (o CodespacesOrganizationSecretRepositoriesOutput) SecretName() pulumi.StringOutput { + return o.ApplyT(func(v *CodespacesOrganizationSecretRepositories) pulumi.StringOutput { return v.SecretName }).(pulumi.StringOutput) +} + +// An array of repository ids that can access the organization secret. +func (o CodespacesOrganizationSecretRepositoriesOutput) SelectedRepositoryIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v *CodespacesOrganizationSecretRepositories) pulumi.IntArrayOutput { + return v.SelectedRepositoryIds + }).(pulumi.IntArrayOutput) +} + +type CodespacesOrganizationSecretRepositoriesArrayOutput struct{ *pulumi.OutputState } + +func (CodespacesOrganizationSecretRepositoriesArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*CodespacesOrganizationSecretRepositories)(nil)).Elem() +} + +func (o CodespacesOrganizationSecretRepositoriesArrayOutput) ToCodespacesOrganizationSecretRepositoriesArrayOutput() CodespacesOrganizationSecretRepositoriesArrayOutput { + return o +} + +func (o CodespacesOrganizationSecretRepositoriesArrayOutput) ToCodespacesOrganizationSecretRepositoriesArrayOutputWithContext(ctx context.Context) CodespacesOrganizationSecretRepositoriesArrayOutput { + return o +} + +func (o CodespacesOrganizationSecretRepositoriesArrayOutput) Index(i pulumi.IntInput) CodespacesOrganizationSecretRepositoriesOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CodespacesOrganizationSecretRepositories { + return vs[0].([]*CodespacesOrganizationSecretRepositories)[vs[1].(int)] + }).(CodespacesOrganizationSecretRepositoriesOutput) +} + +type CodespacesOrganizationSecretRepositoriesMapOutput struct{ *pulumi.OutputState } + +func (CodespacesOrganizationSecretRepositoriesMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*CodespacesOrganizationSecretRepositories)(nil)).Elem() +} + +func (o CodespacesOrganizationSecretRepositoriesMapOutput) ToCodespacesOrganizationSecretRepositoriesMapOutput() CodespacesOrganizationSecretRepositoriesMapOutput { + return o +} + +func (o CodespacesOrganizationSecretRepositoriesMapOutput) ToCodespacesOrganizationSecretRepositoriesMapOutputWithContext(ctx context.Context) CodespacesOrganizationSecretRepositoriesMapOutput { + return o +} + +func (o CodespacesOrganizationSecretRepositoriesMapOutput) MapIndex(k pulumi.StringInput) CodespacesOrganizationSecretRepositoriesOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CodespacesOrganizationSecretRepositories { + return vs[0].(map[string]*CodespacesOrganizationSecretRepositories)[vs[1].(string)] + }).(CodespacesOrganizationSecretRepositoriesOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*CodespacesOrganizationSecretRepositoriesInput)(nil)).Elem(), &CodespacesOrganizationSecretRepositories{}) + pulumi.RegisterInputType(reflect.TypeOf((*CodespacesOrganizationSecretRepositoriesArrayInput)(nil)).Elem(), CodespacesOrganizationSecretRepositoriesArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*CodespacesOrganizationSecretRepositoriesMapInput)(nil)).Elem(), CodespacesOrganizationSecretRepositoriesMap{}) + pulumi.RegisterOutputType(CodespacesOrganizationSecretRepositoriesOutput{}) + pulumi.RegisterOutputType(CodespacesOrganizationSecretRepositoriesArrayOutput{}) + pulumi.RegisterOutputType(CodespacesOrganizationSecretRepositoriesMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/codespacesSecret.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/codespacesSecret.go new file mode 100644 index 000000000..d53ac63fa --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/codespacesSecret.go @@ -0,0 +1,321 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage GitHub Codespaces secrets within your GitHub repositories. +// You must have write access to a repository to use this resource. +// +// Secret values are encrypted using the [Go '/crypto/box' module](https://godoc.org/golang.org/x/crypto/nacl/box) which is +// interoperable with [libsodium](https://libsodium.gitbook.io/doc/). Libsodium is used by GitHub to decrypt secret values. +// +// For the purposes of security, the contents of the `plaintextValue` field have been marked as `sensitive` to Terraform, +// but it is important to note that **this does not hide it from state files**. You should treat state as sensitive always. +// It is also advised that you do not store plaintext values in your code but rather populate the `encryptedValue` +// using fields from a resource, data source or variable as, while encrypted in state, these will be easily accessible +// in your code. See below for an example of this abstraction. +// +// ## Import +// +// This resource can be imported using an ID made up of the `repository` and `secretName`: +// +// ```sh +// $ pulumi import github:index/codespacesSecret:CodespacesSecret example_secret example_repository/example_secret_name +// ``` +// +// NOTE: the implementation is limited in that it won't fetch the value of the +// `plaintextValue` or `encryptedValue` fields when importing. You may need to ignore changes for these as a workaround. +type CodespacesSecret struct { + pulumi.CustomResourceState + + // Date of codespacesSecret creation. + CreatedAt pulumi.StringOutput `pulumi:"createdAt"` + // Encrypted value of the secret using the GitHub public key in Base64 format. + EncryptedValue pulumi.StringPtrOutput `pulumi:"encryptedValue"` + // Plaintext value of the secret to be encrypted + PlaintextValue pulumi.StringPtrOutput `pulumi:"plaintextValue"` + // Name of the repository + Repository pulumi.StringOutput `pulumi:"repository"` + // Name of the secret + SecretName pulumi.StringOutput `pulumi:"secretName"` + // Date of codespacesSecret update. + UpdatedAt pulumi.StringOutput `pulumi:"updatedAt"` +} + +// NewCodespacesSecret registers a new resource with the given unique name, arguments, and options. +func NewCodespacesSecret(ctx *pulumi.Context, + name string, args *CodespacesSecretArgs, opts ...pulumi.ResourceOption) (*CodespacesSecret, 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.SecretName == nil { + return nil, errors.New("invalid value for required argument 'SecretName'") + } + if args.EncryptedValue != nil { + args.EncryptedValue = pulumi.ToSecret(args.EncryptedValue).(pulumi.StringPtrInput) + } + if args.PlaintextValue != nil { + args.PlaintextValue = pulumi.ToSecret(args.PlaintextValue).(pulumi.StringPtrInput) + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "encryptedValue", + "plaintextValue", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource CodespacesSecret + err := ctx.RegisterResource("github:index/codespacesSecret:CodespacesSecret", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetCodespacesSecret gets an existing CodespacesSecret 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 GetCodespacesSecret(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *CodespacesSecretState, opts ...pulumi.ResourceOption) (*CodespacesSecret, error) { + var resource CodespacesSecret + err := ctx.ReadResource("github:index/codespacesSecret:CodespacesSecret", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering CodespacesSecret resources. +type codespacesSecretState struct { + // Date of codespacesSecret creation. + CreatedAt *string `pulumi:"createdAt"` + // Encrypted value of the secret using the GitHub public key in Base64 format. + EncryptedValue *string `pulumi:"encryptedValue"` + // Plaintext value of the secret to be encrypted + PlaintextValue *string `pulumi:"plaintextValue"` + // Name of the repository + Repository *string `pulumi:"repository"` + // Name of the secret + SecretName *string `pulumi:"secretName"` + // Date of codespacesSecret update. + UpdatedAt *string `pulumi:"updatedAt"` +} + +type CodespacesSecretState struct { + // Date of codespacesSecret creation. + CreatedAt pulumi.StringPtrInput + // Encrypted value of the secret using the GitHub public key in Base64 format. + EncryptedValue pulumi.StringPtrInput + // Plaintext value of the secret to be encrypted + PlaintextValue pulumi.StringPtrInput + // Name of the repository + Repository pulumi.StringPtrInput + // Name of the secret + SecretName pulumi.StringPtrInput + // Date of codespacesSecret update. + UpdatedAt pulumi.StringPtrInput +} + +func (CodespacesSecretState) ElementType() reflect.Type { + return reflect.TypeOf((*codespacesSecretState)(nil)).Elem() +} + +type codespacesSecretArgs struct { + // Encrypted value of the secret using the GitHub public key in Base64 format. + EncryptedValue *string `pulumi:"encryptedValue"` + // Plaintext value of the secret to be encrypted + PlaintextValue *string `pulumi:"plaintextValue"` + // Name of the repository + Repository string `pulumi:"repository"` + // Name of the secret + SecretName string `pulumi:"secretName"` +} + +// The set of arguments for constructing a CodespacesSecret resource. +type CodespacesSecretArgs struct { + // Encrypted value of the secret using the GitHub public key in Base64 format. + EncryptedValue pulumi.StringPtrInput + // Plaintext value of the secret to be encrypted + PlaintextValue pulumi.StringPtrInput + // Name of the repository + Repository pulumi.StringInput + // Name of the secret + SecretName pulumi.StringInput +} + +func (CodespacesSecretArgs) ElementType() reflect.Type { + return reflect.TypeOf((*codespacesSecretArgs)(nil)).Elem() +} + +type CodespacesSecretInput interface { + pulumi.Input + + ToCodespacesSecretOutput() CodespacesSecretOutput + ToCodespacesSecretOutputWithContext(ctx context.Context) CodespacesSecretOutput +} + +func (*CodespacesSecret) ElementType() reflect.Type { + return reflect.TypeOf((**CodespacesSecret)(nil)).Elem() +} + +func (i *CodespacesSecret) ToCodespacesSecretOutput() CodespacesSecretOutput { + return i.ToCodespacesSecretOutputWithContext(context.Background()) +} + +func (i *CodespacesSecret) ToCodespacesSecretOutputWithContext(ctx context.Context) CodespacesSecretOutput { + return pulumi.ToOutputWithContext(ctx, i).(CodespacesSecretOutput) +} + +// CodespacesSecretArrayInput is an input type that accepts CodespacesSecretArray and CodespacesSecretArrayOutput values. +// You can construct a concrete instance of `CodespacesSecretArrayInput` via: +// +// CodespacesSecretArray{ CodespacesSecretArgs{...} } +type CodespacesSecretArrayInput interface { + pulumi.Input + + ToCodespacesSecretArrayOutput() CodespacesSecretArrayOutput + ToCodespacesSecretArrayOutputWithContext(context.Context) CodespacesSecretArrayOutput +} + +type CodespacesSecretArray []CodespacesSecretInput + +func (CodespacesSecretArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*CodespacesSecret)(nil)).Elem() +} + +func (i CodespacesSecretArray) ToCodespacesSecretArrayOutput() CodespacesSecretArrayOutput { + return i.ToCodespacesSecretArrayOutputWithContext(context.Background()) +} + +func (i CodespacesSecretArray) ToCodespacesSecretArrayOutputWithContext(ctx context.Context) CodespacesSecretArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(CodespacesSecretArrayOutput) +} + +// CodespacesSecretMapInput is an input type that accepts CodespacesSecretMap and CodespacesSecretMapOutput values. +// You can construct a concrete instance of `CodespacesSecretMapInput` via: +// +// CodespacesSecretMap{ "key": CodespacesSecretArgs{...} } +type CodespacesSecretMapInput interface { + pulumi.Input + + ToCodespacesSecretMapOutput() CodespacesSecretMapOutput + ToCodespacesSecretMapOutputWithContext(context.Context) CodespacesSecretMapOutput +} + +type CodespacesSecretMap map[string]CodespacesSecretInput + +func (CodespacesSecretMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*CodespacesSecret)(nil)).Elem() +} + +func (i CodespacesSecretMap) ToCodespacesSecretMapOutput() CodespacesSecretMapOutput { + return i.ToCodespacesSecretMapOutputWithContext(context.Background()) +} + +func (i CodespacesSecretMap) ToCodespacesSecretMapOutputWithContext(ctx context.Context) CodespacesSecretMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(CodespacesSecretMapOutput) +} + +type CodespacesSecretOutput struct{ *pulumi.OutputState } + +func (CodespacesSecretOutput) ElementType() reflect.Type { + return reflect.TypeOf((**CodespacesSecret)(nil)).Elem() +} + +func (o CodespacesSecretOutput) ToCodespacesSecretOutput() CodespacesSecretOutput { + return o +} + +func (o CodespacesSecretOutput) ToCodespacesSecretOutputWithContext(ctx context.Context) CodespacesSecretOutput { + return o +} + +// Date of codespacesSecret creation. +func (o CodespacesSecretOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *CodespacesSecret) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) +} + +// Encrypted value of the secret using the GitHub public key in Base64 format. +func (o CodespacesSecretOutput) EncryptedValue() pulumi.StringPtrOutput { + return o.ApplyT(func(v *CodespacesSecret) pulumi.StringPtrOutput { return v.EncryptedValue }).(pulumi.StringPtrOutput) +} + +// Plaintext value of the secret to be encrypted +func (o CodespacesSecretOutput) PlaintextValue() pulumi.StringPtrOutput { + return o.ApplyT(func(v *CodespacesSecret) pulumi.StringPtrOutput { return v.PlaintextValue }).(pulumi.StringPtrOutput) +} + +// Name of the repository +func (o CodespacesSecretOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *CodespacesSecret) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// Name of the secret +func (o CodespacesSecretOutput) SecretName() pulumi.StringOutput { + return o.ApplyT(func(v *CodespacesSecret) pulumi.StringOutput { return v.SecretName }).(pulumi.StringOutput) +} + +// Date of codespacesSecret update. +func (o CodespacesSecretOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *CodespacesSecret) pulumi.StringOutput { return v.UpdatedAt }).(pulumi.StringOutput) +} + +type CodespacesSecretArrayOutput struct{ *pulumi.OutputState } + +func (CodespacesSecretArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*CodespacesSecret)(nil)).Elem() +} + +func (o CodespacesSecretArrayOutput) ToCodespacesSecretArrayOutput() CodespacesSecretArrayOutput { + return o +} + +func (o CodespacesSecretArrayOutput) ToCodespacesSecretArrayOutputWithContext(ctx context.Context) CodespacesSecretArrayOutput { + return o +} + +func (o CodespacesSecretArrayOutput) Index(i pulumi.IntInput) CodespacesSecretOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CodespacesSecret { + return vs[0].([]*CodespacesSecret)[vs[1].(int)] + }).(CodespacesSecretOutput) +} + +type CodespacesSecretMapOutput struct{ *pulumi.OutputState } + +func (CodespacesSecretMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*CodespacesSecret)(nil)).Elem() +} + +func (o CodespacesSecretMapOutput) ToCodespacesSecretMapOutput() CodespacesSecretMapOutput { + return o +} + +func (o CodespacesSecretMapOutput) ToCodespacesSecretMapOutputWithContext(ctx context.Context) CodespacesSecretMapOutput { + return o +} + +func (o CodespacesSecretMapOutput) MapIndex(k pulumi.StringInput) CodespacesSecretOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CodespacesSecret { + return vs[0].(map[string]*CodespacesSecret)[vs[1].(string)] + }).(CodespacesSecretOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*CodespacesSecretInput)(nil)).Elem(), &CodespacesSecret{}) + pulumi.RegisterInputType(reflect.TypeOf((*CodespacesSecretArrayInput)(nil)).Elem(), CodespacesSecretArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*CodespacesSecretMapInput)(nil)).Elem(), CodespacesSecretMap{}) + pulumi.RegisterOutputType(CodespacesSecretOutput{}) + pulumi.RegisterOutputType(CodespacesSecretArrayOutput{}) + pulumi.RegisterOutputType(CodespacesSecretMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/codespacesUserSecret.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/codespacesUserSecret.go new file mode 100644 index 000000000..aa563afa3 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/codespacesUserSecret.go @@ -0,0 +1,318 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage GitHub Codespaces secrets within your GitHub user. +// You must have write access to a repository to use this resource. +// +// Secret values are encrypted using the [Go '/crypto/box' module](https://godoc.org/golang.org/x/crypto/nacl/box) which is +// interoperable with [libsodium](https://libsodium.gitbook.io/doc/). Libsodium is used by GitHub to decrypt secret values. +// +// For the purposes of security, the contents of the `plaintextValue` field have been marked as `sensitive` to Terraform, +// but it is important to note that **this does not hide it from state files**. You should treat state as sensitive always. +// It is also advised that you do not store plaintext values in your code but rather populate the `encryptedValue` +// using fields from a resource, data source or variable as, while encrypted in state, these will be easily accessible +// in your code. See below for an example of this abstraction. +// +// ## Import +// +// This resource can be imported using an ID made up of the secret name: +// +// ```sh +// $ pulumi import github:index/codespacesUserSecret:CodespacesUserSecret test_secret test_secret_name +// ``` +// +// NOTE: the implementation is limited in that it won't fetch the value of the +// `plaintextValue` or `encryptedValue` fields when importing. You may need to ignore changes for these as a workaround. +type CodespacesUserSecret struct { + pulumi.CustomResourceState + + // Date of codespacesSecret creation. + CreatedAt pulumi.StringOutput `pulumi:"createdAt"` + // Encrypted value of the secret using the GitHub public key in Base64 format. + EncryptedValue pulumi.StringPtrOutput `pulumi:"encryptedValue"` + // Plaintext value of the secret to be encrypted + PlaintextValue pulumi.StringPtrOutput `pulumi:"plaintextValue"` + // Name of the secret + SecretName pulumi.StringOutput `pulumi:"secretName"` + // An array of repository ids that can access the user secret. + SelectedRepositoryIds pulumi.IntArrayOutput `pulumi:"selectedRepositoryIds"` + // Date of codespacesSecret update. + UpdatedAt pulumi.StringOutput `pulumi:"updatedAt"` +} + +// NewCodespacesUserSecret registers a new resource with the given unique name, arguments, and options. +func NewCodespacesUserSecret(ctx *pulumi.Context, + name string, args *CodespacesUserSecretArgs, opts ...pulumi.ResourceOption) (*CodespacesUserSecret, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.SecretName == nil { + return nil, errors.New("invalid value for required argument 'SecretName'") + } + if args.EncryptedValue != nil { + args.EncryptedValue = pulumi.ToSecret(args.EncryptedValue).(pulumi.StringPtrInput) + } + if args.PlaintextValue != nil { + args.PlaintextValue = pulumi.ToSecret(args.PlaintextValue).(pulumi.StringPtrInput) + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "encryptedValue", + "plaintextValue", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource CodespacesUserSecret + err := ctx.RegisterResource("github:index/codespacesUserSecret:CodespacesUserSecret", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetCodespacesUserSecret gets an existing CodespacesUserSecret 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 GetCodespacesUserSecret(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *CodespacesUserSecretState, opts ...pulumi.ResourceOption) (*CodespacesUserSecret, error) { + var resource CodespacesUserSecret + err := ctx.ReadResource("github:index/codespacesUserSecret:CodespacesUserSecret", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering CodespacesUserSecret resources. +type codespacesUserSecretState struct { + // Date of codespacesSecret creation. + CreatedAt *string `pulumi:"createdAt"` + // Encrypted value of the secret using the GitHub public key in Base64 format. + EncryptedValue *string `pulumi:"encryptedValue"` + // Plaintext value of the secret to be encrypted + PlaintextValue *string `pulumi:"plaintextValue"` + // Name of the secret + SecretName *string `pulumi:"secretName"` + // An array of repository ids that can access the user secret. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` + // Date of codespacesSecret update. + UpdatedAt *string `pulumi:"updatedAt"` +} + +type CodespacesUserSecretState struct { + // Date of codespacesSecret creation. + CreatedAt pulumi.StringPtrInput + // Encrypted value of the secret using the GitHub public key in Base64 format. + EncryptedValue pulumi.StringPtrInput + // Plaintext value of the secret to be encrypted + PlaintextValue pulumi.StringPtrInput + // Name of the secret + SecretName pulumi.StringPtrInput + // An array of repository ids that can access the user secret. + SelectedRepositoryIds pulumi.IntArrayInput + // Date of codespacesSecret update. + UpdatedAt pulumi.StringPtrInput +} + +func (CodespacesUserSecretState) ElementType() reflect.Type { + return reflect.TypeOf((*codespacesUserSecretState)(nil)).Elem() +} + +type codespacesUserSecretArgs struct { + // Encrypted value of the secret using the GitHub public key in Base64 format. + EncryptedValue *string `pulumi:"encryptedValue"` + // Plaintext value of the secret to be encrypted + PlaintextValue *string `pulumi:"plaintextValue"` + // Name of the secret + SecretName string `pulumi:"secretName"` + // An array of repository ids that can access the user secret. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` +} + +// The set of arguments for constructing a CodespacesUserSecret resource. +type CodespacesUserSecretArgs struct { + // Encrypted value of the secret using the GitHub public key in Base64 format. + EncryptedValue pulumi.StringPtrInput + // Plaintext value of the secret to be encrypted + PlaintextValue pulumi.StringPtrInput + // Name of the secret + SecretName pulumi.StringInput + // An array of repository ids that can access the user secret. + SelectedRepositoryIds pulumi.IntArrayInput +} + +func (CodespacesUserSecretArgs) ElementType() reflect.Type { + return reflect.TypeOf((*codespacesUserSecretArgs)(nil)).Elem() +} + +type CodespacesUserSecretInput interface { + pulumi.Input + + ToCodespacesUserSecretOutput() CodespacesUserSecretOutput + ToCodespacesUserSecretOutputWithContext(ctx context.Context) CodespacesUserSecretOutput +} + +func (*CodespacesUserSecret) ElementType() reflect.Type { + return reflect.TypeOf((**CodespacesUserSecret)(nil)).Elem() +} + +func (i *CodespacesUserSecret) ToCodespacesUserSecretOutput() CodespacesUserSecretOutput { + return i.ToCodespacesUserSecretOutputWithContext(context.Background()) +} + +func (i *CodespacesUserSecret) ToCodespacesUserSecretOutputWithContext(ctx context.Context) CodespacesUserSecretOutput { + return pulumi.ToOutputWithContext(ctx, i).(CodespacesUserSecretOutput) +} + +// CodespacesUserSecretArrayInput is an input type that accepts CodespacesUserSecretArray and CodespacesUserSecretArrayOutput values. +// You can construct a concrete instance of `CodespacesUserSecretArrayInput` via: +// +// CodespacesUserSecretArray{ CodespacesUserSecretArgs{...} } +type CodespacesUserSecretArrayInput interface { + pulumi.Input + + ToCodespacesUserSecretArrayOutput() CodespacesUserSecretArrayOutput + ToCodespacesUserSecretArrayOutputWithContext(context.Context) CodespacesUserSecretArrayOutput +} + +type CodespacesUserSecretArray []CodespacesUserSecretInput + +func (CodespacesUserSecretArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*CodespacesUserSecret)(nil)).Elem() +} + +func (i CodespacesUserSecretArray) ToCodespacesUserSecretArrayOutput() CodespacesUserSecretArrayOutput { + return i.ToCodespacesUserSecretArrayOutputWithContext(context.Background()) +} + +func (i CodespacesUserSecretArray) ToCodespacesUserSecretArrayOutputWithContext(ctx context.Context) CodespacesUserSecretArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(CodespacesUserSecretArrayOutput) +} + +// CodespacesUserSecretMapInput is an input type that accepts CodespacesUserSecretMap and CodespacesUserSecretMapOutput values. +// You can construct a concrete instance of `CodespacesUserSecretMapInput` via: +// +// CodespacesUserSecretMap{ "key": CodespacesUserSecretArgs{...} } +type CodespacesUserSecretMapInput interface { + pulumi.Input + + ToCodespacesUserSecretMapOutput() CodespacesUserSecretMapOutput + ToCodespacesUserSecretMapOutputWithContext(context.Context) CodespacesUserSecretMapOutput +} + +type CodespacesUserSecretMap map[string]CodespacesUserSecretInput + +func (CodespacesUserSecretMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*CodespacesUserSecret)(nil)).Elem() +} + +func (i CodespacesUserSecretMap) ToCodespacesUserSecretMapOutput() CodespacesUserSecretMapOutput { + return i.ToCodespacesUserSecretMapOutputWithContext(context.Background()) +} + +func (i CodespacesUserSecretMap) ToCodespacesUserSecretMapOutputWithContext(ctx context.Context) CodespacesUserSecretMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(CodespacesUserSecretMapOutput) +} + +type CodespacesUserSecretOutput struct{ *pulumi.OutputState } + +func (CodespacesUserSecretOutput) ElementType() reflect.Type { + return reflect.TypeOf((**CodespacesUserSecret)(nil)).Elem() +} + +func (o CodespacesUserSecretOutput) ToCodespacesUserSecretOutput() CodespacesUserSecretOutput { + return o +} + +func (o CodespacesUserSecretOutput) ToCodespacesUserSecretOutputWithContext(ctx context.Context) CodespacesUserSecretOutput { + return o +} + +// Date of codespacesSecret creation. +func (o CodespacesUserSecretOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *CodespacesUserSecret) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) +} + +// Encrypted value of the secret using the GitHub public key in Base64 format. +func (o CodespacesUserSecretOutput) EncryptedValue() pulumi.StringPtrOutput { + return o.ApplyT(func(v *CodespacesUserSecret) pulumi.StringPtrOutput { return v.EncryptedValue }).(pulumi.StringPtrOutput) +} + +// Plaintext value of the secret to be encrypted +func (o CodespacesUserSecretOutput) PlaintextValue() pulumi.StringPtrOutput { + return o.ApplyT(func(v *CodespacesUserSecret) pulumi.StringPtrOutput { return v.PlaintextValue }).(pulumi.StringPtrOutput) +} + +// Name of the secret +func (o CodespacesUserSecretOutput) SecretName() pulumi.StringOutput { + return o.ApplyT(func(v *CodespacesUserSecret) pulumi.StringOutput { return v.SecretName }).(pulumi.StringOutput) +} + +// An array of repository ids that can access the user secret. +func (o CodespacesUserSecretOutput) SelectedRepositoryIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v *CodespacesUserSecret) pulumi.IntArrayOutput { return v.SelectedRepositoryIds }).(pulumi.IntArrayOutput) +} + +// Date of codespacesSecret update. +func (o CodespacesUserSecretOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *CodespacesUserSecret) pulumi.StringOutput { return v.UpdatedAt }).(pulumi.StringOutput) +} + +type CodespacesUserSecretArrayOutput struct{ *pulumi.OutputState } + +func (CodespacesUserSecretArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*CodespacesUserSecret)(nil)).Elem() +} + +func (o CodespacesUserSecretArrayOutput) ToCodespacesUserSecretArrayOutput() CodespacesUserSecretArrayOutput { + return o +} + +func (o CodespacesUserSecretArrayOutput) ToCodespacesUserSecretArrayOutputWithContext(ctx context.Context) CodespacesUserSecretArrayOutput { + return o +} + +func (o CodespacesUserSecretArrayOutput) Index(i pulumi.IntInput) CodespacesUserSecretOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *CodespacesUserSecret { + return vs[0].([]*CodespacesUserSecret)[vs[1].(int)] + }).(CodespacesUserSecretOutput) +} + +type CodespacesUserSecretMapOutput struct{ *pulumi.OutputState } + +func (CodespacesUserSecretMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*CodespacesUserSecret)(nil)).Elem() +} + +func (o CodespacesUserSecretMapOutput) ToCodespacesUserSecretMapOutput() CodespacesUserSecretMapOutput { + return o +} + +func (o CodespacesUserSecretMapOutput) ToCodespacesUserSecretMapOutputWithContext(ctx context.Context) CodespacesUserSecretMapOutput { + return o +} + +func (o CodespacesUserSecretMapOutput) MapIndex(k pulumi.StringInput) CodespacesUserSecretOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *CodespacesUserSecret { + return vs[0].(map[string]*CodespacesUserSecret)[vs[1].(string)] + }).(CodespacesUserSecretOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*CodespacesUserSecretInput)(nil)).Elem(), &CodespacesUserSecret{}) + pulumi.RegisterInputType(reflect.TypeOf((*CodespacesUserSecretArrayInput)(nil)).Elem(), CodespacesUserSecretArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*CodespacesUserSecretMapInput)(nil)).Elem(), CodespacesUserSecretMap{}) + pulumi.RegisterOutputType(CodespacesUserSecretOutput{}) + pulumi.RegisterOutputType(CodespacesUserSecretArrayOutput{}) + pulumi.RegisterOutputType(CodespacesUserSecretMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/dependabotOrganizationSecret.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/dependabotOrganizationSecret.go new file mode 100644 index 000000000..8308af2a2 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/dependabotOrganizationSecret.go @@ -0,0 +1,527 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage GitHub Dependabot secrets within your GitHub organization. +// You must have write access to a repository to use this resource. +// +// Secret values are encrypted using the [Go '/crypto/box' module](https://godoc.org/golang.org/x/crypto/nacl/box) which is +// interoperable with [libsodium](https://libsodium.gitbook.io/doc/). Libsodium is used by GitHub to decrypt secret values. +// +// For the purposes of security, the contents of the `value` field have been marked as `sensitive` to Terraform, +// but it is important to note that **this does not hide it from state files**. You should treat state as sensitive always. +// It is also advised that you do not store plaintext values in your code but rather populate the `valueEncrypted` +// using fields from a resource, data source or variable as, while encrypted in state, these will be easily accessible +// in your code. See below for an example of this abstraction. +// +// ## Example Usage +// +// ```go +// 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.NewDependabotOrganizationSecret(ctx, "example_plaintext", &github.DependabotOrganizationSecretArgs{ +// SecretName: pulumi.String("example_secret_name"), +// Visibility: pulumi.String("all"), +// Value: pulumi.Any(someSecretString), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewDependabotOrganizationSecret(ctx, "example_secret", &github.DependabotOrganizationSecretArgs{ +// SecretName: pulumi.String("example_secret_name"), +// Visibility: pulumi.String("all"), +// ValueEncrypted: pulumi.Any(someEncryptedSecretString), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ```go +// 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 { +// repo, err := github.GetRepository(ctx, &github.LookupRepositoryArgs{ +// FullName: pulumi.StringRef("my-org/repo"), +// }, nil) +// if err != nil { +// return err +// } +// _, err = github.NewDependabotOrganizationSecret(ctx, "example_plaintext", &github.DependabotOrganizationSecretArgs{ +// SecretName: pulumi.String("example_secret_name"), +// Visibility: pulumi.String("selected"), +// Value: pulumi.Any(someSecretString), +// SelectedRepositoryIds: pulumi.IntArray{ +// pulumi.Int(pulumi.Int(repo.RepoId)), +// }, +// }) +// if err != nil { +// return err +// } +// _, err = github.NewDependabotOrganizationSecret(ctx, "example_encrypted", &github.DependabotOrganizationSecretArgs{ +// SecretName: pulumi.String("example_secret_name"), +// Visibility: pulumi.String("selected"), +// ValueEncrypted: pulumi.Any(someEncryptedSecretString), +// SelectedRepositoryIds: pulumi.IntArray{ +// pulumi.Int(pulumi.Int(repo.RepoId)), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ### Import Command +// +// The following command imports a GitHub Dependabot organization secret named `mysecret` to a `DependabotOrganizationSecret` resource named `example`. +// +// ```sh +// $ pulumi import github:index/dependabotOrganizationSecret:DependabotOrganizationSecret example mysecret +// ``` +type DependabotOrganizationSecret struct { + pulumi.CustomResourceState + + // Date the secret was created. + CreatedAt pulumi.StringOutput `pulumi:"createdAt"` + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue pulumi.StringPtrOutput `pulumi:"encryptedValue"` + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId pulumi.StringOutput `pulumi:"keyId"` + // (Optional) Please use `value`. + // + // Deprecated: Use value. + PlaintextValue pulumi.StringPtrOutput `pulumi:"plaintextValue"` + // Date the secret was last updated in GitHub. + RemoteUpdatedAt pulumi.StringOutput `pulumi:"remoteUpdatedAt"` + // Name of the secret. + SecretName pulumi.StringOutput `pulumi:"secretName"` + // An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: This field is deprecated and will be removed in a future release. Please use the `DependabotOrganizationSecretRepositories` or `DependabotOrganizationSecretRepository` resources to manage repository access to organization secrets. + SelectedRepositoryIds pulumi.IntArrayOutput `pulumi:"selectedRepositoryIds"` + // Date the secret was last updated by the provider. + UpdatedAt pulumi.StringOutput `pulumi:"updatedAt"` + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value pulumi.StringPtrOutput `pulumi:"value"` + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted pulumi.StringPtrOutput `pulumi:"valueEncrypted"` + // Configures the access that repositories have to the organization secret; must be one of `all`, `private`, or `selected`. + Visibility pulumi.StringOutput `pulumi:"visibility"` +} + +// NewDependabotOrganizationSecret registers a new resource with the given unique name, arguments, and options. +func NewDependabotOrganizationSecret(ctx *pulumi.Context, + name string, args *DependabotOrganizationSecretArgs, opts ...pulumi.ResourceOption) (*DependabotOrganizationSecret, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.SecretName == nil { + return nil, errors.New("invalid value for required argument 'SecretName'") + } + if args.Visibility == nil { + return nil, errors.New("invalid value for required argument 'Visibility'") + } + if args.EncryptedValue != nil { + args.EncryptedValue = pulumi.ToSecret(args.EncryptedValue).(pulumi.StringPtrInput) + } + if args.PlaintextValue != nil { + args.PlaintextValue = pulumi.ToSecret(args.PlaintextValue).(pulumi.StringPtrInput) + } + if args.Value != nil { + args.Value = pulumi.ToSecret(args.Value).(pulumi.StringPtrInput) + } + if args.ValueEncrypted != nil { + args.ValueEncrypted = pulumi.ToSecret(args.ValueEncrypted).(pulumi.StringPtrInput) + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "encryptedValue", + "plaintextValue", + "value", + "valueEncrypted", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource DependabotOrganizationSecret + err := ctx.RegisterResource("github:index/dependabotOrganizationSecret:DependabotOrganizationSecret", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetDependabotOrganizationSecret gets an existing DependabotOrganizationSecret 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 GetDependabotOrganizationSecret(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *DependabotOrganizationSecretState, opts ...pulumi.ResourceOption) (*DependabotOrganizationSecret, error) { + var resource DependabotOrganizationSecret + err := ctx.ReadResource("github:index/dependabotOrganizationSecret:DependabotOrganizationSecret", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering DependabotOrganizationSecret resources. +type dependabotOrganizationSecretState struct { + // Date the secret was created. + CreatedAt *string `pulumi:"createdAt"` + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue *string `pulumi:"encryptedValue"` + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId *string `pulumi:"keyId"` + // (Optional) Please use `value`. + // + // Deprecated: Use value. + PlaintextValue *string `pulumi:"plaintextValue"` + // Date the secret was last updated in GitHub. + RemoteUpdatedAt *string `pulumi:"remoteUpdatedAt"` + // Name of the secret. + SecretName *string `pulumi:"secretName"` + // An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: This field is deprecated and will be removed in a future release. Please use the `DependabotOrganizationSecretRepositories` or `DependabotOrganizationSecretRepository` resources to manage repository access to organization secrets. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` + // Date the secret was last updated by the provider. + UpdatedAt *string `pulumi:"updatedAt"` + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value *string `pulumi:"value"` + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted *string `pulumi:"valueEncrypted"` + // Configures the access that repositories have to the organization secret; must be one of `all`, `private`, or `selected`. + Visibility *string `pulumi:"visibility"` +} + +type DependabotOrganizationSecretState struct { + // Date the secret was created. + CreatedAt pulumi.StringPtrInput + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue pulumi.StringPtrInput + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId pulumi.StringPtrInput + // (Optional) Please use `value`. + // + // Deprecated: Use value. + PlaintextValue pulumi.StringPtrInput + // Date the secret was last updated in GitHub. + RemoteUpdatedAt pulumi.StringPtrInput + // Name of the secret. + SecretName pulumi.StringPtrInput + // An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: This field is deprecated and will be removed in a future release. Please use the `DependabotOrganizationSecretRepositories` or `DependabotOrganizationSecretRepository` resources to manage repository access to organization secrets. + SelectedRepositoryIds pulumi.IntArrayInput + // Date the secret was last updated by the provider. + UpdatedAt pulumi.StringPtrInput + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value pulumi.StringPtrInput + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted pulumi.StringPtrInput + // Configures the access that repositories have to the organization secret; must be one of `all`, `private`, or `selected`. + Visibility pulumi.StringPtrInput +} + +func (DependabotOrganizationSecretState) ElementType() reflect.Type { + return reflect.TypeOf((*dependabotOrganizationSecretState)(nil)).Elem() +} + +type dependabotOrganizationSecretArgs struct { + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue *string `pulumi:"encryptedValue"` + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId *string `pulumi:"keyId"` + // (Optional) Please use `value`. + // + // Deprecated: Use value. + PlaintextValue *string `pulumi:"plaintextValue"` + // Name of the secret. + SecretName string `pulumi:"secretName"` + // An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: This field is deprecated and will be removed in a future release. Please use the `DependabotOrganizationSecretRepositories` or `DependabotOrganizationSecretRepository` resources to manage repository access to organization secrets. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value *string `pulumi:"value"` + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted *string `pulumi:"valueEncrypted"` + // Configures the access that repositories have to the organization secret; must be one of `all`, `private`, or `selected`. + Visibility string `pulumi:"visibility"` +} + +// The set of arguments for constructing a DependabotOrganizationSecret resource. +type DependabotOrganizationSecretArgs struct { + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue pulumi.StringPtrInput + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId pulumi.StringPtrInput + // (Optional) Please use `value`. + // + // Deprecated: Use value. + PlaintextValue pulumi.StringPtrInput + // Name of the secret. + SecretName pulumi.StringInput + // An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: This field is deprecated and will be removed in a future release. Please use the `DependabotOrganizationSecretRepositories` or `DependabotOrganizationSecretRepository` resources to manage repository access to organization secrets. + SelectedRepositoryIds pulumi.IntArrayInput + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value pulumi.StringPtrInput + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted pulumi.StringPtrInput + // Configures the access that repositories have to the organization secret; must be one of `all`, `private`, or `selected`. + Visibility pulumi.StringInput +} + +func (DependabotOrganizationSecretArgs) ElementType() reflect.Type { + return reflect.TypeOf((*dependabotOrganizationSecretArgs)(nil)).Elem() +} + +type DependabotOrganizationSecretInput interface { + pulumi.Input + + ToDependabotOrganizationSecretOutput() DependabotOrganizationSecretOutput + ToDependabotOrganizationSecretOutputWithContext(ctx context.Context) DependabotOrganizationSecretOutput +} + +func (*DependabotOrganizationSecret) ElementType() reflect.Type { + return reflect.TypeOf((**DependabotOrganizationSecret)(nil)).Elem() +} + +func (i *DependabotOrganizationSecret) ToDependabotOrganizationSecretOutput() DependabotOrganizationSecretOutput { + return i.ToDependabotOrganizationSecretOutputWithContext(context.Background()) +} + +func (i *DependabotOrganizationSecret) ToDependabotOrganizationSecretOutputWithContext(ctx context.Context) DependabotOrganizationSecretOutput { + return pulumi.ToOutputWithContext(ctx, i).(DependabotOrganizationSecretOutput) +} + +// DependabotOrganizationSecretArrayInput is an input type that accepts DependabotOrganizationSecretArray and DependabotOrganizationSecretArrayOutput values. +// You can construct a concrete instance of `DependabotOrganizationSecretArrayInput` via: +// +// DependabotOrganizationSecretArray{ DependabotOrganizationSecretArgs{...} } +type DependabotOrganizationSecretArrayInput interface { + pulumi.Input + + ToDependabotOrganizationSecretArrayOutput() DependabotOrganizationSecretArrayOutput + ToDependabotOrganizationSecretArrayOutputWithContext(context.Context) DependabotOrganizationSecretArrayOutput +} + +type DependabotOrganizationSecretArray []DependabotOrganizationSecretInput + +func (DependabotOrganizationSecretArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*DependabotOrganizationSecret)(nil)).Elem() +} + +func (i DependabotOrganizationSecretArray) ToDependabotOrganizationSecretArrayOutput() DependabotOrganizationSecretArrayOutput { + return i.ToDependabotOrganizationSecretArrayOutputWithContext(context.Background()) +} + +func (i DependabotOrganizationSecretArray) ToDependabotOrganizationSecretArrayOutputWithContext(ctx context.Context) DependabotOrganizationSecretArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(DependabotOrganizationSecretArrayOutput) +} + +// DependabotOrganizationSecretMapInput is an input type that accepts DependabotOrganizationSecretMap and DependabotOrganizationSecretMapOutput values. +// You can construct a concrete instance of `DependabotOrganizationSecretMapInput` via: +// +// DependabotOrganizationSecretMap{ "key": DependabotOrganizationSecretArgs{...} } +type DependabotOrganizationSecretMapInput interface { + pulumi.Input + + ToDependabotOrganizationSecretMapOutput() DependabotOrganizationSecretMapOutput + ToDependabotOrganizationSecretMapOutputWithContext(context.Context) DependabotOrganizationSecretMapOutput +} + +type DependabotOrganizationSecretMap map[string]DependabotOrganizationSecretInput + +func (DependabotOrganizationSecretMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*DependabotOrganizationSecret)(nil)).Elem() +} + +func (i DependabotOrganizationSecretMap) ToDependabotOrganizationSecretMapOutput() DependabotOrganizationSecretMapOutput { + return i.ToDependabotOrganizationSecretMapOutputWithContext(context.Background()) +} + +func (i DependabotOrganizationSecretMap) ToDependabotOrganizationSecretMapOutputWithContext(ctx context.Context) DependabotOrganizationSecretMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(DependabotOrganizationSecretMapOutput) +} + +type DependabotOrganizationSecretOutput struct{ *pulumi.OutputState } + +func (DependabotOrganizationSecretOutput) ElementType() reflect.Type { + return reflect.TypeOf((**DependabotOrganizationSecret)(nil)).Elem() +} + +func (o DependabotOrganizationSecretOutput) ToDependabotOrganizationSecretOutput() DependabotOrganizationSecretOutput { + return o +} + +func (o DependabotOrganizationSecretOutput) ToDependabotOrganizationSecretOutputWithContext(ctx context.Context) DependabotOrganizationSecretOutput { + return o +} + +// Date the secret was created. +func (o DependabotOrganizationSecretOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *DependabotOrganizationSecret) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) +} + +// (Optional) Please use `valueEncrypted`. +// +// Deprecated: Use valueEncrypted and key_id. +func (o DependabotOrganizationSecretOutput) EncryptedValue() pulumi.StringPtrOutput { + return o.ApplyT(func(v *DependabotOrganizationSecret) pulumi.StringPtrOutput { return v.EncryptedValue }).(pulumi.StringPtrOutput) +} + +// ID of the public key used to encrypt the secret, required when setting `encryptedValue`. +func (o DependabotOrganizationSecretOutput) KeyId() pulumi.StringOutput { + return o.ApplyT(func(v *DependabotOrganizationSecret) pulumi.StringOutput { return v.KeyId }).(pulumi.StringOutput) +} + +// (Optional) Please use `value`. +// +// Deprecated: Use value. +func (o DependabotOrganizationSecretOutput) PlaintextValue() pulumi.StringPtrOutput { + return o.ApplyT(func(v *DependabotOrganizationSecret) pulumi.StringPtrOutput { return v.PlaintextValue }).(pulumi.StringPtrOutput) +} + +// Date the secret was last updated in GitHub. +func (o DependabotOrganizationSecretOutput) RemoteUpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *DependabotOrganizationSecret) pulumi.StringOutput { return v.RemoteUpdatedAt }).(pulumi.StringOutput) +} + +// Name of the secret. +func (o DependabotOrganizationSecretOutput) SecretName() pulumi.StringOutput { + return o.ApplyT(func(v *DependabotOrganizationSecret) pulumi.StringOutput { return v.SecretName }).(pulumi.StringOutput) +} + +// An array of repository IDs that can access the organization variable; this requires `visibility` to be set to `selected`. +// +// > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. +// +// Deprecated: This field is deprecated and will be removed in a future release. Please use the `DependabotOrganizationSecretRepositories` or `DependabotOrganizationSecretRepository` resources to manage repository access to organization secrets. +func (o DependabotOrganizationSecretOutput) SelectedRepositoryIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v *DependabotOrganizationSecret) pulumi.IntArrayOutput { return v.SelectedRepositoryIds }).(pulumi.IntArrayOutput) +} + +// Date the secret was last updated by the provider. +func (o DependabotOrganizationSecretOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *DependabotOrganizationSecret) pulumi.StringOutput { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. +func (o DependabotOrganizationSecretOutput) Value() pulumi.StringPtrOutput { + return o.ApplyT(func(v *DependabotOrganizationSecret) pulumi.StringPtrOutput { return v.Value }).(pulumi.StringPtrOutput) +} + +// Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. +func (o DependabotOrganizationSecretOutput) ValueEncrypted() pulumi.StringPtrOutput { + return o.ApplyT(func(v *DependabotOrganizationSecret) pulumi.StringPtrOutput { return v.ValueEncrypted }).(pulumi.StringPtrOutput) +} + +// Configures the access that repositories have to the organization secret; must be one of `all`, `private`, or `selected`. +func (o DependabotOrganizationSecretOutput) Visibility() pulumi.StringOutput { + return o.ApplyT(func(v *DependabotOrganizationSecret) pulumi.StringOutput { return v.Visibility }).(pulumi.StringOutput) +} + +type DependabotOrganizationSecretArrayOutput struct{ *pulumi.OutputState } + +func (DependabotOrganizationSecretArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*DependabotOrganizationSecret)(nil)).Elem() +} + +func (o DependabotOrganizationSecretArrayOutput) ToDependabotOrganizationSecretArrayOutput() DependabotOrganizationSecretArrayOutput { + return o +} + +func (o DependabotOrganizationSecretArrayOutput) ToDependabotOrganizationSecretArrayOutputWithContext(ctx context.Context) DependabotOrganizationSecretArrayOutput { + return o +} + +func (o DependabotOrganizationSecretArrayOutput) Index(i pulumi.IntInput) DependabotOrganizationSecretOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DependabotOrganizationSecret { + return vs[0].([]*DependabotOrganizationSecret)[vs[1].(int)] + }).(DependabotOrganizationSecretOutput) +} + +type DependabotOrganizationSecretMapOutput struct{ *pulumi.OutputState } + +func (DependabotOrganizationSecretMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*DependabotOrganizationSecret)(nil)).Elem() +} + +func (o DependabotOrganizationSecretMapOutput) ToDependabotOrganizationSecretMapOutput() DependabotOrganizationSecretMapOutput { + return o +} + +func (o DependabotOrganizationSecretMapOutput) ToDependabotOrganizationSecretMapOutputWithContext(ctx context.Context) DependabotOrganizationSecretMapOutput { + return o +} + +func (o DependabotOrganizationSecretMapOutput) MapIndex(k pulumi.StringInput) DependabotOrganizationSecretOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DependabotOrganizationSecret { + return vs[0].(map[string]*DependabotOrganizationSecret)[vs[1].(string)] + }).(DependabotOrganizationSecretOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*DependabotOrganizationSecretInput)(nil)).Elem(), &DependabotOrganizationSecret{}) + pulumi.RegisterInputType(reflect.TypeOf((*DependabotOrganizationSecretArrayInput)(nil)).Elem(), DependabotOrganizationSecretArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*DependabotOrganizationSecretMapInput)(nil)).Elem(), DependabotOrganizationSecretMap{}) + pulumi.RegisterOutputType(DependabotOrganizationSecretOutput{}) + pulumi.RegisterOutputType(DependabotOrganizationSecretArrayOutput{}) + pulumi.RegisterOutputType(DependabotOrganizationSecretMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/dependabotOrganizationSecretRepositories.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/dependabotOrganizationSecretRepositories.go new file mode 100644 index 000000000..62b12749b --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/dependabotOrganizationSecretRepositories.go @@ -0,0 +1,298 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to manage the repositories allowed to access a Dependabot secret within your GitHub organization. +// You must have write access to an organization secret to use this resource. +// +// This resource is only applicable when `visibility` of the existing organization secret has been set to `selected`. +// +// ## Example Usage +// +// ```go +// 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.NewDependabotOrganizationSecret(ctx, "example", &github.DependabotOrganizationSecretArgs{ +// SecretName: pulumi.String("mysecret"), +// Value: 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.NewDependabotOrganizationSecretRepositories(ctx, "example", &github.DependabotOrganizationSecretRepositoriesArgs{ +// SecretName: example.Name, +// SelectedRepositoryIds: pulumi.IntArray{ +// exampleRepository.RepoId, +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using the secret name as the ID. +// +// ### Import Command +// +// The following command imports the repositories able to access the Dependabot organization secret named `mysecret` to a `DependabotOrganizationSecretRepositories` resource named `example`. +// +// ```sh +// $ pulumi import github:index/dependabotOrganizationSecretRepositories:DependabotOrganizationSecretRepositories example mysecret +// ``` +type DependabotOrganizationSecretRepositories struct { + pulumi.CustomResourceState + + // Name of the Dependabot organization secret. + SecretName pulumi.StringOutput `pulumi:"secretName"` + // List of IDs for the repositories that should be able to access the secret. + SelectedRepositoryIds pulumi.IntArrayOutput `pulumi:"selectedRepositoryIds"` +} + +// NewDependabotOrganizationSecretRepositories registers a new resource with the given unique name, arguments, and options. +func NewDependabotOrganizationSecretRepositories(ctx *pulumi.Context, + name string, args *DependabotOrganizationSecretRepositoriesArgs, opts ...pulumi.ResourceOption) (*DependabotOrganizationSecretRepositories, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.SecretName == nil { + return nil, errors.New("invalid value for required argument 'SecretName'") + } + if args.SelectedRepositoryIds == nil { + return nil, errors.New("invalid value for required argument 'SelectedRepositoryIds'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource DependabotOrganizationSecretRepositories + err := ctx.RegisterResource("github:index/dependabotOrganizationSecretRepositories:DependabotOrganizationSecretRepositories", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetDependabotOrganizationSecretRepositories gets an existing DependabotOrganizationSecretRepositories 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 GetDependabotOrganizationSecretRepositories(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *DependabotOrganizationSecretRepositoriesState, opts ...pulumi.ResourceOption) (*DependabotOrganizationSecretRepositories, error) { + var resource DependabotOrganizationSecretRepositories + err := ctx.ReadResource("github:index/dependabotOrganizationSecretRepositories:DependabotOrganizationSecretRepositories", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering DependabotOrganizationSecretRepositories resources. +type dependabotOrganizationSecretRepositoriesState struct { + // Name of the Dependabot organization secret. + SecretName *string `pulumi:"secretName"` + // List of IDs for the repositories that should be able to access the secret. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` +} + +type DependabotOrganizationSecretRepositoriesState struct { + // Name of the Dependabot organization secret. + SecretName pulumi.StringPtrInput + // List of IDs for the repositories that should be able to access the secret. + SelectedRepositoryIds pulumi.IntArrayInput +} + +func (DependabotOrganizationSecretRepositoriesState) ElementType() reflect.Type { + return reflect.TypeOf((*dependabotOrganizationSecretRepositoriesState)(nil)).Elem() +} + +type dependabotOrganizationSecretRepositoriesArgs struct { + // Name of the Dependabot organization secret. + SecretName string `pulumi:"secretName"` + // List of IDs for the repositories that should be able to access the secret. + SelectedRepositoryIds []int `pulumi:"selectedRepositoryIds"` +} + +// The set of arguments for constructing a DependabotOrganizationSecretRepositories resource. +type DependabotOrganizationSecretRepositoriesArgs struct { + // Name of the Dependabot organization secret. + SecretName pulumi.StringInput + // List of IDs for the repositories that should be able to access the secret. + SelectedRepositoryIds pulumi.IntArrayInput +} + +func (DependabotOrganizationSecretRepositoriesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*dependabotOrganizationSecretRepositoriesArgs)(nil)).Elem() +} + +type DependabotOrganizationSecretRepositoriesInput interface { + pulumi.Input + + ToDependabotOrganizationSecretRepositoriesOutput() DependabotOrganizationSecretRepositoriesOutput + ToDependabotOrganizationSecretRepositoriesOutputWithContext(ctx context.Context) DependabotOrganizationSecretRepositoriesOutput +} + +func (*DependabotOrganizationSecretRepositories) ElementType() reflect.Type { + return reflect.TypeOf((**DependabotOrganizationSecretRepositories)(nil)).Elem() +} + +func (i *DependabotOrganizationSecretRepositories) ToDependabotOrganizationSecretRepositoriesOutput() DependabotOrganizationSecretRepositoriesOutput { + return i.ToDependabotOrganizationSecretRepositoriesOutputWithContext(context.Background()) +} + +func (i *DependabotOrganizationSecretRepositories) ToDependabotOrganizationSecretRepositoriesOutputWithContext(ctx context.Context) DependabotOrganizationSecretRepositoriesOutput { + return pulumi.ToOutputWithContext(ctx, i).(DependabotOrganizationSecretRepositoriesOutput) +} + +// DependabotOrganizationSecretRepositoriesArrayInput is an input type that accepts DependabotOrganizationSecretRepositoriesArray and DependabotOrganizationSecretRepositoriesArrayOutput values. +// You can construct a concrete instance of `DependabotOrganizationSecretRepositoriesArrayInput` via: +// +// DependabotOrganizationSecretRepositoriesArray{ DependabotOrganizationSecretRepositoriesArgs{...} } +type DependabotOrganizationSecretRepositoriesArrayInput interface { + pulumi.Input + + ToDependabotOrganizationSecretRepositoriesArrayOutput() DependabotOrganizationSecretRepositoriesArrayOutput + ToDependabotOrganizationSecretRepositoriesArrayOutputWithContext(context.Context) DependabotOrganizationSecretRepositoriesArrayOutput +} + +type DependabotOrganizationSecretRepositoriesArray []DependabotOrganizationSecretRepositoriesInput + +func (DependabotOrganizationSecretRepositoriesArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*DependabotOrganizationSecretRepositories)(nil)).Elem() +} + +func (i DependabotOrganizationSecretRepositoriesArray) ToDependabotOrganizationSecretRepositoriesArrayOutput() DependabotOrganizationSecretRepositoriesArrayOutput { + return i.ToDependabotOrganizationSecretRepositoriesArrayOutputWithContext(context.Background()) +} + +func (i DependabotOrganizationSecretRepositoriesArray) ToDependabotOrganizationSecretRepositoriesArrayOutputWithContext(ctx context.Context) DependabotOrganizationSecretRepositoriesArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(DependabotOrganizationSecretRepositoriesArrayOutput) +} + +// DependabotOrganizationSecretRepositoriesMapInput is an input type that accepts DependabotOrganizationSecretRepositoriesMap and DependabotOrganizationSecretRepositoriesMapOutput values. +// You can construct a concrete instance of `DependabotOrganizationSecretRepositoriesMapInput` via: +// +// DependabotOrganizationSecretRepositoriesMap{ "key": DependabotOrganizationSecretRepositoriesArgs{...} } +type DependabotOrganizationSecretRepositoriesMapInput interface { + pulumi.Input + + ToDependabotOrganizationSecretRepositoriesMapOutput() DependabotOrganizationSecretRepositoriesMapOutput + ToDependabotOrganizationSecretRepositoriesMapOutputWithContext(context.Context) DependabotOrganizationSecretRepositoriesMapOutput +} + +type DependabotOrganizationSecretRepositoriesMap map[string]DependabotOrganizationSecretRepositoriesInput + +func (DependabotOrganizationSecretRepositoriesMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*DependabotOrganizationSecretRepositories)(nil)).Elem() +} + +func (i DependabotOrganizationSecretRepositoriesMap) ToDependabotOrganizationSecretRepositoriesMapOutput() DependabotOrganizationSecretRepositoriesMapOutput { + return i.ToDependabotOrganizationSecretRepositoriesMapOutputWithContext(context.Background()) +} + +func (i DependabotOrganizationSecretRepositoriesMap) ToDependabotOrganizationSecretRepositoriesMapOutputWithContext(ctx context.Context) DependabotOrganizationSecretRepositoriesMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(DependabotOrganizationSecretRepositoriesMapOutput) +} + +type DependabotOrganizationSecretRepositoriesOutput struct{ *pulumi.OutputState } + +func (DependabotOrganizationSecretRepositoriesOutput) ElementType() reflect.Type { + return reflect.TypeOf((**DependabotOrganizationSecretRepositories)(nil)).Elem() +} + +func (o DependabotOrganizationSecretRepositoriesOutput) ToDependabotOrganizationSecretRepositoriesOutput() DependabotOrganizationSecretRepositoriesOutput { + return o +} + +func (o DependabotOrganizationSecretRepositoriesOutput) ToDependabotOrganizationSecretRepositoriesOutputWithContext(ctx context.Context) DependabotOrganizationSecretRepositoriesOutput { + return o +} + +// Name of the Dependabot organization secret. +func (o DependabotOrganizationSecretRepositoriesOutput) SecretName() pulumi.StringOutput { + return o.ApplyT(func(v *DependabotOrganizationSecretRepositories) pulumi.StringOutput { return v.SecretName }).(pulumi.StringOutput) +} + +// List of IDs for the repositories that should be able to access the secret. +func (o DependabotOrganizationSecretRepositoriesOutput) SelectedRepositoryIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v *DependabotOrganizationSecretRepositories) pulumi.IntArrayOutput { + return v.SelectedRepositoryIds + }).(pulumi.IntArrayOutput) +} + +type DependabotOrganizationSecretRepositoriesArrayOutput struct{ *pulumi.OutputState } + +func (DependabotOrganizationSecretRepositoriesArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*DependabotOrganizationSecretRepositories)(nil)).Elem() +} + +func (o DependabotOrganizationSecretRepositoriesArrayOutput) ToDependabotOrganizationSecretRepositoriesArrayOutput() DependabotOrganizationSecretRepositoriesArrayOutput { + return o +} + +func (o DependabotOrganizationSecretRepositoriesArrayOutput) ToDependabotOrganizationSecretRepositoriesArrayOutputWithContext(ctx context.Context) DependabotOrganizationSecretRepositoriesArrayOutput { + return o +} + +func (o DependabotOrganizationSecretRepositoriesArrayOutput) Index(i pulumi.IntInput) DependabotOrganizationSecretRepositoriesOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DependabotOrganizationSecretRepositories { + return vs[0].([]*DependabotOrganizationSecretRepositories)[vs[1].(int)] + }).(DependabotOrganizationSecretRepositoriesOutput) +} + +type DependabotOrganizationSecretRepositoriesMapOutput struct{ *pulumi.OutputState } + +func (DependabotOrganizationSecretRepositoriesMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*DependabotOrganizationSecretRepositories)(nil)).Elem() +} + +func (o DependabotOrganizationSecretRepositoriesMapOutput) ToDependabotOrganizationSecretRepositoriesMapOutput() DependabotOrganizationSecretRepositoriesMapOutput { + return o +} + +func (o DependabotOrganizationSecretRepositoriesMapOutput) ToDependabotOrganizationSecretRepositoriesMapOutputWithContext(ctx context.Context) DependabotOrganizationSecretRepositoriesMapOutput { + return o +} + +func (o DependabotOrganizationSecretRepositoriesMapOutput) MapIndex(k pulumi.StringInput) DependabotOrganizationSecretRepositoriesOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DependabotOrganizationSecretRepositories { + return vs[0].(map[string]*DependabotOrganizationSecretRepositories)[vs[1].(string)] + }).(DependabotOrganizationSecretRepositoriesOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*DependabotOrganizationSecretRepositoriesInput)(nil)).Elem(), &DependabotOrganizationSecretRepositories{}) + pulumi.RegisterInputType(reflect.TypeOf((*DependabotOrganizationSecretRepositoriesArrayInput)(nil)).Elem(), DependabotOrganizationSecretRepositoriesArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*DependabotOrganizationSecretRepositoriesMapInput)(nil)).Elem(), DependabotOrganizationSecretRepositoriesMap{}) + pulumi.RegisterOutputType(DependabotOrganizationSecretRepositoriesOutput{}) + pulumi.RegisterOutputType(DependabotOrganizationSecretRepositoriesArrayOutput{}) + pulumi.RegisterOutputType(DependabotOrganizationSecretRepositoriesMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/dependabotOrganizationSecretRepository.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/dependabotOrganizationSecretRepository.go new file mode 100644 index 000000000..d5cfa2f8b --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/dependabotOrganizationSecretRepository.go @@ -0,0 +1,294 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource adds permission for a repository to use a Dependabot secret within your GitHub organization. +// You must have write access to an organization secret to use this resource. +// +// This resource is only applicable when `visibility` of the existing organization secret has been set to `selected`. +// +// ## Example Usage +// +// ```go +// 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.NewDependabotOrganizationSecret(ctx, "example", &github.DependabotOrganizationSecretArgs{ +// SecretName: pulumi.String("mysecret"), +// Value: 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.NewDependabotOrganizationSecretRepository(ctx, "example", &github.DependabotOrganizationSecretRepositoryArgs{ +// SecretName: example.Name, +// RepositoryId: exampleRepository.RepoId, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using an ID made of the secret name and repository name separated by a `:`. +// +// ### Import Command +// +// The following command imports the access of repository ID `123456` for the Dependabot organization secret named `mysecret` to a `v` resource named `example`. +// +// ```sh +// $ pulumi import github:index/dependabotOrganizationSecretRepository:DependabotOrganizationSecretRepository example mysecret:123456 +// ``` +type DependabotOrganizationSecretRepository struct { + pulumi.CustomResourceState + + // ID of the repository that should be able to access the secret. + RepositoryId pulumi.IntOutput `pulumi:"repositoryId"` + // Name of the Dependabot organization secret. + SecretName pulumi.StringOutput `pulumi:"secretName"` +} + +// NewDependabotOrganizationSecretRepository registers a new resource with the given unique name, arguments, and options. +func NewDependabotOrganizationSecretRepository(ctx *pulumi.Context, + name string, args *DependabotOrganizationSecretRepositoryArgs, opts ...pulumi.ResourceOption) (*DependabotOrganizationSecretRepository, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.RepositoryId == nil { + return nil, errors.New("invalid value for required argument 'RepositoryId'") + } + if args.SecretName == nil { + return nil, errors.New("invalid value for required argument 'SecretName'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource DependabotOrganizationSecretRepository + err := ctx.RegisterResource("github:index/dependabotOrganizationSecretRepository:DependabotOrganizationSecretRepository", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetDependabotOrganizationSecretRepository gets an existing DependabotOrganizationSecretRepository 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 GetDependabotOrganizationSecretRepository(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *DependabotOrganizationSecretRepositoryState, opts ...pulumi.ResourceOption) (*DependabotOrganizationSecretRepository, error) { + var resource DependabotOrganizationSecretRepository + err := ctx.ReadResource("github:index/dependabotOrganizationSecretRepository:DependabotOrganizationSecretRepository", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering DependabotOrganizationSecretRepository resources. +type dependabotOrganizationSecretRepositoryState struct { + // ID of the repository that should be able to access the secret. + RepositoryId *int `pulumi:"repositoryId"` + // Name of the Dependabot organization secret. + SecretName *string `pulumi:"secretName"` +} + +type DependabotOrganizationSecretRepositoryState struct { + // ID of the repository that should be able to access the secret. + RepositoryId pulumi.IntPtrInput + // Name of the Dependabot organization secret. + SecretName pulumi.StringPtrInput +} + +func (DependabotOrganizationSecretRepositoryState) ElementType() reflect.Type { + return reflect.TypeOf((*dependabotOrganizationSecretRepositoryState)(nil)).Elem() +} + +type dependabotOrganizationSecretRepositoryArgs struct { + // ID of the repository that should be able to access the secret. + RepositoryId int `pulumi:"repositoryId"` + // Name of the Dependabot organization secret. + SecretName string `pulumi:"secretName"` +} + +// The set of arguments for constructing a DependabotOrganizationSecretRepository resource. +type DependabotOrganizationSecretRepositoryArgs struct { + // ID of the repository that should be able to access the secret. + RepositoryId pulumi.IntInput + // Name of the Dependabot organization secret. + SecretName pulumi.StringInput +} + +func (DependabotOrganizationSecretRepositoryArgs) ElementType() reflect.Type { + return reflect.TypeOf((*dependabotOrganizationSecretRepositoryArgs)(nil)).Elem() +} + +type DependabotOrganizationSecretRepositoryInput interface { + pulumi.Input + + ToDependabotOrganizationSecretRepositoryOutput() DependabotOrganizationSecretRepositoryOutput + ToDependabotOrganizationSecretRepositoryOutputWithContext(ctx context.Context) DependabotOrganizationSecretRepositoryOutput +} + +func (*DependabotOrganizationSecretRepository) ElementType() reflect.Type { + return reflect.TypeOf((**DependabotOrganizationSecretRepository)(nil)).Elem() +} + +func (i *DependabotOrganizationSecretRepository) ToDependabotOrganizationSecretRepositoryOutput() DependabotOrganizationSecretRepositoryOutput { + return i.ToDependabotOrganizationSecretRepositoryOutputWithContext(context.Background()) +} + +func (i *DependabotOrganizationSecretRepository) ToDependabotOrganizationSecretRepositoryOutputWithContext(ctx context.Context) DependabotOrganizationSecretRepositoryOutput { + return pulumi.ToOutputWithContext(ctx, i).(DependabotOrganizationSecretRepositoryOutput) +} + +// DependabotOrganizationSecretRepositoryArrayInput is an input type that accepts DependabotOrganizationSecretRepositoryArray and DependabotOrganizationSecretRepositoryArrayOutput values. +// You can construct a concrete instance of `DependabotOrganizationSecretRepositoryArrayInput` via: +// +// DependabotOrganizationSecretRepositoryArray{ DependabotOrganizationSecretRepositoryArgs{...} } +type DependabotOrganizationSecretRepositoryArrayInput interface { + pulumi.Input + + ToDependabotOrganizationSecretRepositoryArrayOutput() DependabotOrganizationSecretRepositoryArrayOutput + ToDependabotOrganizationSecretRepositoryArrayOutputWithContext(context.Context) DependabotOrganizationSecretRepositoryArrayOutput +} + +type DependabotOrganizationSecretRepositoryArray []DependabotOrganizationSecretRepositoryInput + +func (DependabotOrganizationSecretRepositoryArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*DependabotOrganizationSecretRepository)(nil)).Elem() +} + +func (i DependabotOrganizationSecretRepositoryArray) ToDependabotOrganizationSecretRepositoryArrayOutput() DependabotOrganizationSecretRepositoryArrayOutput { + return i.ToDependabotOrganizationSecretRepositoryArrayOutputWithContext(context.Background()) +} + +func (i DependabotOrganizationSecretRepositoryArray) ToDependabotOrganizationSecretRepositoryArrayOutputWithContext(ctx context.Context) DependabotOrganizationSecretRepositoryArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(DependabotOrganizationSecretRepositoryArrayOutput) +} + +// DependabotOrganizationSecretRepositoryMapInput is an input type that accepts DependabotOrganizationSecretRepositoryMap and DependabotOrganizationSecretRepositoryMapOutput values. +// You can construct a concrete instance of `DependabotOrganizationSecretRepositoryMapInput` via: +// +// DependabotOrganizationSecretRepositoryMap{ "key": DependabotOrganizationSecretRepositoryArgs{...} } +type DependabotOrganizationSecretRepositoryMapInput interface { + pulumi.Input + + ToDependabotOrganizationSecretRepositoryMapOutput() DependabotOrganizationSecretRepositoryMapOutput + ToDependabotOrganizationSecretRepositoryMapOutputWithContext(context.Context) DependabotOrganizationSecretRepositoryMapOutput +} + +type DependabotOrganizationSecretRepositoryMap map[string]DependabotOrganizationSecretRepositoryInput + +func (DependabotOrganizationSecretRepositoryMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*DependabotOrganizationSecretRepository)(nil)).Elem() +} + +func (i DependabotOrganizationSecretRepositoryMap) ToDependabotOrganizationSecretRepositoryMapOutput() DependabotOrganizationSecretRepositoryMapOutput { + return i.ToDependabotOrganizationSecretRepositoryMapOutputWithContext(context.Background()) +} + +func (i DependabotOrganizationSecretRepositoryMap) ToDependabotOrganizationSecretRepositoryMapOutputWithContext(ctx context.Context) DependabotOrganizationSecretRepositoryMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(DependabotOrganizationSecretRepositoryMapOutput) +} + +type DependabotOrganizationSecretRepositoryOutput struct{ *pulumi.OutputState } + +func (DependabotOrganizationSecretRepositoryOutput) ElementType() reflect.Type { + return reflect.TypeOf((**DependabotOrganizationSecretRepository)(nil)).Elem() +} + +func (o DependabotOrganizationSecretRepositoryOutput) ToDependabotOrganizationSecretRepositoryOutput() DependabotOrganizationSecretRepositoryOutput { + return o +} + +func (o DependabotOrganizationSecretRepositoryOutput) ToDependabotOrganizationSecretRepositoryOutputWithContext(ctx context.Context) DependabotOrganizationSecretRepositoryOutput { + return o +} + +// ID of the repository that should be able to access the secret. +func (o DependabotOrganizationSecretRepositoryOutput) RepositoryId() pulumi.IntOutput { + return o.ApplyT(func(v *DependabotOrganizationSecretRepository) pulumi.IntOutput { return v.RepositoryId }).(pulumi.IntOutput) +} + +// Name of the Dependabot organization secret. +func (o DependabotOrganizationSecretRepositoryOutput) SecretName() pulumi.StringOutput { + return o.ApplyT(func(v *DependabotOrganizationSecretRepository) pulumi.StringOutput { return v.SecretName }).(pulumi.StringOutput) +} + +type DependabotOrganizationSecretRepositoryArrayOutput struct{ *pulumi.OutputState } + +func (DependabotOrganizationSecretRepositoryArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*DependabotOrganizationSecretRepository)(nil)).Elem() +} + +func (o DependabotOrganizationSecretRepositoryArrayOutput) ToDependabotOrganizationSecretRepositoryArrayOutput() DependabotOrganizationSecretRepositoryArrayOutput { + return o +} + +func (o DependabotOrganizationSecretRepositoryArrayOutput) ToDependabotOrganizationSecretRepositoryArrayOutputWithContext(ctx context.Context) DependabotOrganizationSecretRepositoryArrayOutput { + return o +} + +func (o DependabotOrganizationSecretRepositoryArrayOutput) Index(i pulumi.IntInput) DependabotOrganizationSecretRepositoryOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DependabotOrganizationSecretRepository { + return vs[0].([]*DependabotOrganizationSecretRepository)[vs[1].(int)] + }).(DependabotOrganizationSecretRepositoryOutput) +} + +type DependabotOrganizationSecretRepositoryMapOutput struct{ *pulumi.OutputState } + +func (DependabotOrganizationSecretRepositoryMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*DependabotOrganizationSecretRepository)(nil)).Elem() +} + +func (o DependabotOrganizationSecretRepositoryMapOutput) ToDependabotOrganizationSecretRepositoryMapOutput() DependabotOrganizationSecretRepositoryMapOutput { + return o +} + +func (o DependabotOrganizationSecretRepositoryMapOutput) ToDependabotOrganizationSecretRepositoryMapOutputWithContext(ctx context.Context) DependabotOrganizationSecretRepositoryMapOutput { + return o +} + +func (o DependabotOrganizationSecretRepositoryMapOutput) MapIndex(k pulumi.StringInput) DependabotOrganizationSecretRepositoryOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DependabotOrganizationSecretRepository { + return vs[0].(map[string]*DependabotOrganizationSecretRepository)[vs[1].(string)] + }).(DependabotOrganizationSecretRepositoryOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*DependabotOrganizationSecretRepositoryInput)(nil)).Elem(), &DependabotOrganizationSecretRepository{}) + pulumi.RegisterInputType(reflect.TypeOf((*DependabotOrganizationSecretRepositoryArrayInput)(nil)).Elem(), DependabotOrganizationSecretRepositoryArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*DependabotOrganizationSecretRepositoryMapInput)(nil)).Elem(), DependabotOrganizationSecretRepositoryMap{}) + pulumi.RegisterOutputType(DependabotOrganizationSecretRepositoryOutput{}) + pulumi.RegisterOutputType(DependabotOrganizationSecretRepositoryArrayOutput{}) + pulumi.RegisterOutputType(DependabotOrganizationSecretRepositoryMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/dependabotSecret.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/dependabotSecret.go new file mode 100644 index 000000000..eed29da5c --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/dependabotSecret.go @@ -0,0 +1,501 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage GitHub Dependabot secrets within your GitHub repositories. +// You must have write access to a repository to use this resource. +// +// Secret values are encrypted using the [Go '/crypto/box' module](https://godoc.org/golang.org/x/crypto/nacl/box) which is +// interoperable with [libsodium](https://libsodium.gitbook.io/doc/). Libsodium is used by GitHub to decrypt secret values. +// +// For the purposes of security, the contents of the `value` field have been marked as `sensitive` to Terraform, +// but it is important to note that **this does not hide it from state files**. You should treat state as sensitive always. +// It is also advised that you do not store plaintext values in your code but rather populate the `valueEncrypted` +// using fields from a resource, data source or variable as, while encrypted in state, these will be easily accessible +// in your code. See below for an example of this abstraction. +// +// ## Example Usage +// +// ```go +// 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.NewDependabotSecret(ctx, "example_plaintext", &github.DependabotSecretArgs{ +// Repository: pulumi.String("example_repository"), +// SecretName: pulumi.String("example_secret_name"), +// Value: pulumi.Any(someSecretString), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewDependabotSecret(ctx, "example_encrypted", &github.DependabotSecretArgs{ +// Repository: pulumi.String("example_repository"), +// SecretName: pulumi.String("example_secret_name"), +// ValueEncrypted: pulumi.Any(someEncryptedSecretString), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Example Lifecycle Ignore Changes +// +// This resource supports using the `lifecycle` `ignoreChanges` block on `remoteUpdatedAt` to support use cases where a secret value is created using a placeholder value and then modified after creation outside the scope of Terraform. This approach ensures only the initial placeholder value is referenced in your code and in the resulting state file. +// +// ```go +// 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.NewDependabotSecret(ctx, "example_allow_drift", &github.DependabotSecretArgs{ +// Repository: pulumi.String("example_repository"), +// SecretName: pulumi.String("example_secret_name"), +// Value: pulumi.String("placeholder"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using an ID made of the repository name, and secret name separated by a `:`. +// +// > **Note**: When importing secrets, the `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` fields will not be populated in the state. You may need to ignore changes for these as a workaround if you're not planning on updating the secret through Terraform. +// +// ### Import Command +// +// The following command imports a GitHub Dependabot secret named `mysecret` for the repo `myrepo` to a `DependabotSecret` resource named `example`. +// +// ```sh +// $ pulumi import github:index/dependabotSecret:DependabotSecret example myrepo:mysecret +// ``` +type DependabotSecret struct { + pulumi.CustomResourceState + + // Date the secret was created. + CreatedAt pulumi.StringOutput `pulumi:"createdAt"` + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue pulumi.StringPtrOutput `pulumi:"encryptedValue"` + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId pulumi.StringOutput `pulumi:"keyId"` + // (Optional) Please use `value`. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: Use value. + PlaintextValue pulumi.StringPtrOutput `pulumi:"plaintextValue"` + // Date the secret was last updated in GitHub. + RemoteUpdatedAt pulumi.StringOutput `pulumi:"remoteUpdatedAt"` + // Name of the repository. + Repository pulumi.StringOutput `pulumi:"repository"` + // ID of the repository. + RepositoryId pulumi.IntOutput `pulumi:"repositoryId"` + // Name of the secret. + SecretName pulumi.StringOutput `pulumi:"secretName"` + // Date the secret was last updated by the provider. + UpdatedAt pulumi.StringOutput `pulumi:"updatedAt"` + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value pulumi.StringPtrOutput `pulumi:"value"` + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted pulumi.StringPtrOutput `pulumi:"valueEncrypted"` +} + +// NewDependabotSecret registers a new resource with the given unique name, arguments, and options. +func NewDependabotSecret(ctx *pulumi.Context, + name string, args *DependabotSecretArgs, opts ...pulumi.ResourceOption) (*DependabotSecret, 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.SecretName == nil { + return nil, errors.New("invalid value for required argument 'SecretName'") + } + if args.EncryptedValue != nil { + args.EncryptedValue = pulumi.ToSecret(args.EncryptedValue).(pulumi.StringPtrInput) + } + if args.PlaintextValue != nil { + args.PlaintextValue = pulumi.ToSecret(args.PlaintextValue).(pulumi.StringPtrInput) + } + if args.Value != nil { + args.Value = pulumi.ToSecret(args.Value).(pulumi.StringPtrInput) + } + if args.ValueEncrypted != nil { + args.ValueEncrypted = pulumi.ToSecret(args.ValueEncrypted).(pulumi.StringPtrInput) + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "encryptedValue", + "plaintextValue", + "value", + "valueEncrypted", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource DependabotSecret + err := ctx.RegisterResource("github:index/dependabotSecret:DependabotSecret", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetDependabotSecret gets an existing DependabotSecret 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 GetDependabotSecret(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *DependabotSecretState, opts ...pulumi.ResourceOption) (*DependabotSecret, error) { + var resource DependabotSecret + err := ctx.ReadResource("github:index/dependabotSecret:DependabotSecret", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering DependabotSecret resources. +type dependabotSecretState struct { + // Date the secret was created. + CreatedAt *string `pulumi:"createdAt"` + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue *string `pulumi:"encryptedValue"` + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId *string `pulumi:"keyId"` + // (Optional) Please use `value`. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: Use value. + PlaintextValue *string `pulumi:"plaintextValue"` + // Date the secret was last updated in GitHub. + RemoteUpdatedAt *string `pulumi:"remoteUpdatedAt"` + // Name of the repository. + Repository *string `pulumi:"repository"` + // ID of the repository. + RepositoryId *int `pulumi:"repositoryId"` + // Name of the secret. + SecretName *string `pulumi:"secretName"` + // Date the secret was last updated by the provider. + UpdatedAt *string `pulumi:"updatedAt"` + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value *string `pulumi:"value"` + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted *string `pulumi:"valueEncrypted"` +} + +type DependabotSecretState struct { + // Date the secret was created. + CreatedAt pulumi.StringPtrInput + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue pulumi.StringPtrInput + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId pulumi.StringPtrInput + // (Optional) Please use `value`. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: Use value. + PlaintextValue pulumi.StringPtrInput + // Date the secret was last updated in GitHub. + RemoteUpdatedAt pulumi.StringPtrInput + // Name of the repository. + Repository pulumi.StringPtrInput + // ID of the repository. + RepositoryId pulumi.IntPtrInput + // Name of the secret. + SecretName pulumi.StringPtrInput + // Date the secret was last updated by the provider. + UpdatedAt pulumi.StringPtrInput + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value pulumi.StringPtrInput + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted pulumi.StringPtrInput +} + +func (DependabotSecretState) ElementType() reflect.Type { + return reflect.TypeOf((*dependabotSecretState)(nil)).Elem() +} + +type dependabotSecretArgs struct { + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue *string `pulumi:"encryptedValue"` + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId *string `pulumi:"keyId"` + // (Optional) Please use `value`. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: Use value. + PlaintextValue *string `pulumi:"plaintextValue"` + // Name of the repository. + Repository string `pulumi:"repository"` + // Name of the secret. + SecretName string `pulumi:"secretName"` + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value *string `pulumi:"value"` + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted *string `pulumi:"valueEncrypted"` +} + +// The set of arguments for constructing a DependabotSecret resource. +type DependabotSecretArgs struct { + // (Optional) Please use `valueEncrypted`. + // + // Deprecated: Use valueEncrypted and key_id. + EncryptedValue pulumi.StringPtrInput + // ID of the public key used to encrypt the secret, required when setting `encryptedValue`. + KeyId pulumi.StringPtrInput + // (Optional) Please use `value`. + // + // > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. + // + // Deprecated: Use value. + PlaintextValue pulumi.StringPtrInput + // Name of the repository. + Repository pulumi.StringInput + // Name of the secret. + SecretName pulumi.StringInput + // Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. + Value pulumi.StringPtrInput + // Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. + ValueEncrypted pulumi.StringPtrInput +} + +func (DependabotSecretArgs) ElementType() reflect.Type { + return reflect.TypeOf((*dependabotSecretArgs)(nil)).Elem() +} + +type DependabotSecretInput interface { + pulumi.Input + + ToDependabotSecretOutput() DependabotSecretOutput + ToDependabotSecretOutputWithContext(ctx context.Context) DependabotSecretOutput +} + +func (*DependabotSecret) ElementType() reflect.Type { + return reflect.TypeOf((**DependabotSecret)(nil)).Elem() +} + +func (i *DependabotSecret) ToDependabotSecretOutput() DependabotSecretOutput { + return i.ToDependabotSecretOutputWithContext(context.Background()) +} + +func (i *DependabotSecret) ToDependabotSecretOutputWithContext(ctx context.Context) DependabotSecretOutput { + return pulumi.ToOutputWithContext(ctx, i).(DependabotSecretOutput) +} + +// DependabotSecretArrayInput is an input type that accepts DependabotSecretArray and DependabotSecretArrayOutput values. +// You can construct a concrete instance of `DependabotSecretArrayInput` via: +// +// DependabotSecretArray{ DependabotSecretArgs{...} } +type DependabotSecretArrayInput interface { + pulumi.Input + + ToDependabotSecretArrayOutput() DependabotSecretArrayOutput + ToDependabotSecretArrayOutputWithContext(context.Context) DependabotSecretArrayOutput +} + +type DependabotSecretArray []DependabotSecretInput + +func (DependabotSecretArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*DependabotSecret)(nil)).Elem() +} + +func (i DependabotSecretArray) ToDependabotSecretArrayOutput() DependabotSecretArrayOutput { + return i.ToDependabotSecretArrayOutputWithContext(context.Background()) +} + +func (i DependabotSecretArray) ToDependabotSecretArrayOutputWithContext(ctx context.Context) DependabotSecretArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(DependabotSecretArrayOutput) +} + +// DependabotSecretMapInput is an input type that accepts DependabotSecretMap and DependabotSecretMapOutput values. +// You can construct a concrete instance of `DependabotSecretMapInput` via: +// +// DependabotSecretMap{ "key": DependabotSecretArgs{...} } +type DependabotSecretMapInput interface { + pulumi.Input + + ToDependabotSecretMapOutput() DependabotSecretMapOutput + ToDependabotSecretMapOutputWithContext(context.Context) DependabotSecretMapOutput +} + +type DependabotSecretMap map[string]DependabotSecretInput + +func (DependabotSecretMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*DependabotSecret)(nil)).Elem() +} + +func (i DependabotSecretMap) ToDependabotSecretMapOutput() DependabotSecretMapOutput { + return i.ToDependabotSecretMapOutputWithContext(context.Background()) +} + +func (i DependabotSecretMap) ToDependabotSecretMapOutputWithContext(ctx context.Context) DependabotSecretMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(DependabotSecretMapOutput) +} + +type DependabotSecretOutput struct{ *pulumi.OutputState } + +func (DependabotSecretOutput) ElementType() reflect.Type { + return reflect.TypeOf((**DependabotSecret)(nil)).Elem() +} + +func (o DependabotSecretOutput) ToDependabotSecretOutput() DependabotSecretOutput { + return o +} + +func (o DependabotSecretOutput) ToDependabotSecretOutputWithContext(ctx context.Context) DependabotSecretOutput { + return o +} + +// Date the secret was created. +func (o DependabotSecretOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *DependabotSecret) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) +} + +// (Optional) Please use `valueEncrypted`. +// +// Deprecated: Use valueEncrypted and key_id. +func (o DependabotSecretOutput) EncryptedValue() pulumi.StringPtrOutput { + return o.ApplyT(func(v *DependabotSecret) pulumi.StringPtrOutput { return v.EncryptedValue }).(pulumi.StringPtrOutput) +} + +// ID of the public key used to encrypt the secret, required when setting `encryptedValue`. +func (o DependabotSecretOutput) KeyId() pulumi.StringOutput { + return o.ApplyT(func(v *DependabotSecret) pulumi.StringOutput { return v.KeyId }).(pulumi.StringOutput) +} + +// (Optional) Please use `value`. +// +// > **Note**: One of either `value`, `valueEncrypted`, `encryptedValue`, or `plaintextValue` must be specified. +// +// Deprecated: Use value. +func (o DependabotSecretOutput) PlaintextValue() pulumi.StringPtrOutput { + return o.ApplyT(func(v *DependabotSecret) pulumi.StringPtrOutput { return v.PlaintextValue }).(pulumi.StringPtrOutput) +} + +// Date the secret was last updated in GitHub. +func (o DependabotSecretOutput) RemoteUpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *DependabotSecret) pulumi.StringOutput { return v.RemoteUpdatedAt }).(pulumi.StringOutput) +} + +// Name of the repository. +func (o DependabotSecretOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *DependabotSecret) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// ID of the repository. +func (o DependabotSecretOutput) RepositoryId() pulumi.IntOutput { + return o.ApplyT(func(v *DependabotSecret) pulumi.IntOutput { return v.RepositoryId }).(pulumi.IntOutput) +} + +// Name of the secret. +func (o DependabotSecretOutput) SecretName() pulumi.StringOutput { + return o.ApplyT(func(v *DependabotSecret) pulumi.StringOutput { return v.SecretName }).(pulumi.StringOutput) +} + +// Date the secret was last updated by the provider. +func (o DependabotSecretOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *DependabotSecret) pulumi.StringOutput { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// Plaintext value of the secret to be encrypted. This conflicts with `valueEncrypted`, `encryptedValue` & `plaintextValue`. +func (o DependabotSecretOutput) Value() pulumi.StringPtrOutput { + return o.ApplyT(func(v *DependabotSecret) pulumi.StringPtrOutput { return v.Value }).(pulumi.StringPtrOutput) +} + +// Encrypted value of the secret using the GitHub public key in Base64 format, `keyId` is required with this value. This conflicts with `value`, `encryptedValue` & `plaintextValue`. +func (o DependabotSecretOutput) ValueEncrypted() pulumi.StringPtrOutput { + return o.ApplyT(func(v *DependabotSecret) pulumi.StringPtrOutput { return v.ValueEncrypted }).(pulumi.StringPtrOutput) +} + +type DependabotSecretArrayOutput struct{ *pulumi.OutputState } + +func (DependabotSecretArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*DependabotSecret)(nil)).Elem() +} + +func (o DependabotSecretArrayOutput) ToDependabotSecretArrayOutput() DependabotSecretArrayOutput { + return o +} + +func (o DependabotSecretArrayOutput) ToDependabotSecretArrayOutputWithContext(ctx context.Context) DependabotSecretArrayOutput { + return o +} + +func (o DependabotSecretArrayOutput) Index(i pulumi.IntInput) DependabotSecretOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DependabotSecret { + return vs[0].([]*DependabotSecret)[vs[1].(int)] + }).(DependabotSecretOutput) +} + +type DependabotSecretMapOutput struct{ *pulumi.OutputState } + +func (DependabotSecretMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*DependabotSecret)(nil)).Elem() +} + +func (o DependabotSecretMapOutput) ToDependabotSecretMapOutput() DependabotSecretMapOutput { + return o +} + +func (o DependabotSecretMapOutput) ToDependabotSecretMapOutputWithContext(ctx context.Context) DependabotSecretMapOutput { + return o +} + +func (o DependabotSecretMapOutput) MapIndex(k pulumi.StringInput) DependabotSecretOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DependabotSecret { + return vs[0].(map[string]*DependabotSecret)[vs[1].(string)] + }).(DependabotSecretOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*DependabotSecretInput)(nil)).Elem(), &DependabotSecret{}) + pulumi.RegisterInputType(reflect.TypeOf((*DependabotSecretArrayInput)(nil)).Elem(), DependabotSecretArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*DependabotSecretMapInput)(nil)).Elem(), DependabotSecretMap{}) + pulumi.RegisterOutputType(DependabotSecretOutput{}) + pulumi.RegisterOutputType(DependabotSecretArrayOutput{}) + pulumi.RegisterOutputType(DependabotSecretMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/doc.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/doc.go new file mode 100644 index 000000000..3b3225d50 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/doc.go @@ -0,0 +1,2 @@ +// A Pulumi package for creating and managing github cloud resources. +package github diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/emuGroupMapping.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/emuGroupMapping.go new file mode 100644 index 000000000..5ba55ffcc --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/emuGroupMapping.go @@ -0,0 +1,305 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource manages mappings between external groups for enterprise managed users and GitHub teams. It wraps the [Teams#ExternalGroups API](https://docs.github.com/en/rest/reference/teams#external-groups). Note that this is a distinct resource from `TeamSyncGroupMapping`. `EmuGroupMapping` is special to the Enterprise Managed User (EMU) external group feature, whereas `TeamSyncGroupMapping` is specific to Identity Provider Groups. +// +// ## Example Usage +// +// ```go +// 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.NewEmuGroupMapping(ctx, "example_emu_group_mapping", &github.EmuGroupMappingArgs{ +// TeamSlug: pulumi.String("emu-test-team"), +// GroupId: pulumi.Int(28836), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub EMU External Group Mappings can be imported using the external `groupId` and `teamSlug` separated by a colon, e.g. +// +// ```sh +// $ pulumi import github:index/emuGroupMapping:EmuGroupMapping example_emu_group_mapping 28836:emu-test-team +// ``` +type EmuGroupMapping struct { + pulumi.CustomResourceState + + // An etag representing the external group state + Etag pulumi.StringOutput `pulumi:"etag"` + // Integer corresponding to the external group ID to be linked + GroupId pulumi.IntOutput `pulumi:"groupId"` + // The name of the external group + GroupName pulumi.StringOutput `pulumi:"groupName"` + // The ID of the GitHub team + TeamId pulumi.IntOutput `pulumi:"teamId"` + // Slug of the GitHub team + TeamSlug pulumi.StringOutput `pulumi:"teamSlug"` +} + +// NewEmuGroupMapping registers a new resource with the given unique name, arguments, and options. +func NewEmuGroupMapping(ctx *pulumi.Context, + name string, args *EmuGroupMappingArgs, opts ...pulumi.ResourceOption) (*EmuGroupMapping, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.GroupId == nil { + return nil, errors.New("invalid value for required argument 'GroupId'") + } + if args.TeamSlug == nil { + return nil, errors.New("invalid value for required argument 'TeamSlug'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource EmuGroupMapping + err := ctx.RegisterResource("github:index/emuGroupMapping:EmuGroupMapping", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetEmuGroupMapping gets an existing EmuGroupMapping 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 GetEmuGroupMapping(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *EmuGroupMappingState, opts ...pulumi.ResourceOption) (*EmuGroupMapping, error) { + var resource EmuGroupMapping + err := ctx.ReadResource("github:index/emuGroupMapping:EmuGroupMapping", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering EmuGroupMapping resources. +type emuGroupMappingState struct { + // An etag representing the external group state + Etag *string `pulumi:"etag"` + // Integer corresponding to the external group ID to be linked + GroupId *int `pulumi:"groupId"` + // The name of the external group + GroupName *string `pulumi:"groupName"` + // The ID of the GitHub team + TeamId *int `pulumi:"teamId"` + // Slug of the GitHub team + TeamSlug *string `pulumi:"teamSlug"` +} + +type EmuGroupMappingState struct { + // An etag representing the external group state + Etag pulumi.StringPtrInput + // Integer corresponding to the external group ID to be linked + GroupId pulumi.IntPtrInput + // The name of the external group + GroupName pulumi.StringPtrInput + // The ID of the GitHub team + TeamId pulumi.IntPtrInput + // Slug of the GitHub team + TeamSlug pulumi.StringPtrInput +} + +func (EmuGroupMappingState) ElementType() reflect.Type { + return reflect.TypeOf((*emuGroupMappingState)(nil)).Elem() +} + +type emuGroupMappingArgs struct { + // Integer corresponding to the external group ID to be linked + GroupId int `pulumi:"groupId"` + // Slug of the GitHub team + TeamSlug string `pulumi:"teamSlug"` +} + +// The set of arguments for constructing a EmuGroupMapping resource. +type EmuGroupMappingArgs struct { + // Integer corresponding to the external group ID to be linked + GroupId pulumi.IntInput + // Slug of the GitHub team + TeamSlug pulumi.StringInput +} + +func (EmuGroupMappingArgs) ElementType() reflect.Type { + return reflect.TypeOf((*emuGroupMappingArgs)(nil)).Elem() +} + +type EmuGroupMappingInput interface { + pulumi.Input + + ToEmuGroupMappingOutput() EmuGroupMappingOutput + ToEmuGroupMappingOutputWithContext(ctx context.Context) EmuGroupMappingOutput +} + +func (*EmuGroupMapping) ElementType() reflect.Type { + return reflect.TypeOf((**EmuGroupMapping)(nil)).Elem() +} + +func (i *EmuGroupMapping) ToEmuGroupMappingOutput() EmuGroupMappingOutput { + return i.ToEmuGroupMappingOutputWithContext(context.Background()) +} + +func (i *EmuGroupMapping) ToEmuGroupMappingOutputWithContext(ctx context.Context) EmuGroupMappingOutput { + return pulumi.ToOutputWithContext(ctx, i).(EmuGroupMappingOutput) +} + +// EmuGroupMappingArrayInput is an input type that accepts EmuGroupMappingArray and EmuGroupMappingArrayOutput values. +// You can construct a concrete instance of `EmuGroupMappingArrayInput` via: +// +// EmuGroupMappingArray{ EmuGroupMappingArgs{...} } +type EmuGroupMappingArrayInput interface { + pulumi.Input + + ToEmuGroupMappingArrayOutput() EmuGroupMappingArrayOutput + ToEmuGroupMappingArrayOutputWithContext(context.Context) EmuGroupMappingArrayOutput +} + +type EmuGroupMappingArray []EmuGroupMappingInput + +func (EmuGroupMappingArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*EmuGroupMapping)(nil)).Elem() +} + +func (i EmuGroupMappingArray) ToEmuGroupMappingArrayOutput() EmuGroupMappingArrayOutput { + return i.ToEmuGroupMappingArrayOutputWithContext(context.Background()) +} + +func (i EmuGroupMappingArray) ToEmuGroupMappingArrayOutputWithContext(ctx context.Context) EmuGroupMappingArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(EmuGroupMappingArrayOutput) +} + +// EmuGroupMappingMapInput is an input type that accepts EmuGroupMappingMap and EmuGroupMappingMapOutput values. +// You can construct a concrete instance of `EmuGroupMappingMapInput` via: +// +// EmuGroupMappingMap{ "key": EmuGroupMappingArgs{...} } +type EmuGroupMappingMapInput interface { + pulumi.Input + + ToEmuGroupMappingMapOutput() EmuGroupMappingMapOutput + ToEmuGroupMappingMapOutputWithContext(context.Context) EmuGroupMappingMapOutput +} + +type EmuGroupMappingMap map[string]EmuGroupMappingInput + +func (EmuGroupMappingMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*EmuGroupMapping)(nil)).Elem() +} + +func (i EmuGroupMappingMap) ToEmuGroupMappingMapOutput() EmuGroupMappingMapOutput { + return i.ToEmuGroupMappingMapOutputWithContext(context.Background()) +} + +func (i EmuGroupMappingMap) ToEmuGroupMappingMapOutputWithContext(ctx context.Context) EmuGroupMappingMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(EmuGroupMappingMapOutput) +} + +type EmuGroupMappingOutput struct{ *pulumi.OutputState } + +func (EmuGroupMappingOutput) ElementType() reflect.Type { + return reflect.TypeOf((**EmuGroupMapping)(nil)).Elem() +} + +func (o EmuGroupMappingOutput) ToEmuGroupMappingOutput() EmuGroupMappingOutput { + return o +} + +func (o EmuGroupMappingOutput) ToEmuGroupMappingOutputWithContext(ctx context.Context) EmuGroupMappingOutput { + return o +} + +// An etag representing the external group state +func (o EmuGroupMappingOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *EmuGroupMapping) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// Integer corresponding to the external group ID to be linked +func (o EmuGroupMappingOutput) GroupId() pulumi.IntOutput { + return o.ApplyT(func(v *EmuGroupMapping) pulumi.IntOutput { return v.GroupId }).(pulumi.IntOutput) +} + +// The name of the external group +func (o EmuGroupMappingOutput) GroupName() pulumi.StringOutput { + return o.ApplyT(func(v *EmuGroupMapping) pulumi.StringOutput { return v.GroupName }).(pulumi.StringOutput) +} + +// The ID of the GitHub team +func (o EmuGroupMappingOutput) TeamId() pulumi.IntOutput { + return o.ApplyT(func(v *EmuGroupMapping) pulumi.IntOutput { return v.TeamId }).(pulumi.IntOutput) +} + +// Slug of the GitHub team +func (o EmuGroupMappingOutput) TeamSlug() pulumi.StringOutput { + return o.ApplyT(func(v *EmuGroupMapping) pulumi.StringOutput { return v.TeamSlug }).(pulumi.StringOutput) +} + +type EmuGroupMappingArrayOutput struct{ *pulumi.OutputState } + +func (EmuGroupMappingArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*EmuGroupMapping)(nil)).Elem() +} + +func (o EmuGroupMappingArrayOutput) ToEmuGroupMappingArrayOutput() EmuGroupMappingArrayOutput { + return o +} + +func (o EmuGroupMappingArrayOutput) ToEmuGroupMappingArrayOutputWithContext(ctx context.Context) EmuGroupMappingArrayOutput { + return o +} + +func (o EmuGroupMappingArrayOutput) Index(i pulumi.IntInput) EmuGroupMappingOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EmuGroupMapping { + return vs[0].([]*EmuGroupMapping)[vs[1].(int)] + }).(EmuGroupMappingOutput) +} + +type EmuGroupMappingMapOutput struct{ *pulumi.OutputState } + +func (EmuGroupMappingMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*EmuGroupMapping)(nil)).Elem() +} + +func (o EmuGroupMappingMapOutput) ToEmuGroupMappingMapOutput() EmuGroupMappingMapOutput { + return o +} + +func (o EmuGroupMappingMapOutput) ToEmuGroupMappingMapOutputWithContext(ctx context.Context) EmuGroupMappingMapOutput { + return o +} + +func (o EmuGroupMappingMapOutput) MapIndex(k pulumi.StringInput) EmuGroupMappingOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EmuGroupMapping { + return vs[0].(map[string]*EmuGroupMapping)[vs[1].(string)] + }).(EmuGroupMappingOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*EmuGroupMappingInput)(nil)).Elem(), &EmuGroupMapping{}) + pulumi.RegisterInputType(reflect.TypeOf((*EmuGroupMappingArrayInput)(nil)).Elem(), EmuGroupMappingArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*EmuGroupMappingMapInput)(nil)).Elem(), EmuGroupMappingMap{}) + pulumi.RegisterOutputType(EmuGroupMappingOutput{}) + pulumi.RegisterOutputType(EmuGroupMappingArrayOutput{}) + pulumi.RegisterOutputType(EmuGroupMappingMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseActionsPermissions.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseActionsPermissions.go new file mode 100644 index 000000000..d889a778f --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseActionsPermissions.go @@ -0,0 +1,342 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage GitHub Actions permissions within your GitHub enterprise. +// You must have admin access to an enterprise to use this resource. +// +// ## Example Usage +// +// ```go +// 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_org, err := github.GetOrganization(ctx, &github.GetOrganizationArgs{ +// Name: "my-org", +// }, nil) +// if err != nil { +// return err +// } +// _, err = github.NewEnterpriseActionsPermissions(ctx, "test", &github.EnterpriseActionsPermissionsArgs{ +// EnterpriseSlug: pulumi.String("my-enterprise"), +// AllowedActions: pulumi.String("selected"), +// EnabledOrganizations: pulumi.String("selected"), +// AllowedActionsConfig: &github.EnterpriseActionsPermissionsAllowedActionsConfigArgs{ +// GithubOwnedAllowed: pulumi.Bool(true), +// PatternsAlloweds: pulumi.StringArray{ +// pulumi.String("actions/cache@*"), +// pulumi.String("actions/checkout@*"), +// }, +// VerifiedAllowed: pulumi.Bool(true), +// }, +// EnabledOrganizationsConfig: &github.EnterpriseActionsPermissionsEnabledOrganizationsConfigArgs{ +// OrganizationIds: pulumi.IntArray{ +// pulumi.Int(pulumi.String(example_org.Id)), +// }, +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using the name of the GitHub enterprise: +// +// ```sh +// $ pulumi import github:index/enterpriseActionsPermissions:EnterpriseActionsPermissions test github_enterprise_name +// ``` +type EnterpriseActionsPermissions struct { + pulumi.CustomResourceState + + // The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. + AllowedActions pulumi.StringPtrOutput `pulumi:"allowedActions"` + // Sets the actions that are allowed in an enterprise. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. + AllowedActionsConfig EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput `pulumi:"allowedActionsConfig"` + // The policy that controls the organizations in the enterprise that are allowed to run GitHub Actions. Can be one of: `all`, `none`, or `selected`. + EnabledOrganizations pulumi.StringOutput `pulumi:"enabledOrganizations"` + // Sets the list of selected organizations that are enabled for GitHub Actions in an enterprise. Only available when `enabledOrganizations` = `selected`. See Enabled Organizations Config below for details. + EnabledOrganizationsConfig EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput `pulumi:"enabledOrganizationsConfig"` + // The slug of the enterprise. + EnterpriseSlug pulumi.StringOutput `pulumi:"enterpriseSlug"` +} + +// NewEnterpriseActionsPermissions registers a new resource with the given unique name, arguments, and options. +func NewEnterpriseActionsPermissions(ctx *pulumi.Context, + name string, args *EnterpriseActionsPermissionsArgs, opts ...pulumi.ResourceOption) (*EnterpriseActionsPermissions, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.EnabledOrganizations == nil { + return nil, errors.New("invalid value for required argument 'EnabledOrganizations'") + } + if args.EnterpriseSlug == nil { + return nil, errors.New("invalid value for required argument 'EnterpriseSlug'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource EnterpriseActionsPermissions + err := ctx.RegisterResource("github:index/enterpriseActionsPermissions:EnterpriseActionsPermissions", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetEnterpriseActionsPermissions gets an existing EnterpriseActionsPermissions 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 GetEnterpriseActionsPermissions(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *EnterpriseActionsPermissionsState, opts ...pulumi.ResourceOption) (*EnterpriseActionsPermissions, error) { + var resource EnterpriseActionsPermissions + err := ctx.ReadResource("github:index/enterpriseActionsPermissions:EnterpriseActionsPermissions", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering EnterpriseActionsPermissions resources. +type enterpriseActionsPermissionsState struct { + // The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. + AllowedActions *string `pulumi:"allowedActions"` + // Sets the actions that are allowed in an enterprise. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. + AllowedActionsConfig *EnterpriseActionsPermissionsAllowedActionsConfig `pulumi:"allowedActionsConfig"` + // The policy that controls the organizations in the enterprise that are allowed to run GitHub Actions. Can be one of: `all`, `none`, or `selected`. + EnabledOrganizations *string `pulumi:"enabledOrganizations"` + // Sets the list of selected organizations that are enabled for GitHub Actions in an enterprise. Only available when `enabledOrganizations` = `selected`. See Enabled Organizations Config below for details. + EnabledOrganizationsConfig *EnterpriseActionsPermissionsEnabledOrganizationsConfig `pulumi:"enabledOrganizationsConfig"` + // The slug of the enterprise. + EnterpriseSlug *string `pulumi:"enterpriseSlug"` +} + +type EnterpriseActionsPermissionsState struct { + // The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. + AllowedActions pulumi.StringPtrInput + // Sets the actions that are allowed in an enterprise. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. + AllowedActionsConfig EnterpriseActionsPermissionsAllowedActionsConfigPtrInput + // The policy that controls the organizations in the enterprise that are allowed to run GitHub Actions. Can be one of: `all`, `none`, or `selected`. + EnabledOrganizations pulumi.StringPtrInput + // Sets the list of selected organizations that are enabled for GitHub Actions in an enterprise. Only available when `enabledOrganizations` = `selected`. See Enabled Organizations Config below for details. + EnabledOrganizationsConfig EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrInput + // The slug of the enterprise. + EnterpriseSlug pulumi.StringPtrInput +} + +func (EnterpriseActionsPermissionsState) ElementType() reflect.Type { + return reflect.TypeOf((*enterpriseActionsPermissionsState)(nil)).Elem() +} + +type enterpriseActionsPermissionsArgs struct { + // The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. + AllowedActions *string `pulumi:"allowedActions"` + // Sets the actions that are allowed in an enterprise. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. + AllowedActionsConfig *EnterpriseActionsPermissionsAllowedActionsConfig `pulumi:"allowedActionsConfig"` + // The policy that controls the organizations in the enterprise that are allowed to run GitHub Actions. Can be one of: `all`, `none`, or `selected`. + EnabledOrganizations string `pulumi:"enabledOrganizations"` + // Sets the list of selected organizations that are enabled for GitHub Actions in an enterprise. Only available when `enabledOrganizations` = `selected`. See Enabled Organizations Config below for details. + EnabledOrganizationsConfig *EnterpriseActionsPermissionsEnabledOrganizationsConfig `pulumi:"enabledOrganizationsConfig"` + // The slug of the enterprise. + EnterpriseSlug string `pulumi:"enterpriseSlug"` +} + +// The set of arguments for constructing a EnterpriseActionsPermissions resource. +type EnterpriseActionsPermissionsArgs struct { + // The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. + AllowedActions pulumi.StringPtrInput + // Sets the actions that are allowed in an enterprise. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. + AllowedActionsConfig EnterpriseActionsPermissionsAllowedActionsConfigPtrInput + // The policy that controls the organizations in the enterprise that are allowed to run GitHub Actions. Can be one of: `all`, `none`, or `selected`. + EnabledOrganizations pulumi.StringInput + // Sets the list of selected organizations that are enabled for GitHub Actions in an enterprise. Only available when `enabledOrganizations` = `selected`. See Enabled Organizations Config below for details. + EnabledOrganizationsConfig EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrInput + // The slug of the enterprise. + EnterpriseSlug pulumi.StringInput +} + +func (EnterpriseActionsPermissionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*enterpriseActionsPermissionsArgs)(nil)).Elem() +} + +type EnterpriseActionsPermissionsInput interface { + pulumi.Input + + ToEnterpriseActionsPermissionsOutput() EnterpriseActionsPermissionsOutput + ToEnterpriseActionsPermissionsOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsOutput +} + +func (*EnterpriseActionsPermissions) ElementType() reflect.Type { + return reflect.TypeOf((**EnterpriseActionsPermissions)(nil)).Elem() +} + +func (i *EnterpriseActionsPermissions) ToEnterpriseActionsPermissionsOutput() EnterpriseActionsPermissionsOutput { + return i.ToEnterpriseActionsPermissionsOutputWithContext(context.Background()) +} + +func (i *EnterpriseActionsPermissions) ToEnterpriseActionsPermissionsOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseActionsPermissionsOutput) +} + +// EnterpriseActionsPermissionsArrayInput is an input type that accepts EnterpriseActionsPermissionsArray and EnterpriseActionsPermissionsArrayOutput values. +// You can construct a concrete instance of `EnterpriseActionsPermissionsArrayInput` via: +// +// EnterpriseActionsPermissionsArray{ EnterpriseActionsPermissionsArgs{...} } +type EnterpriseActionsPermissionsArrayInput interface { + pulumi.Input + + ToEnterpriseActionsPermissionsArrayOutput() EnterpriseActionsPermissionsArrayOutput + ToEnterpriseActionsPermissionsArrayOutputWithContext(context.Context) EnterpriseActionsPermissionsArrayOutput +} + +type EnterpriseActionsPermissionsArray []EnterpriseActionsPermissionsInput + +func (EnterpriseActionsPermissionsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*EnterpriseActionsPermissions)(nil)).Elem() +} + +func (i EnterpriseActionsPermissionsArray) ToEnterpriseActionsPermissionsArrayOutput() EnterpriseActionsPermissionsArrayOutput { + return i.ToEnterpriseActionsPermissionsArrayOutputWithContext(context.Background()) +} + +func (i EnterpriseActionsPermissionsArray) ToEnterpriseActionsPermissionsArrayOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseActionsPermissionsArrayOutput) +} + +// EnterpriseActionsPermissionsMapInput is an input type that accepts EnterpriseActionsPermissionsMap and EnterpriseActionsPermissionsMapOutput values. +// You can construct a concrete instance of `EnterpriseActionsPermissionsMapInput` via: +// +// EnterpriseActionsPermissionsMap{ "key": EnterpriseActionsPermissionsArgs{...} } +type EnterpriseActionsPermissionsMapInput interface { + pulumi.Input + + ToEnterpriseActionsPermissionsMapOutput() EnterpriseActionsPermissionsMapOutput + ToEnterpriseActionsPermissionsMapOutputWithContext(context.Context) EnterpriseActionsPermissionsMapOutput +} + +type EnterpriseActionsPermissionsMap map[string]EnterpriseActionsPermissionsInput + +func (EnterpriseActionsPermissionsMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*EnterpriseActionsPermissions)(nil)).Elem() +} + +func (i EnterpriseActionsPermissionsMap) ToEnterpriseActionsPermissionsMapOutput() EnterpriseActionsPermissionsMapOutput { + return i.ToEnterpriseActionsPermissionsMapOutputWithContext(context.Background()) +} + +func (i EnterpriseActionsPermissionsMap) ToEnterpriseActionsPermissionsMapOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseActionsPermissionsMapOutput) +} + +type EnterpriseActionsPermissionsOutput struct{ *pulumi.OutputState } + +func (EnterpriseActionsPermissionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((**EnterpriseActionsPermissions)(nil)).Elem() +} + +func (o EnterpriseActionsPermissionsOutput) ToEnterpriseActionsPermissionsOutput() EnterpriseActionsPermissionsOutput { + return o +} + +func (o EnterpriseActionsPermissionsOutput) ToEnterpriseActionsPermissionsOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsOutput { + return o +} + +// The permissions policy that controls the actions that are allowed to run. Can be one of: `all`, `localOnly`, or `selected`. +func (o EnterpriseActionsPermissionsOutput) AllowedActions() pulumi.StringPtrOutput { + return o.ApplyT(func(v *EnterpriseActionsPermissions) pulumi.StringPtrOutput { return v.AllowedActions }).(pulumi.StringPtrOutput) +} + +// Sets the actions that are allowed in an enterprise. Only available when `allowedActions` = `selected`. See Allowed Actions Config below for details. +func (o EnterpriseActionsPermissionsOutput) AllowedActionsConfig() EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput { + return o.ApplyT(func(v *EnterpriseActionsPermissions) EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput { + return v.AllowedActionsConfig + }).(EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput) +} + +// The policy that controls the organizations in the enterprise that are allowed to run GitHub Actions. Can be one of: `all`, `none`, or `selected`. +func (o EnterpriseActionsPermissionsOutput) EnabledOrganizations() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseActionsPermissions) pulumi.StringOutput { return v.EnabledOrganizations }).(pulumi.StringOutput) +} + +// Sets the list of selected organizations that are enabled for GitHub Actions in an enterprise. Only available when `enabledOrganizations` = `selected`. See Enabled Organizations Config below for details. +func (o EnterpriseActionsPermissionsOutput) EnabledOrganizationsConfig() EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput { + return o.ApplyT(func(v *EnterpriseActionsPermissions) EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput { + return v.EnabledOrganizationsConfig + }).(EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput) +} + +// The slug of the enterprise. +func (o EnterpriseActionsPermissionsOutput) EnterpriseSlug() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseActionsPermissions) pulumi.StringOutput { return v.EnterpriseSlug }).(pulumi.StringOutput) +} + +type EnterpriseActionsPermissionsArrayOutput struct{ *pulumi.OutputState } + +func (EnterpriseActionsPermissionsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*EnterpriseActionsPermissions)(nil)).Elem() +} + +func (o EnterpriseActionsPermissionsArrayOutput) ToEnterpriseActionsPermissionsArrayOutput() EnterpriseActionsPermissionsArrayOutput { + return o +} + +func (o EnterpriseActionsPermissionsArrayOutput) ToEnterpriseActionsPermissionsArrayOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsArrayOutput { + return o +} + +func (o EnterpriseActionsPermissionsArrayOutput) Index(i pulumi.IntInput) EnterpriseActionsPermissionsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EnterpriseActionsPermissions { + return vs[0].([]*EnterpriseActionsPermissions)[vs[1].(int)] + }).(EnterpriseActionsPermissionsOutput) +} + +type EnterpriseActionsPermissionsMapOutput struct{ *pulumi.OutputState } + +func (EnterpriseActionsPermissionsMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*EnterpriseActionsPermissions)(nil)).Elem() +} + +func (o EnterpriseActionsPermissionsMapOutput) ToEnterpriseActionsPermissionsMapOutput() EnterpriseActionsPermissionsMapOutput { + return o +} + +func (o EnterpriseActionsPermissionsMapOutput) ToEnterpriseActionsPermissionsMapOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsMapOutput { + return o +} + +func (o EnterpriseActionsPermissionsMapOutput) MapIndex(k pulumi.StringInput) EnterpriseActionsPermissionsOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EnterpriseActionsPermissions { + return vs[0].(map[string]*EnterpriseActionsPermissions)[vs[1].(string)] + }).(EnterpriseActionsPermissionsOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseActionsPermissionsInput)(nil)).Elem(), &EnterpriseActionsPermissions{}) + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseActionsPermissionsArrayInput)(nil)).Elem(), EnterpriseActionsPermissionsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseActionsPermissionsMapInput)(nil)).Elem(), EnterpriseActionsPermissionsMap{}) + pulumi.RegisterOutputType(EnterpriseActionsPermissionsOutput{}) + pulumi.RegisterOutputType(EnterpriseActionsPermissionsArrayOutput{}) + pulumi.RegisterOutputType(EnterpriseActionsPermissionsMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseActionsRunnerGroup.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseActionsRunnerGroup.go new file mode 100644 index 000000000..cfc6b60ed --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseActionsRunnerGroup.go @@ -0,0 +1,418 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage GitHub Actions runner groups within your GitHub enterprise. +// You must have admin access to an enterprise to use this resource. +// +// ## Example Usage +// +// ```go +// 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 { +// enterprise, err := github.GetEnterprise(ctx, &github.GetEnterpriseArgs{ +// Slug: "my-enterprise", +// }, nil) +// if err != nil { +// return err +// } +// enterpriseOrganization, err := github.NewEnterpriseOrganization(ctx, "enterprise_organization", &github.EnterpriseOrganizationArgs{ +// EnterpriseId: pulumi.String(pulumi.String(enterprise.Id)), +// Name: pulumi.String("my-organization"), +// BillingEmail: pulumi.String("octocat@octo.cat"), +// AdminLogins: pulumi.StringArray{ +// pulumi.String("octocat"), +// }, +// }) +// if err != nil { +// return err +// } +// _, err = github.NewEnterpriseActionsRunnerGroup(ctx, "example", &github.EnterpriseActionsRunnerGroupArgs{ +// Name: pulumi.String("my-awesome-runner-group"), +// EnterpriseSlug: pulumi.String(pulumi.String(enterprise.Slug)), +// AllowsPublicRepositories: pulumi.Bool(true), +// Visibility: pulumi.String("selected"), +// SelectedOrganizationIds: pulumi.IntArray{ +// enterpriseOrganization.DatabaseId, +// }, +// RestrictedToWorkflows: pulumi.Bool(true), +// SelectedWorkflows: pulumi.StringArray{ +// pulumi.String("my-organization/my-repo/.github/workflows/cool-workflow.yaml@refs/tags/v1"), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using the enterprise slug and the ID of the runner group: +// +// ```sh +// $ pulumi import github:index/enterpriseActionsRunnerGroup:EnterpriseActionsRunnerGroup test enterprise-slug/42 +// ``` +type EnterpriseActionsRunnerGroup struct { + pulumi.CustomResourceState + + // Whether public repositories can be added to the runner group. Defaults to false. + AllowsPublicRepositories pulumi.BoolPtrOutput `pulumi:"allowsPublicRepositories"` + // Whether this is the default runner group + Default pulumi.BoolOutput `pulumi:"default"` + // The slug of the enterprise. + EnterpriseSlug pulumi.StringOutput `pulumi:"enterpriseSlug"` + // An etag representing the runner group object + Etag pulumi.StringOutput `pulumi:"etag"` + // Name of the runner group + Name pulumi.StringOutput `pulumi:"name"` + // If true, the runner group will be restricted to running only the workflows specified in the selectedWorkflows array. Defaults to false. + RestrictedToWorkflows pulumi.BoolPtrOutput `pulumi:"restrictedToWorkflows"` + // The GitHub API URL for the runner group's runners + RunnersUrl pulumi.StringOutput `pulumi:"runnersUrl"` + // IDs of the organizations which should be added to the runner group + SelectedOrganizationIds pulumi.IntArrayOutput `pulumi:"selectedOrganizationIds"` + // The GitHub API URL for the runner group's selected organizations + SelectedOrganizationsUrl pulumi.StringOutput `pulumi:"selectedOrganizationsUrl"` + // List of workflows the runner group should be allowed to run. This setting will be ignored unless restrictedToWorkflows is set to true. + SelectedWorkflows pulumi.StringArrayOutput `pulumi:"selectedWorkflows"` + // Visibility of a runner group to enterprise organizations. Whether the runner group can include `all` or `selected` + Visibility pulumi.StringOutput `pulumi:"visibility"` +} + +// NewEnterpriseActionsRunnerGroup registers a new resource with the given unique name, arguments, and options. +func NewEnterpriseActionsRunnerGroup(ctx *pulumi.Context, + name string, args *EnterpriseActionsRunnerGroupArgs, opts ...pulumi.ResourceOption) (*EnterpriseActionsRunnerGroup, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.EnterpriseSlug == nil { + return nil, errors.New("invalid value for required argument 'EnterpriseSlug'") + } + if args.Visibility == nil { + return nil, errors.New("invalid value for required argument 'Visibility'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource EnterpriseActionsRunnerGroup + err := ctx.RegisterResource("github:index/enterpriseActionsRunnerGroup:EnterpriseActionsRunnerGroup", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetEnterpriseActionsRunnerGroup gets an existing EnterpriseActionsRunnerGroup 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 GetEnterpriseActionsRunnerGroup(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *EnterpriseActionsRunnerGroupState, opts ...pulumi.ResourceOption) (*EnterpriseActionsRunnerGroup, error) { + var resource EnterpriseActionsRunnerGroup + err := ctx.ReadResource("github:index/enterpriseActionsRunnerGroup:EnterpriseActionsRunnerGroup", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering EnterpriseActionsRunnerGroup resources. +type enterpriseActionsRunnerGroupState struct { + // Whether public repositories can be added to the runner group. Defaults to false. + AllowsPublicRepositories *bool `pulumi:"allowsPublicRepositories"` + // Whether this is the default runner group + Default *bool `pulumi:"default"` + // The slug of the enterprise. + EnterpriseSlug *string `pulumi:"enterpriseSlug"` + // An etag representing the runner group object + Etag *string `pulumi:"etag"` + // Name of the runner group + Name *string `pulumi:"name"` + // If true, the runner group will be restricted to running only the workflows specified in the selectedWorkflows array. Defaults to false. + RestrictedToWorkflows *bool `pulumi:"restrictedToWorkflows"` + // The GitHub API URL for the runner group's runners + RunnersUrl *string `pulumi:"runnersUrl"` + // IDs of the organizations which should be added to the runner group + SelectedOrganizationIds []int `pulumi:"selectedOrganizationIds"` + // The GitHub API URL for the runner group's selected organizations + SelectedOrganizationsUrl *string `pulumi:"selectedOrganizationsUrl"` + // List of workflows the runner group should be allowed to run. This setting will be ignored unless restrictedToWorkflows is set to true. + SelectedWorkflows []string `pulumi:"selectedWorkflows"` + // Visibility of a runner group to enterprise organizations. Whether the runner group can include `all` or `selected` + Visibility *string `pulumi:"visibility"` +} + +type EnterpriseActionsRunnerGroupState struct { + // Whether public repositories can be added to the runner group. Defaults to false. + AllowsPublicRepositories pulumi.BoolPtrInput + // Whether this is the default runner group + Default pulumi.BoolPtrInput + // The slug of the enterprise. + EnterpriseSlug pulumi.StringPtrInput + // An etag representing the runner group object + Etag pulumi.StringPtrInput + // Name of the runner group + Name pulumi.StringPtrInput + // If true, the runner group will be restricted to running only the workflows specified in the selectedWorkflows array. Defaults to false. + RestrictedToWorkflows pulumi.BoolPtrInput + // The GitHub API URL for the runner group's runners + RunnersUrl pulumi.StringPtrInput + // IDs of the organizations which should be added to the runner group + SelectedOrganizationIds pulumi.IntArrayInput + // The GitHub API URL for the runner group's selected organizations + SelectedOrganizationsUrl pulumi.StringPtrInput + // List of workflows the runner group should be allowed to run. This setting will be ignored unless restrictedToWorkflows is set to true. + SelectedWorkflows pulumi.StringArrayInput + // Visibility of a runner group to enterprise organizations. Whether the runner group can include `all` or `selected` + Visibility pulumi.StringPtrInput +} + +func (EnterpriseActionsRunnerGroupState) ElementType() reflect.Type { + return reflect.TypeOf((*enterpriseActionsRunnerGroupState)(nil)).Elem() +} + +type enterpriseActionsRunnerGroupArgs struct { + // Whether public repositories can be added to the runner group. Defaults to false. + AllowsPublicRepositories *bool `pulumi:"allowsPublicRepositories"` + // The slug of the enterprise. + EnterpriseSlug string `pulumi:"enterpriseSlug"` + // Name of the runner group + Name *string `pulumi:"name"` + // If true, the runner group will be restricted to running only the workflows specified in the selectedWorkflows array. Defaults to false. + RestrictedToWorkflows *bool `pulumi:"restrictedToWorkflows"` + // IDs of the organizations which should be added to the runner group + SelectedOrganizationIds []int `pulumi:"selectedOrganizationIds"` + // List of workflows the runner group should be allowed to run. This setting will be ignored unless restrictedToWorkflows is set to true. + SelectedWorkflows []string `pulumi:"selectedWorkflows"` + // Visibility of a runner group to enterprise organizations. Whether the runner group can include `all` or `selected` + Visibility string `pulumi:"visibility"` +} + +// The set of arguments for constructing a EnterpriseActionsRunnerGroup resource. +type EnterpriseActionsRunnerGroupArgs struct { + // Whether public repositories can be added to the runner group. Defaults to false. + AllowsPublicRepositories pulumi.BoolPtrInput + // The slug of the enterprise. + EnterpriseSlug pulumi.StringInput + // Name of the runner group + Name pulumi.StringPtrInput + // If true, the runner group will be restricted to running only the workflows specified in the selectedWorkflows array. Defaults to false. + RestrictedToWorkflows pulumi.BoolPtrInput + // IDs of the organizations which should be added to the runner group + SelectedOrganizationIds pulumi.IntArrayInput + // List of workflows the runner group should be allowed to run. This setting will be ignored unless restrictedToWorkflows is set to true. + SelectedWorkflows pulumi.StringArrayInput + // Visibility of a runner group to enterprise organizations. Whether the runner group can include `all` or `selected` + Visibility pulumi.StringInput +} + +func (EnterpriseActionsRunnerGroupArgs) ElementType() reflect.Type { + return reflect.TypeOf((*enterpriseActionsRunnerGroupArgs)(nil)).Elem() +} + +type EnterpriseActionsRunnerGroupInput interface { + pulumi.Input + + ToEnterpriseActionsRunnerGroupOutput() EnterpriseActionsRunnerGroupOutput + ToEnterpriseActionsRunnerGroupOutputWithContext(ctx context.Context) EnterpriseActionsRunnerGroupOutput +} + +func (*EnterpriseActionsRunnerGroup) ElementType() reflect.Type { + return reflect.TypeOf((**EnterpriseActionsRunnerGroup)(nil)).Elem() +} + +func (i *EnterpriseActionsRunnerGroup) ToEnterpriseActionsRunnerGroupOutput() EnterpriseActionsRunnerGroupOutput { + return i.ToEnterpriseActionsRunnerGroupOutputWithContext(context.Background()) +} + +func (i *EnterpriseActionsRunnerGroup) ToEnterpriseActionsRunnerGroupOutputWithContext(ctx context.Context) EnterpriseActionsRunnerGroupOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseActionsRunnerGroupOutput) +} + +// EnterpriseActionsRunnerGroupArrayInput is an input type that accepts EnterpriseActionsRunnerGroupArray and EnterpriseActionsRunnerGroupArrayOutput values. +// You can construct a concrete instance of `EnterpriseActionsRunnerGroupArrayInput` via: +// +// EnterpriseActionsRunnerGroupArray{ EnterpriseActionsRunnerGroupArgs{...} } +type EnterpriseActionsRunnerGroupArrayInput interface { + pulumi.Input + + ToEnterpriseActionsRunnerGroupArrayOutput() EnterpriseActionsRunnerGroupArrayOutput + ToEnterpriseActionsRunnerGroupArrayOutputWithContext(context.Context) EnterpriseActionsRunnerGroupArrayOutput +} + +type EnterpriseActionsRunnerGroupArray []EnterpriseActionsRunnerGroupInput + +func (EnterpriseActionsRunnerGroupArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*EnterpriseActionsRunnerGroup)(nil)).Elem() +} + +func (i EnterpriseActionsRunnerGroupArray) ToEnterpriseActionsRunnerGroupArrayOutput() EnterpriseActionsRunnerGroupArrayOutput { + return i.ToEnterpriseActionsRunnerGroupArrayOutputWithContext(context.Background()) +} + +func (i EnterpriseActionsRunnerGroupArray) ToEnterpriseActionsRunnerGroupArrayOutputWithContext(ctx context.Context) EnterpriseActionsRunnerGroupArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseActionsRunnerGroupArrayOutput) +} + +// EnterpriseActionsRunnerGroupMapInput is an input type that accepts EnterpriseActionsRunnerGroupMap and EnterpriseActionsRunnerGroupMapOutput values. +// You can construct a concrete instance of `EnterpriseActionsRunnerGroupMapInput` via: +// +// EnterpriseActionsRunnerGroupMap{ "key": EnterpriseActionsRunnerGroupArgs{...} } +type EnterpriseActionsRunnerGroupMapInput interface { + pulumi.Input + + ToEnterpriseActionsRunnerGroupMapOutput() EnterpriseActionsRunnerGroupMapOutput + ToEnterpriseActionsRunnerGroupMapOutputWithContext(context.Context) EnterpriseActionsRunnerGroupMapOutput +} + +type EnterpriseActionsRunnerGroupMap map[string]EnterpriseActionsRunnerGroupInput + +func (EnterpriseActionsRunnerGroupMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*EnterpriseActionsRunnerGroup)(nil)).Elem() +} + +func (i EnterpriseActionsRunnerGroupMap) ToEnterpriseActionsRunnerGroupMapOutput() EnterpriseActionsRunnerGroupMapOutput { + return i.ToEnterpriseActionsRunnerGroupMapOutputWithContext(context.Background()) +} + +func (i EnterpriseActionsRunnerGroupMap) ToEnterpriseActionsRunnerGroupMapOutputWithContext(ctx context.Context) EnterpriseActionsRunnerGroupMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseActionsRunnerGroupMapOutput) +} + +type EnterpriseActionsRunnerGroupOutput struct{ *pulumi.OutputState } + +func (EnterpriseActionsRunnerGroupOutput) ElementType() reflect.Type { + return reflect.TypeOf((**EnterpriseActionsRunnerGroup)(nil)).Elem() +} + +func (o EnterpriseActionsRunnerGroupOutput) ToEnterpriseActionsRunnerGroupOutput() EnterpriseActionsRunnerGroupOutput { + return o +} + +func (o EnterpriseActionsRunnerGroupOutput) ToEnterpriseActionsRunnerGroupOutputWithContext(ctx context.Context) EnterpriseActionsRunnerGroupOutput { + return o +} + +// Whether public repositories can be added to the runner group. Defaults to false. +func (o EnterpriseActionsRunnerGroupOutput) AllowsPublicRepositories() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *EnterpriseActionsRunnerGroup) pulumi.BoolPtrOutput { return v.AllowsPublicRepositories }).(pulumi.BoolPtrOutput) +} + +// Whether this is the default runner group +func (o EnterpriseActionsRunnerGroupOutput) Default() pulumi.BoolOutput { + return o.ApplyT(func(v *EnterpriseActionsRunnerGroup) pulumi.BoolOutput { return v.Default }).(pulumi.BoolOutput) +} + +// The slug of the enterprise. +func (o EnterpriseActionsRunnerGroupOutput) EnterpriseSlug() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseActionsRunnerGroup) pulumi.StringOutput { return v.EnterpriseSlug }).(pulumi.StringOutput) +} + +// An etag representing the runner group object +func (o EnterpriseActionsRunnerGroupOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseActionsRunnerGroup) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// Name of the runner group +func (o EnterpriseActionsRunnerGroupOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseActionsRunnerGroup) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// If true, the runner group will be restricted to running only the workflows specified in the selectedWorkflows array. Defaults to false. +func (o EnterpriseActionsRunnerGroupOutput) RestrictedToWorkflows() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *EnterpriseActionsRunnerGroup) pulumi.BoolPtrOutput { return v.RestrictedToWorkflows }).(pulumi.BoolPtrOutput) +} + +// The GitHub API URL for the runner group's runners +func (o EnterpriseActionsRunnerGroupOutput) RunnersUrl() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseActionsRunnerGroup) pulumi.StringOutput { return v.RunnersUrl }).(pulumi.StringOutput) +} + +// IDs of the organizations which should be added to the runner group +func (o EnterpriseActionsRunnerGroupOutput) SelectedOrganizationIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v *EnterpriseActionsRunnerGroup) pulumi.IntArrayOutput { return v.SelectedOrganizationIds }).(pulumi.IntArrayOutput) +} + +// The GitHub API URL for the runner group's selected organizations +func (o EnterpriseActionsRunnerGroupOutput) SelectedOrganizationsUrl() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseActionsRunnerGroup) pulumi.StringOutput { return v.SelectedOrganizationsUrl }).(pulumi.StringOutput) +} + +// List of workflows the runner group should be allowed to run. This setting will be ignored unless restrictedToWorkflows is set to true. +func (o EnterpriseActionsRunnerGroupOutput) SelectedWorkflows() pulumi.StringArrayOutput { + return o.ApplyT(func(v *EnterpriseActionsRunnerGroup) pulumi.StringArrayOutput { return v.SelectedWorkflows }).(pulumi.StringArrayOutput) +} + +// Visibility of a runner group to enterprise organizations. Whether the runner group can include `all` or `selected` +func (o EnterpriseActionsRunnerGroupOutput) Visibility() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseActionsRunnerGroup) pulumi.StringOutput { return v.Visibility }).(pulumi.StringOutput) +} + +type EnterpriseActionsRunnerGroupArrayOutput struct{ *pulumi.OutputState } + +func (EnterpriseActionsRunnerGroupArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*EnterpriseActionsRunnerGroup)(nil)).Elem() +} + +func (o EnterpriseActionsRunnerGroupArrayOutput) ToEnterpriseActionsRunnerGroupArrayOutput() EnterpriseActionsRunnerGroupArrayOutput { + return o +} + +func (o EnterpriseActionsRunnerGroupArrayOutput) ToEnterpriseActionsRunnerGroupArrayOutputWithContext(ctx context.Context) EnterpriseActionsRunnerGroupArrayOutput { + return o +} + +func (o EnterpriseActionsRunnerGroupArrayOutput) Index(i pulumi.IntInput) EnterpriseActionsRunnerGroupOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EnterpriseActionsRunnerGroup { + return vs[0].([]*EnterpriseActionsRunnerGroup)[vs[1].(int)] + }).(EnterpriseActionsRunnerGroupOutput) +} + +type EnterpriseActionsRunnerGroupMapOutput struct{ *pulumi.OutputState } + +func (EnterpriseActionsRunnerGroupMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*EnterpriseActionsRunnerGroup)(nil)).Elem() +} + +func (o EnterpriseActionsRunnerGroupMapOutput) ToEnterpriseActionsRunnerGroupMapOutput() EnterpriseActionsRunnerGroupMapOutput { + return o +} + +func (o EnterpriseActionsRunnerGroupMapOutput) ToEnterpriseActionsRunnerGroupMapOutputWithContext(ctx context.Context) EnterpriseActionsRunnerGroupMapOutput { + return o +} + +func (o EnterpriseActionsRunnerGroupMapOutput) MapIndex(k pulumi.StringInput) EnterpriseActionsRunnerGroupOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EnterpriseActionsRunnerGroup { + return vs[0].(map[string]*EnterpriseActionsRunnerGroup)[vs[1].(string)] + }).(EnterpriseActionsRunnerGroupOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseActionsRunnerGroupInput)(nil)).Elem(), &EnterpriseActionsRunnerGroup{}) + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseActionsRunnerGroupArrayInput)(nil)).Elem(), EnterpriseActionsRunnerGroupArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseActionsRunnerGroupMapInput)(nil)).Elem(), EnterpriseActionsRunnerGroupMap{}) + pulumi.RegisterOutputType(EnterpriseActionsRunnerGroupOutput{}) + pulumi.RegisterOutputType(EnterpriseActionsRunnerGroupArrayOutput{}) + pulumi.RegisterOutputType(EnterpriseActionsRunnerGroupMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseActionsWorkflowPermissions.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseActionsWorkflowPermissions.go new file mode 100644 index 000000000..9500518be --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseActionsWorkflowPermissions.go @@ -0,0 +1,309 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to manage GitHub Actions workflow permissions for a GitHub Enterprise account. This controls the default permissions granted to the GITHUB_TOKEN when running workflows and whether GitHub Actions can approve pull request reviews. +// +// You must have enterprise admin access to use this resource. +// +// ## Example Usage +// +// ```go +// 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 { +// // Basic workflow permissions configuration +// _, err := github.NewEnterpriseActionsWorkflowPermissions(ctx, "example", &github.EnterpriseActionsWorkflowPermissionsArgs{ +// EnterpriseSlug: pulumi.String("my-enterprise"), +// DefaultWorkflowPermissions: pulumi.String("read"), +// CanApprovePullRequestReviews: pulumi.Bool(false), +// }) +// if err != nil { +// return err +// } +// // Allow write permissions and PR approvals +// _, err = github.NewEnterpriseActionsWorkflowPermissions(ctx, "permissive", &github.EnterpriseActionsWorkflowPermissionsArgs{ +// EnterpriseSlug: pulumi.String("my-enterprise"), +// DefaultWorkflowPermissions: pulumi.String("write"), +// CanApprovePullRequestReviews: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Notes +// +// > **Note:** This resource requires a GitHub Enterprise account and enterprise admin permissions. +// +// When this resource is destroyed, the workflow permissions will be reset to safe defaults: +// - `defaultWorkflowPermissions` = `read` +// - `canApprovePullRequestReviews` = `false` +// +// ## Import +// +// Enterprise Actions workflow permissions can be imported using the enterprise slug: +// +// ```sh +// $ pulumi import github:index/enterpriseActionsWorkflowPermissions:EnterpriseActionsWorkflowPermissions example my-enterprise +// ``` +type EnterpriseActionsWorkflowPermissions struct { + pulumi.CustomResourceState + + // Whether GitHub Actions can approve pull request reviews. Defaults to `false`. + CanApprovePullRequestReviews pulumi.BoolPtrOutput `pulumi:"canApprovePullRequestReviews"` + // The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be `read` or `write`. Defaults to `read`. + DefaultWorkflowPermissions pulumi.StringPtrOutput `pulumi:"defaultWorkflowPermissions"` + // The slug of the enterprise. + EnterpriseSlug pulumi.StringOutput `pulumi:"enterpriseSlug"` +} + +// NewEnterpriseActionsWorkflowPermissions registers a new resource with the given unique name, arguments, and options. +func NewEnterpriseActionsWorkflowPermissions(ctx *pulumi.Context, + name string, args *EnterpriseActionsWorkflowPermissionsArgs, opts ...pulumi.ResourceOption) (*EnterpriseActionsWorkflowPermissions, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.EnterpriseSlug == nil { + return nil, errors.New("invalid value for required argument 'EnterpriseSlug'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource EnterpriseActionsWorkflowPermissions + err := ctx.RegisterResource("github:index/enterpriseActionsWorkflowPermissions:EnterpriseActionsWorkflowPermissions", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetEnterpriseActionsWorkflowPermissions gets an existing EnterpriseActionsWorkflowPermissions 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 GetEnterpriseActionsWorkflowPermissions(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *EnterpriseActionsWorkflowPermissionsState, opts ...pulumi.ResourceOption) (*EnterpriseActionsWorkflowPermissions, error) { + var resource EnterpriseActionsWorkflowPermissions + err := ctx.ReadResource("github:index/enterpriseActionsWorkflowPermissions:EnterpriseActionsWorkflowPermissions", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering EnterpriseActionsWorkflowPermissions resources. +type enterpriseActionsWorkflowPermissionsState struct { + // Whether GitHub Actions can approve pull request reviews. Defaults to `false`. + CanApprovePullRequestReviews *bool `pulumi:"canApprovePullRequestReviews"` + // The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be `read` or `write`. Defaults to `read`. + DefaultWorkflowPermissions *string `pulumi:"defaultWorkflowPermissions"` + // The slug of the enterprise. + EnterpriseSlug *string `pulumi:"enterpriseSlug"` +} + +type EnterpriseActionsWorkflowPermissionsState struct { + // Whether GitHub Actions can approve pull request reviews. Defaults to `false`. + CanApprovePullRequestReviews pulumi.BoolPtrInput + // The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be `read` or `write`. Defaults to `read`. + DefaultWorkflowPermissions pulumi.StringPtrInput + // The slug of the enterprise. + EnterpriseSlug pulumi.StringPtrInput +} + +func (EnterpriseActionsWorkflowPermissionsState) ElementType() reflect.Type { + return reflect.TypeOf((*enterpriseActionsWorkflowPermissionsState)(nil)).Elem() +} + +type enterpriseActionsWorkflowPermissionsArgs struct { + // Whether GitHub Actions can approve pull request reviews. Defaults to `false`. + CanApprovePullRequestReviews *bool `pulumi:"canApprovePullRequestReviews"` + // The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be `read` or `write`. Defaults to `read`. + DefaultWorkflowPermissions *string `pulumi:"defaultWorkflowPermissions"` + // The slug of the enterprise. + EnterpriseSlug string `pulumi:"enterpriseSlug"` +} + +// The set of arguments for constructing a EnterpriseActionsWorkflowPermissions resource. +type EnterpriseActionsWorkflowPermissionsArgs struct { + // Whether GitHub Actions can approve pull request reviews. Defaults to `false`. + CanApprovePullRequestReviews pulumi.BoolPtrInput + // The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be `read` or `write`. Defaults to `read`. + DefaultWorkflowPermissions pulumi.StringPtrInput + // The slug of the enterprise. + EnterpriseSlug pulumi.StringInput +} + +func (EnterpriseActionsWorkflowPermissionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*enterpriseActionsWorkflowPermissionsArgs)(nil)).Elem() +} + +type EnterpriseActionsWorkflowPermissionsInput interface { + pulumi.Input + + ToEnterpriseActionsWorkflowPermissionsOutput() EnterpriseActionsWorkflowPermissionsOutput + ToEnterpriseActionsWorkflowPermissionsOutputWithContext(ctx context.Context) EnterpriseActionsWorkflowPermissionsOutput +} + +func (*EnterpriseActionsWorkflowPermissions) ElementType() reflect.Type { + return reflect.TypeOf((**EnterpriseActionsWorkflowPermissions)(nil)).Elem() +} + +func (i *EnterpriseActionsWorkflowPermissions) ToEnterpriseActionsWorkflowPermissionsOutput() EnterpriseActionsWorkflowPermissionsOutput { + return i.ToEnterpriseActionsWorkflowPermissionsOutputWithContext(context.Background()) +} + +func (i *EnterpriseActionsWorkflowPermissions) ToEnterpriseActionsWorkflowPermissionsOutputWithContext(ctx context.Context) EnterpriseActionsWorkflowPermissionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseActionsWorkflowPermissionsOutput) +} + +// EnterpriseActionsWorkflowPermissionsArrayInput is an input type that accepts EnterpriseActionsWorkflowPermissionsArray and EnterpriseActionsWorkflowPermissionsArrayOutput values. +// You can construct a concrete instance of `EnterpriseActionsWorkflowPermissionsArrayInput` via: +// +// EnterpriseActionsWorkflowPermissionsArray{ EnterpriseActionsWorkflowPermissionsArgs{...} } +type EnterpriseActionsWorkflowPermissionsArrayInput interface { + pulumi.Input + + ToEnterpriseActionsWorkflowPermissionsArrayOutput() EnterpriseActionsWorkflowPermissionsArrayOutput + ToEnterpriseActionsWorkflowPermissionsArrayOutputWithContext(context.Context) EnterpriseActionsWorkflowPermissionsArrayOutput +} + +type EnterpriseActionsWorkflowPermissionsArray []EnterpriseActionsWorkflowPermissionsInput + +func (EnterpriseActionsWorkflowPermissionsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*EnterpriseActionsWorkflowPermissions)(nil)).Elem() +} + +func (i EnterpriseActionsWorkflowPermissionsArray) ToEnterpriseActionsWorkflowPermissionsArrayOutput() EnterpriseActionsWorkflowPermissionsArrayOutput { + return i.ToEnterpriseActionsWorkflowPermissionsArrayOutputWithContext(context.Background()) +} + +func (i EnterpriseActionsWorkflowPermissionsArray) ToEnterpriseActionsWorkflowPermissionsArrayOutputWithContext(ctx context.Context) EnterpriseActionsWorkflowPermissionsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseActionsWorkflowPermissionsArrayOutput) +} + +// EnterpriseActionsWorkflowPermissionsMapInput is an input type that accepts EnterpriseActionsWorkflowPermissionsMap and EnterpriseActionsWorkflowPermissionsMapOutput values. +// You can construct a concrete instance of `EnterpriseActionsWorkflowPermissionsMapInput` via: +// +// EnterpriseActionsWorkflowPermissionsMap{ "key": EnterpriseActionsWorkflowPermissionsArgs{...} } +type EnterpriseActionsWorkflowPermissionsMapInput interface { + pulumi.Input + + ToEnterpriseActionsWorkflowPermissionsMapOutput() EnterpriseActionsWorkflowPermissionsMapOutput + ToEnterpriseActionsWorkflowPermissionsMapOutputWithContext(context.Context) EnterpriseActionsWorkflowPermissionsMapOutput +} + +type EnterpriseActionsWorkflowPermissionsMap map[string]EnterpriseActionsWorkflowPermissionsInput + +func (EnterpriseActionsWorkflowPermissionsMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*EnterpriseActionsWorkflowPermissions)(nil)).Elem() +} + +func (i EnterpriseActionsWorkflowPermissionsMap) ToEnterpriseActionsWorkflowPermissionsMapOutput() EnterpriseActionsWorkflowPermissionsMapOutput { + return i.ToEnterpriseActionsWorkflowPermissionsMapOutputWithContext(context.Background()) +} + +func (i EnterpriseActionsWorkflowPermissionsMap) ToEnterpriseActionsWorkflowPermissionsMapOutputWithContext(ctx context.Context) EnterpriseActionsWorkflowPermissionsMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseActionsWorkflowPermissionsMapOutput) +} + +type EnterpriseActionsWorkflowPermissionsOutput struct{ *pulumi.OutputState } + +func (EnterpriseActionsWorkflowPermissionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((**EnterpriseActionsWorkflowPermissions)(nil)).Elem() +} + +func (o EnterpriseActionsWorkflowPermissionsOutput) ToEnterpriseActionsWorkflowPermissionsOutput() EnterpriseActionsWorkflowPermissionsOutput { + return o +} + +func (o EnterpriseActionsWorkflowPermissionsOutput) ToEnterpriseActionsWorkflowPermissionsOutputWithContext(ctx context.Context) EnterpriseActionsWorkflowPermissionsOutput { + return o +} + +// Whether GitHub Actions can approve pull request reviews. Defaults to `false`. +func (o EnterpriseActionsWorkflowPermissionsOutput) CanApprovePullRequestReviews() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *EnterpriseActionsWorkflowPermissions) pulumi.BoolPtrOutput { + return v.CanApprovePullRequestReviews + }).(pulumi.BoolPtrOutput) +} + +// The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be `read` or `write`. Defaults to `read`. +func (o EnterpriseActionsWorkflowPermissionsOutput) DefaultWorkflowPermissions() pulumi.StringPtrOutput { + return o.ApplyT(func(v *EnterpriseActionsWorkflowPermissions) pulumi.StringPtrOutput { + return v.DefaultWorkflowPermissions + }).(pulumi.StringPtrOutput) +} + +// The slug of the enterprise. +func (o EnterpriseActionsWorkflowPermissionsOutput) EnterpriseSlug() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseActionsWorkflowPermissions) pulumi.StringOutput { return v.EnterpriseSlug }).(pulumi.StringOutput) +} + +type EnterpriseActionsWorkflowPermissionsArrayOutput struct{ *pulumi.OutputState } + +func (EnterpriseActionsWorkflowPermissionsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*EnterpriseActionsWorkflowPermissions)(nil)).Elem() +} + +func (o EnterpriseActionsWorkflowPermissionsArrayOutput) ToEnterpriseActionsWorkflowPermissionsArrayOutput() EnterpriseActionsWorkflowPermissionsArrayOutput { + return o +} + +func (o EnterpriseActionsWorkflowPermissionsArrayOutput) ToEnterpriseActionsWorkflowPermissionsArrayOutputWithContext(ctx context.Context) EnterpriseActionsWorkflowPermissionsArrayOutput { + return o +} + +func (o EnterpriseActionsWorkflowPermissionsArrayOutput) Index(i pulumi.IntInput) EnterpriseActionsWorkflowPermissionsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EnterpriseActionsWorkflowPermissions { + return vs[0].([]*EnterpriseActionsWorkflowPermissions)[vs[1].(int)] + }).(EnterpriseActionsWorkflowPermissionsOutput) +} + +type EnterpriseActionsWorkflowPermissionsMapOutput struct{ *pulumi.OutputState } + +func (EnterpriseActionsWorkflowPermissionsMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*EnterpriseActionsWorkflowPermissions)(nil)).Elem() +} + +func (o EnterpriseActionsWorkflowPermissionsMapOutput) ToEnterpriseActionsWorkflowPermissionsMapOutput() EnterpriseActionsWorkflowPermissionsMapOutput { + return o +} + +func (o EnterpriseActionsWorkflowPermissionsMapOutput) ToEnterpriseActionsWorkflowPermissionsMapOutputWithContext(ctx context.Context) EnterpriseActionsWorkflowPermissionsMapOutput { + return o +} + +func (o EnterpriseActionsWorkflowPermissionsMapOutput) MapIndex(k pulumi.StringInput) EnterpriseActionsWorkflowPermissionsOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EnterpriseActionsWorkflowPermissions { + return vs[0].(map[string]*EnterpriseActionsWorkflowPermissions)[vs[1].(string)] + }).(EnterpriseActionsWorkflowPermissionsOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseActionsWorkflowPermissionsInput)(nil)).Elem(), &EnterpriseActionsWorkflowPermissions{}) + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseActionsWorkflowPermissionsArrayInput)(nil)).Elem(), EnterpriseActionsWorkflowPermissionsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseActionsWorkflowPermissionsMapInput)(nil)).Elem(), EnterpriseActionsWorkflowPermissionsMap{}) + pulumi.RegisterOutputType(EnterpriseActionsWorkflowPermissionsOutput{}) + pulumi.RegisterOutputType(EnterpriseActionsWorkflowPermissionsArrayOutput{}) + pulumi.RegisterOutputType(EnterpriseActionsWorkflowPermissionsMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseIpAllowListEntry.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseIpAllowListEntry.go new file mode 100644 index 000000000..1904a58cb --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseIpAllowListEntry.go @@ -0,0 +1,326 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage IP allow list entries for a GitHub Enterprise account. IP allow list entries define IP addresses or ranges that are permitted to access private resources in the enterprise. +// +// ## Example Usage +// +// ```go +// 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.NewEnterpriseIpAllowListEntry(ctx, "test", &github.EnterpriseIpAllowListEntryArgs{ +// EnterpriseSlug: pulumi.String("my-enterprise"), +// Ip: pulumi.String("192.168.1.0/20"), +// Name: pulumi.String("My IP Range Name"), +// IsActive: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using the ID of the IP allow list entry: +// +// ```sh +// $ pulumi import github:index/enterpriseIpAllowListEntry:EnterpriseIpAllowListEntry test IALE_kwHOC1234567890a +// ``` +type EnterpriseIpAllowListEntry struct { + pulumi.CustomResourceState + + // Timestamp of when the entry was created. + CreatedAt pulumi.StringOutput `pulumi:"createdAt"` + // The slug of the enterprise. + EnterpriseSlug pulumi.StringOutput `pulumi:"enterpriseSlug"` + // An IP address or range of IP addresses in CIDR notation. + Ip pulumi.StringOutput `pulumi:"ip"` + // Whether the entry is currently active. Default: true. + IsActive pulumi.BoolPtrOutput `pulumi:"isActive"` + // A descriptive name for the IP allow list entry. + Name pulumi.StringOutput `pulumi:"name"` + // Timestamp of when the entry was last updated. + UpdatedAt pulumi.StringOutput `pulumi:"updatedAt"` +} + +// NewEnterpriseIpAllowListEntry registers a new resource with the given unique name, arguments, and options. +func NewEnterpriseIpAllowListEntry(ctx *pulumi.Context, + name string, args *EnterpriseIpAllowListEntryArgs, opts ...pulumi.ResourceOption) (*EnterpriseIpAllowListEntry, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.EnterpriseSlug == nil { + return nil, errors.New("invalid value for required argument 'EnterpriseSlug'") + } + if args.Ip == nil { + return nil, errors.New("invalid value for required argument 'Ip'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource EnterpriseIpAllowListEntry + err := ctx.RegisterResource("github:index/enterpriseIpAllowListEntry:EnterpriseIpAllowListEntry", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetEnterpriseIpAllowListEntry gets an existing EnterpriseIpAllowListEntry 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 GetEnterpriseIpAllowListEntry(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *EnterpriseIpAllowListEntryState, opts ...pulumi.ResourceOption) (*EnterpriseIpAllowListEntry, error) { + var resource EnterpriseIpAllowListEntry + err := ctx.ReadResource("github:index/enterpriseIpAllowListEntry:EnterpriseIpAllowListEntry", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering EnterpriseIpAllowListEntry resources. +type enterpriseIpAllowListEntryState struct { + // Timestamp of when the entry was created. + CreatedAt *string `pulumi:"createdAt"` + // The slug of the enterprise. + EnterpriseSlug *string `pulumi:"enterpriseSlug"` + // An IP address or range of IP addresses in CIDR notation. + Ip *string `pulumi:"ip"` + // Whether the entry is currently active. Default: true. + IsActive *bool `pulumi:"isActive"` + // A descriptive name for the IP allow list entry. + Name *string `pulumi:"name"` + // Timestamp of when the entry was last updated. + UpdatedAt *string `pulumi:"updatedAt"` +} + +type EnterpriseIpAllowListEntryState struct { + // Timestamp of when the entry was created. + CreatedAt pulumi.StringPtrInput + // The slug of the enterprise. + EnterpriseSlug pulumi.StringPtrInput + // An IP address or range of IP addresses in CIDR notation. + Ip pulumi.StringPtrInput + // Whether the entry is currently active. Default: true. + IsActive pulumi.BoolPtrInput + // A descriptive name for the IP allow list entry. + Name pulumi.StringPtrInput + // Timestamp of when the entry was last updated. + UpdatedAt pulumi.StringPtrInput +} + +func (EnterpriseIpAllowListEntryState) ElementType() reflect.Type { + return reflect.TypeOf((*enterpriseIpAllowListEntryState)(nil)).Elem() +} + +type enterpriseIpAllowListEntryArgs struct { + // The slug of the enterprise. + EnterpriseSlug string `pulumi:"enterpriseSlug"` + // An IP address or range of IP addresses in CIDR notation. + Ip string `pulumi:"ip"` + // Whether the entry is currently active. Default: true. + IsActive *bool `pulumi:"isActive"` + // A descriptive name for the IP allow list entry. + Name *string `pulumi:"name"` +} + +// The set of arguments for constructing a EnterpriseIpAllowListEntry resource. +type EnterpriseIpAllowListEntryArgs struct { + // The slug of the enterprise. + EnterpriseSlug pulumi.StringInput + // An IP address or range of IP addresses in CIDR notation. + Ip pulumi.StringInput + // Whether the entry is currently active. Default: true. + IsActive pulumi.BoolPtrInput + // A descriptive name for the IP allow list entry. + Name pulumi.StringPtrInput +} + +func (EnterpriseIpAllowListEntryArgs) ElementType() reflect.Type { + return reflect.TypeOf((*enterpriseIpAllowListEntryArgs)(nil)).Elem() +} + +type EnterpriseIpAllowListEntryInput interface { + pulumi.Input + + ToEnterpriseIpAllowListEntryOutput() EnterpriseIpAllowListEntryOutput + ToEnterpriseIpAllowListEntryOutputWithContext(ctx context.Context) EnterpriseIpAllowListEntryOutput +} + +func (*EnterpriseIpAllowListEntry) ElementType() reflect.Type { + return reflect.TypeOf((**EnterpriseIpAllowListEntry)(nil)).Elem() +} + +func (i *EnterpriseIpAllowListEntry) ToEnterpriseIpAllowListEntryOutput() EnterpriseIpAllowListEntryOutput { + return i.ToEnterpriseIpAllowListEntryOutputWithContext(context.Background()) +} + +func (i *EnterpriseIpAllowListEntry) ToEnterpriseIpAllowListEntryOutputWithContext(ctx context.Context) EnterpriseIpAllowListEntryOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseIpAllowListEntryOutput) +} + +// EnterpriseIpAllowListEntryArrayInput is an input type that accepts EnterpriseIpAllowListEntryArray and EnterpriseIpAllowListEntryArrayOutput values. +// You can construct a concrete instance of `EnterpriseIpAllowListEntryArrayInput` via: +// +// EnterpriseIpAllowListEntryArray{ EnterpriseIpAllowListEntryArgs{...} } +type EnterpriseIpAllowListEntryArrayInput interface { + pulumi.Input + + ToEnterpriseIpAllowListEntryArrayOutput() EnterpriseIpAllowListEntryArrayOutput + ToEnterpriseIpAllowListEntryArrayOutputWithContext(context.Context) EnterpriseIpAllowListEntryArrayOutput +} + +type EnterpriseIpAllowListEntryArray []EnterpriseIpAllowListEntryInput + +func (EnterpriseIpAllowListEntryArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*EnterpriseIpAllowListEntry)(nil)).Elem() +} + +func (i EnterpriseIpAllowListEntryArray) ToEnterpriseIpAllowListEntryArrayOutput() EnterpriseIpAllowListEntryArrayOutput { + return i.ToEnterpriseIpAllowListEntryArrayOutputWithContext(context.Background()) +} + +func (i EnterpriseIpAllowListEntryArray) ToEnterpriseIpAllowListEntryArrayOutputWithContext(ctx context.Context) EnterpriseIpAllowListEntryArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseIpAllowListEntryArrayOutput) +} + +// EnterpriseIpAllowListEntryMapInput is an input type that accepts EnterpriseIpAllowListEntryMap and EnterpriseIpAllowListEntryMapOutput values. +// You can construct a concrete instance of `EnterpriseIpAllowListEntryMapInput` via: +// +// EnterpriseIpAllowListEntryMap{ "key": EnterpriseIpAllowListEntryArgs{...} } +type EnterpriseIpAllowListEntryMapInput interface { + pulumi.Input + + ToEnterpriseIpAllowListEntryMapOutput() EnterpriseIpAllowListEntryMapOutput + ToEnterpriseIpAllowListEntryMapOutputWithContext(context.Context) EnterpriseIpAllowListEntryMapOutput +} + +type EnterpriseIpAllowListEntryMap map[string]EnterpriseIpAllowListEntryInput + +func (EnterpriseIpAllowListEntryMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*EnterpriseIpAllowListEntry)(nil)).Elem() +} + +func (i EnterpriseIpAllowListEntryMap) ToEnterpriseIpAllowListEntryMapOutput() EnterpriseIpAllowListEntryMapOutput { + return i.ToEnterpriseIpAllowListEntryMapOutputWithContext(context.Background()) +} + +func (i EnterpriseIpAllowListEntryMap) ToEnterpriseIpAllowListEntryMapOutputWithContext(ctx context.Context) EnterpriseIpAllowListEntryMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseIpAllowListEntryMapOutput) +} + +type EnterpriseIpAllowListEntryOutput struct{ *pulumi.OutputState } + +func (EnterpriseIpAllowListEntryOutput) ElementType() reflect.Type { + return reflect.TypeOf((**EnterpriseIpAllowListEntry)(nil)).Elem() +} + +func (o EnterpriseIpAllowListEntryOutput) ToEnterpriseIpAllowListEntryOutput() EnterpriseIpAllowListEntryOutput { + return o +} + +func (o EnterpriseIpAllowListEntryOutput) ToEnterpriseIpAllowListEntryOutputWithContext(ctx context.Context) EnterpriseIpAllowListEntryOutput { + return o +} + +// Timestamp of when the entry was created. +func (o EnterpriseIpAllowListEntryOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseIpAllowListEntry) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) +} + +// The slug of the enterprise. +func (o EnterpriseIpAllowListEntryOutput) EnterpriseSlug() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseIpAllowListEntry) pulumi.StringOutput { return v.EnterpriseSlug }).(pulumi.StringOutput) +} + +// An IP address or range of IP addresses in CIDR notation. +func (o EnterpriseIpAllowListEntryOutput) Ip() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseIpAllowListEntry) pulumi.StringOutput { return v.Ip }).(pulumi.StringOutput) +} + +// Whether the entry is currently active. Default: true. +func (o EnterpriseIpAllowListEntryOutput) IsActive() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *EnterpriseIpAllowListEntry) pulumi.BoolPtrOutput { return v.IsActive }).(pulumi.BoolPtrOutput) +} + +// A descriptive name for the IP allow list entry. +func (o EnterpriseIpAllowListEntryOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseIpAllowListEntry) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// Timestamp of when the entry was last updated. +func (o EnterpriseIpAllowListEntryOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseIpAllowListEntry) pulumi.StringOutput { return v.UpdatedAt }).(pulumi.StringOutput) +} + +type EnterpriseIpAllowListEntryArrayOutput struct{ *pulumi.OutputState } + +func (EnterpriseIpAllowListEntryArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*EnterpriseIpAllowListEntry)(nil)).Elem() +} + +func (o EnterpriseIpAllowListEntryArrayOutput) ToEnterpriseIpAllowListEntryArrayOutput() EnterpriseIpAllowListEntryArrayOutput { + return o +} + +func (o EnterpriseIpAllowListEntryArrayOutput) ToEnterpriseIpAllowListEntryArrayOutputWithContext(ctx context.Context) EnterpriseIpAllowListEntryArrayOutput { + return o +} + +func (o EnterpriseIpAllowListEntryArrayOutput) Index(i pulumi.IntInput) EnterpriseIpAllowListEntryOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EnterpriseIpAllowListEntry { + return vs[0].([]*EnterpriseIpAllowListEntry)[vs[1].(int)] + }).(EnterpriseIpAllowListEntryOutput) +} + +type EnterpriseIpAllowListEntryMapOutput struct{ *pulumi.OutputState } + +func (EnterpriseIpAllowListEntryMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*EnterpriseIpAllowListEntry)(nil)).Elem() +} + +func (o EnterpriseIpAllowListEntryMapOutput) ToEnterpriseIpAllowListEntryMapOutput() EnterpriseIpAllowListEntryMapOutput { + return o +} + +func (o EnterpriseIpAllowListEntryMapOutput) ToEnterpriseIpAllowListEntryMapOutputWithContext(ctx context.Context) EnterpriseIpAllowListEntryMapOutput { + return o +} + +func (o EnterpriseIpAllowListEntryMapOutput) MapIndex(k pulumi.StringInput) EnterpriseIpAllowListEntryOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EnterpriseIpAllowListEntry { + return vs[0].(map[string]*EnterpriseIpAllowListEntry)[vs[1].(string)] + }).(EnterpriseIpAllowListEntryOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseIpAllowListEntryInput)(nil)).Elem(), &EnterpriseIpAllowListEntry{}) + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseIpAllowListEntryArrayInput)(nil)).Elem(), EnterpriseIpAllowListEntryArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseIpAllowListEntryMapInput)(nil)).Elem(), EnterpriseIpAllowListEntryMap{}) + pulumi.RegisterOutputType(EnterpriseIpAllowListEntryOutput{}) + pulumi.RegisterOutputType(EnterpriseIpAllowListEntryArrayOutput{}) + pulumi.RegisterOutputType(EnterpriseIpAllowListEntryMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseOrganization.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseOrganization.go new file mode 100644 index 000000000..1efe63e40 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseOrganization.go @@ -0,0 +1,352 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage a GitHub enterprise organization. +// +// ## Example Usage +// +// ```go +// 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.NewEnterpriseOrganization(ctx, "org", &github.EnterpriseOrganizationArgs{ +// EnterpriseId: pulumi.Any(enterprise.Id), +// Name: pulumi.String("some-awesome-org"), +// DisplayName: pulumi.String("Some Awesome Org"), +// Description: pulumi.String("Organization created with terraform"), +// BillingEmail: pulumi.String("jon@winteriscoming.com"), +// AdminLogins: pulumi.StringArray{ +// pulumi.String("jon-snow"), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Enterprise Organization can be imported using the `slug` of the enterprise, combined with the `orgname` of the organization, separated by a `/` character. +// +// ```sh +// $ pulumi import github:index/enterpriseOrganization:EnterpriseOrganization org enterp/some-awesome-org +// ``` +type EnterpriseOrganization struct { + pulumi.CustomResourceState + + // List of organization owner usernames. + AdminLogins pulumi.StringArrayOutput `pulumi:"adminLogins"` + // The billing email address. + BillingEmail pulumi.StringOutput `pulumi:"billingEmail"` + // The ID of the organization. + DatabaseId pulumi.IntOutput `pulumi:"databaseId"` + // The description of the organization. + Description pulumi.StringPtrOutput `pulumi:"description"` + // The display name of the organization. + DisplayName pulumi.StringPtrOutput `pulumi:"displayName"` + // The ID of the enterprise. + EnterpriseId pulumi.StringOutput `pulumi:"enterpriseId"` + // The name of the organization. + Name pulumi.StringOutput `pulumi:"name"` +} + +// NewEnterpriseOrganization registers a new resource with the given unique name, arguments, and options. +func NewEnterpriseOrganization(ctx *pulumi.Context, + name string, args *EnterpriseOrganizationArgs, opts ...pulumi.ResourceOption) (*EnterpriseOrganization, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.AdminLogins == nil { + return nil, errors.New("invalid value for required argument 'AdminLogins'") + } + if args.BillingEmail == nil { + return nil, errors.New("invalid value for required argument 'BillingEmail'") + } + if args.EnterpriseId == nil { + return nil, errors.New("invalid value for required argument 'EnterpriseId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource EnterpriseOrganization + err := ctx.RegisterResource("github:index/enterpriseOrganization:EnterpriseOrganization", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetEnterpriseOrganization gets an existing EnterpriseOrganization 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 GetEnterpriseOrganization(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *EnterpriseOrganizationState, opts ...pulumi.ResourceOption) (*EnterpriseOrganization, error) { + var resource EnterpriseOrganization + err := ctx.ReadResource("github:index/enterpriseOrganization:EnterpriseOrganization", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering EnterpriseOrganization resources. +type enterpriseOrganizationState struct { + // List of organization owner usernames. + AdminLogins []string `pulumi:"adminLogins"` + // The billing email address. + BillingEmail *string `pulumi:"billingEmail"` + // The ID of the organization. + DatabaseId *int `pulumi:"databaseId"` + // The description of the organization. + Description *string `pulumi:"description"` + // The display name of the organization. + DisplayName *string `pulumi:"displayName"` + // The ID of the enterprise. + EnterpriseId *string `pulumi:"enterpriseId"` + // The name of the organization. + Name *string `pulumi:"name"` +} + +type EnterpriseOrganizationState struct { + // List of organization owner usernames. + AdminLogins pulumi.StringArrayInput + // The billing email address. + BillingEmail pulumi.StringPtrInput + // The ID of the organization. + DatabaseId pulumi.IntPtrInput + // The description of the organization. + Description pulumi.StringPtrInput + // The display name of the organization. + DisplayName pulumi.StringPtrInput + // The ID of the enterprise. + EnterpriseId pulumi.StringPtrInput + // The name of the organization. + Name pulumi.StringPtrInput +} + +func (EnterpriseOrganizationState) ElementType() reflect.Type { + return reflect.TypeOf((*enterpriseOrganizationState)(nil)).Elem() +} + +type enterpriseOrganizationArgs struct { + // List of organization owner usernames. + AdminLogins []string `pulumi:"adminLogins"` + // The billing email address. + BillingEmail string `pulumi:"billingEmail"` + // The description of the organization. + Description *string `pulumi:"description"` + // The display name of the organization. + DisplayName *string `pulumi:"displayName"` + // The ID of the enterprise. + EnterpriseId string `pulumi:"enterpriseId"` + // The name of the organization. + Name *string `pulumi:"name"` +} + +// The set of arguments for constructing a EnterpriseOrganization resource. +type EnterpriseOrganizationArgs struct { + // List of organization owner usernames. + AdminLogins pulumi.StringArrayInput + // The billing email address. + BillingEmail pulumi.StringInput + // The description of the organization. + Description pulumi.StringPtrInput + // The display name of the organization. + DisplayName pulumi.StringPtrInput + // The ID of the enterprise. + EnterpriseId pulumi.StringInput + // The name of the organization. + Name pulumi.StringPtrInput +} + +func (EnterpriseOrganizationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*enterpriseOrganizationArgs)(nil)).Elem() +} + +type EnterpriseOrganizationInput interface { + pulumi.Input + + ToEnterpriseOrganizationOutput() EnterpriseOrganizationOutput + ToEnterpriseOrganizationOutputWithContext(ctx context.Context) EnterpriseOrganizationOutput +} + +func (*EnterpriseOrganization) ElementType() reflect.Type { + return reflect.TypeOf((**EnterpriseOrganization)(nil)).Elem() +} + +func (i *EnterpriseOrganization) ToEnterpriseOrganizationOutput() EnterpriseOrganizationOutput { + return i.ToEnterpriseOrganizationOutputWithContext(context.Background()) +} + +func (i *EnterpriseOrganization) ToEnterpriseOrganizationOutputWithContext(ctx context.Context) EnterpriseOrganizationOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseOrganizationOutput) +} + +// EnterpriseOrganizationArrayInput is an input type that accepts EnterpriseOrganizationArray and EnterpriseOrganizationArrayOutput values. +// You can construct a concrete instance of `EnterpriseOrganizationArrayInput` via: +// +// EnterpriseOrganizationArray{ EnterpriseOrganizationArgs{...} } +type EnterpriseOrganizationArrayInput interface { + pulumi.Input + + ToEnterpriseOrganizationArrayOutput() EnterpriseOrganizationArrayOutput + ToEnterpriseOrganizationArrayOutputWithContext(context.Context) EnterpriseOrganizationArrayOutput +} + +type EnterpriseOrganizationArray []EnterpriseOrganizationInput + +func (EnterpriseOrganizationArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*EnterpriseOrganization)(nil)).Elem() +} + +func (i EnterpriseOrganizationArray) ToEnterpriseOrganizationArrayOutput() EnterpriseOrganizationArrayOutput { + return i.ToEnterpriseOrganizationArrayOutputWithContext(context.Background()) +} + +func (i EnterpriseOrganizationArray) ToEnterpriseOrganizationArrayOutputWithContext(ctx context.Context) EnterpriseOrganizationArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseOrganizationArrayOutput) +} + +// EnterpriseOrganizationMapInput is an input type that accepts EnterpriseOrganizationMap and EnterpriseOrganizationMapOutput values. +// You can construct a concrete instance of `EnterpriseOrganizationMapInput` via: +// +// EnterpriseOrganizationMap{ "key": EnterpriseOrganizationArgs{...} } +type EnterpriseOrganizationMapInput interface { + pulumi.Input + + ToEnterpriseOrganizationMapOutput() EnterpriseOrganizationMapOutput + ToEnterpriseOrganizationMapOutputWithContext(context.Context) EnterpriseOrganizationMapOutput +} + +type EnterpriseOrganizationMap map[string]EnterpriseOrganizationInput + +func (EnterpriseOrganizationMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*EnterpriseOrganization)(nil)).Elem() +} + +func (i EnterpriseOrganizationMap) ToEnterpriseOrganizationMapOutput() EnterpriseOrganizationMapOutput { + return i.ToEnterpriseOrganizationMapOutputWithContext(context.Background()) +} + +func (i EnterpriseOrganizationMap) ToEnterpriseOrganizationMapOutputWithContext(ctx context.Context) EnterpriseOrganizationMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseOrganizationMapOutput) +} + +type EnterpriseOrganizationOutput struct{ *pulumi.OutputState } + +func (EnterpriseOrganizationOutput) ElementType() reflect.Type { + return reflect.TypeOf((**EnterpriseOrganization)(nil)).Elem() +} + +func (o EnterpriseOrganizationOutput) ToEnterpriseOrganizationOutput() EnterpriseOrganizationOutput { + return o +} + +func (o EnterpriseOrganizationOutput) ToEnterpriseOrganizationOutputWithContext(ctx context.Context) EnterpriseOrganizationOutput { + return o +} + +// List of organization owner usernames. +func (o EnterpriseOrganizationOutput) AdminLogins() pulumi.StringArrayOutput { + return o.ApplyT(func(v *EnterpriseOrganization) pulumi.StringArrayOutput { return v.AdminLogins }).(pulumi.StringArrayOutput) +} + +// The billing email address. +func (o EnterpriseOrganizationOutput) BillingEmail() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseOrganization) pulumi.StringOutput { return v.BillingEmail }).(pulumi.StringOutput) +} + +// The ID of the organization. +func (o EnterpriseOrganizationOutput) DatabaseId() pulumi.IntOutput { + return o.ApplyT(func(v *EnterpriseOrganization) pulumi.IntOutput { return v.DatabaseId }).(pulumi.IntOutput) +} + +// The description of the organization. +func (o EnterpriseOrganizationOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *EnterpriseOrganization) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) +} + +// The display name of the organization. +func (o EnterpriseOrganizationOutput) DisplayName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *EnterpriseOrganization) pulumi.StringPtrOutput { return v.DisplayName }).(pulumi.StringPtrOutput) +} + +// The ID of the enterprise. +func (o EnterpriseOrganizationOutput) EnterpriseId() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseOrganization) pulumi.StringOutput { return v.EnterpriseId }).(pulumi.StringOutput) +} + +// The name of the organization. +func (o EnterpriseOrganizationOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseOrganization) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +type EnterpriseOrganizationArrayOutput struct{ *pulumi.OutputState } + +func (EnterpriseOrganizationArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*EnterpriseOrganization)(nil)).Elem() +} + +func (o EnterpriseOrganizationArrayOutput) ToEnterpriseOrganizationArrayOutput() EnterpriseOrganizationArrayOutput { + return o +} + +func (o EnterpriseOrganizationArrayOutput) ToEnterpriseOrganizationArrayOutputWithContext(ctx context.Context) EnterpriseOrganizationArrayOutput { + return o +} + +func (o EnterpriseOrganizationArrayOutput) Index(i pulumi.IntInput) EnterpriseOrganizationOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EnterpriseOrganization { + return vs[0].([]*EnterpriseOrganization)[vs[1].(int)] + }).(EnterpriseOrganizationOutput) +} + +type EnterpriseOrganizationMapOutput struct{ *pulumi.OutputState } + +func (EnterpriseOrganizationMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*EnterpriseOrganization)(nil)).Elem() +} + +func (o EnterpriseOrganizationMapOutput) ToEnterpriseOrganizationMapOutput() EnterpriseOrganizationMapOutput { + return o +} + +func (o EnterpriseOrganizationMapOutput) ToEnterpriseOrganizationMapOutputWithContext(ctx context.Context) EnterpriseOrganizationMapOutput { + return o +} + +func (o EnterpriseOrganizationMapOutput) MapIndex(k pulumi.StringInput) EnterpriseOrganizationOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EnterpriseOrganization { + return vs[0].(map[string]*EnterpriseOrganization)[vs[1].(string)] + }).(EnterpriseOrganizationOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseOrganizationInput)(nil)).Elem(), &EnterpriseOrganization{}) + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseOrganizationArrayInput)(nil)).Elem(), EnterpriseOrganizationArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseOrganizationMapInput)(nil)).Elem(), EnterpriseOrganizationMap{}) + pulumi.RegisterOutputType(EnterpriseOrganizationOutput{}) + pulumi.RegisterOutputType(EnterpriseOrganizationArrayOutput{}) + pulumi.RegisterOutputType(EnterpriseOrganizationMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseSecurityAnalysisSettings.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseSecurityAnalysisSettings.go new file mode 100644 index 000000000..5bf60f11d --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/enterpriseSecurityAnalysisSettings.go @@ -0,0 +1,373 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to manage code security and analysis settings for a GitHub Enterprise account. This controls Advanced Security, Secret Scanning, and related security features that are automatically enabled for new repositories in the enterprise. +// +// You must have enterprise admin access to use this resource. +// +// ## Example Usage +// +// ```go +// 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 { +// // Basic security settings - enable secret scanning only +// _, err := github.NewEnterpriseSecurityAnalysisSettings(ctx, "basic", &github.EnterpriseSecurityAnalysisSettingsArgs{ +// EnterpriseSlug: pulumi.String("my-enterprise"), +// SecretScanningEnabledForNewRepositories: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// // Full security configuration with all features enabled +// _, err = github.NewEnterpriseSecurityAnalysisSettings(ctx, "comprehensive", &github.EnterpriseSecurityAnalysisSettingsArgs{ +// EnterpriseSlug: pulumi.String("my-enterprise"), +// AdvancedSecurityEnabledForNewRepositories: pulumi.Bool(true), +// SecretScanningEnabledForNewRepositories: pulumi.Bool(true), +// SecretScanningPushProtectionEnabledForNewRepositories: pulumi.Bool(true), +// SecretScanningValidityChecksEnabled: pulumi.Bool(true), +// SecretScanningPushProtectionCustomLink: pulumi.String("https://octokit.com/security-guidelines"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Notes +// +// > **Note:** This resource requires a GitHub Enterprise account and enterprise admin permissions. +// +// > **Note:** Advanced Security features require a GitHub Advanced Security license. +// +// When this resource is destroyed, all security analysis settings will be reset to disabled defaults for security reasons. +// +// ## Dependencies +// +// This resource manages the following security features: +// +// - **Advanced Security**: Code scanning, secret scanning, and dependency review +// - **Secret Scanning**: Automatic detection of secrets in code +// - **Push Protection**: Prevents secrets from being committed to repositories +// - **Validity Checks**: Verifies that detected secrets are actually valid +// +// These settings only apply to **new repositories** created after the settings are enabled. Existing repositories are not affected and must be configured individually. +// +// ## Import +// +// Enterprise security analysis settings can be imported using the enterprise slug: +// +// ```sh +// $ pulumi import github:index/enterpriseSecurityAnalysisSettings:EnterpriseSecurityAnalysisSettings example my-enterprise +// ``` +type EnterpriseSecurityAnalysisSettings struct { + pulumi.CustomResourceState + + // Whether GitHub Advanced Security is automatically enabled for new repositories. Defaults to `false`. Requires Advanced Security license. + AdvancedSecurityEnabledForNewRepositories pulumi.BoolPtrOutput `pulumi:"advancedSecurityEnabledForNewRepositories"` + // The slug of the enterprise. + EnterpriseSlug pulumi.StringOutput `pulumi:"enterpriseSlug"` + // Whether secret scanning is automatically enabled for new repositories. Defaults to `false`. + SecretScanningEnabledForNewRepositories pulumi.BoolPtrOutput `pulumi:"secretScanningEnabledForNewRepositories"` + // Custom URL for secret scanning push protection bypass instructions. + SecretScanningPushProtectionCustomLink pulumi.StringPtrOutput `pulumi:"secretScanningPushProtectionCustomLink"` + // Whether secret scanning push protection is automatically enabled for new repositories. Defaults to `false`. + SecretScanningPushProtectionEnabledForNewRepositories pulumi.BoolPtrOutput `pulumi:"secretScanningPushProtectionEnabledForNewRepositories"` + // Whether secret scanning validity checks are enabled. Defaults to `false`. + SecretScanningValidityChecksEnabled pulumi.BoolPtrOutput `pulumi:"secretScanningValidityChecksEnabled"` +} + +// NewEnterpriseSecurityAnalysisSettings registers a new resource with the given unique name, arguments, and options. +func NewEnterpriseSecurityAnalysisSettings(ctx *pulumi.Context, + name string, args *EnterpriseSecurityAnalysisSettingsArgs, opts ...pulumi.ResourceOption) (*EnterpriseSecurityAnalysisSettings, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.EnterpriseSlug == nil { + return nil, errors.New("invalid value for required argument 'EnterpriseSlug'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource EnterpriseSecurityAnalysisSettings + err := ctx.RegisterResource("github:index/enterpriseSecurityAnalysisSettings:EnterpriseSecurityAnalysisSettings", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetEnterpriseSecurityAnalysisSettings gets an existing EnterpriseSecurityAnalysisSettings 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 GetEnterpriseSecurityAnalysisSettings(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *EnterpriseSecurityAnalysisSettingsState, opts ...pulumi.ResourceOption) (*EnterpriseSecurityAnalysisSettings, error) { + var resource EnterpriseSecurityAnalysisSettings + err := ctx.ReadResource("github:index/enterpriseSecurityAnalysisSettings:EnterpriseSecurityAnalysisSettings", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering EnterpriseSecurityAnalysisSettings resources. +type enterpriseSecurityAnalysisSettingsState struct { + // Whether GitHub Advanced Security is automatically enabled for new repositories. Defaults to `false`. Requires Advanced Security license. + AdvancedSecurityEnabledForNewRepositories *bool `pulumi:"advancedSecurityEnabledForNewRepositories"` + // The slug of the enterprise. + EnterpriseSlug *string `pulumi:"enterpriseSlug"` + // Whether secret scanning is automatically enabled for new repositories. Defaults to `false`. + SecretScanningEnabledForNewRepositories *bool `pulumi:"secretScanningEnabledForNewRepositories"` + // Custom URL for secret scanning push protection bypass instructions. + SecretScanningPushProtectionCustomLink *string `pulumi:"secretScanningPushProtectionCustomLink"` + // Whether secret scanning push protection is automatically enabled for new repositories. Defaults to `false`. + SecretScanningPushProtectionEnabledForNewRepositories *bool `pulumi:"secretScanningPushProtectionEnabledForNewRepositories"` + // Whether secret scanning validity checks are enabled. Defaults to `false`. + SecretScanningValidityChecksEnabled *bool `pulumi:"secretScanningValidityChecksEnabled"` +} + +type EnterpriseSecurityAnalysisSettingsState struct { + // Whether GitHub Advanced Security is automatically enabled for new repositories. Defaults to `false`. Requires Advanced Security license. + AdvancedSecurityEnabledForNewRepositories pulumi.BoolPtrInput + // The slug of the enterprise. + EnterpriseSlug pulumi.StringPtrInput + // Whether secret scanning is automatically enabled for new repositories. Defaults to `false`. + SecretScanningEnabledForNewRepositories pulumi.BoolPtrInput + // Custom URL for secret scanning push protection bypass instructions. + SecretScanningPushProtectionCustomLink pulumi.StringPtrInput + // Whether secret scanning push protection is automatically enabled for new repositories. Defaults to `false`. + SecretScanningPushProtectionEnabledForNewRepositories pulumi.BoolPtrInput + // Whether secret scanning validity checks are enabled. Defaults to `false`. + SecretScanningValidityChecksEnabled pulumi.BoolPtrInput +} + +func (EnterpriseSecurityAnalysisSettingsState) ElementType() reflect.Type { + return reflect.TypeOf((*enterpriseSecurityAnalysisSettingsState)(nil)).Elem() +} + +type enterpriseSecurityAnalysisSettingsArgs struct { + // Whether GitHub Advanced Security is automatically enabled for new repositories. Defaults to `false`. Requires Advanced Security license. + AdvancedSecurityEnabledForNewRepositories *bool `pulumi:"advancedSecurityEnabledForNewRepositories"` + // The slug of the enterprise. + EnterpriseSlug string `pulumi:"enterpriseSlug"` + // Whether secret scanning is automatically enabled for new repositories. Defaults to `false`. + SecretScanningEnabledForNewRepositories *bool `pulumi:"secretScanningEnabledForNewRepositories"` + // Custom URL for secret scanning push protection bypass instructions. + SecretScanningPushProtectionCustomLink *string `pulumi:"secretScanningPushProtectionCustomLink"` + // Whether secret scanning push protection is automatically enabled for new repositories. Defaults to `false`. + SecretScanningPushProtectionEnabledForNewRepositories *bool `pulumi:"secretScanningPushProtectionEnabledForNewRepositories"` + // Whether secret scanning validity checks are enabled. Defaults to `false`. + SecretScanningValidityChecksEnabled *bool `pulumi:"secretScanningValidityChecksEnabled"` +} + +// The set of arguments for constructing a EnterpriseSecurityAnalysisSettings resource. +type EnterpriseSecurityAnalysisSettingsArgs struct { + // Whether GitHub Advanced Security is automatically enabled for new repositories. Defaults to `false`. Requires Advanced Security license. + AdvancedSecurityEnabledForNewRepositories pulumi.BoolPtrInput + // The slug of the enterprise. + EnterpriseSlug pulumi.StringInput + // Whether secret scanning is automatically enabled for new repositories. Defaults to `false`. + SecretScanningEnabledForNewRepositories pulumi.BoolPtrInput + // Custom URL for secret scanning push protection bypass instructions. + SecretScanningPushProtectionCustomLink pulumi.StringPtrInput + // Whether secret scanning push protection is automatically enabled for new repositories. Defaults to `false`. + SecretScanningPushProtectionEnabledForNewRepositories pulumi.BoolPtrInput + // Whether secret scanning validity checks are enabled. Defaults to `false`. + SecretScanningValidityChecksEnabled pulumi.BoolPtrInput +} + +func (EnterpriseSecurityAnalysisSettingsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*enterpriseSecurityAnalysisSettingsArgs)(nil)).Elem() +} + +type EnterpriseSecurityAnalysisSettingsInput interface { + pulumi.Input + + ToEnterpriseSecurityAnalysisSettingsOutput() EnterpriseSecurityAnalysisSettingsOutput + ToEnterpriseSecurityAnalysisSettingsOutputWithContext(ctx context.Context) EnterpriseSecurityAnalysisSettingsOutput +} + +func (*EnterpriseSecurityAnalysisSettings) ElementType() reflect.Type { + return reflect.TypeOf((**EnterpriseSecurityAnalysisSettings)(nil)).Elem() +} + +func (i *EnterpriseSecurityAnalysisSettings) ToEnterpriseSecurityAnalysisSettingsOutput() EnterpriseSecurityAnalysisSettingsOutput { + return i.ToEnterpriseSecurityAnalysisSettingsOutputWithContext(context.Background()) +} + +func (i *EnterpriseSecurityAnalysisSettings) ToEnterpriseSecurityAnalysisSettingsOutputWithContext(ctx context.Context) EnterpriseSecurityAnalysisSettingsOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseSecurityAnalysisSettingsOutput) +} + +// EnterpriseSecurityAnalysisSettingsArrayInput is an input type that accepts EnterpriseSecurityAnalysisSettingsArray and EnterpriseSecurityAnalysisSettingsArrayOutput values. +// You can construct a concrete instance of `EnterpriseSecurityAnalysisSettingsArrayInput` via: +// +// EnterpriseSecurityAnalysisSettingsArray{ EnterpriseSecurityAnalysisSettingsArgs{...} } +type EnterpriseSecurityAnalysisSettingsArrayInput interface { + pulumi.Input + + ToEnterpriseSecurityAnalysisSettingsArrayOutput() EnterpriseSecurityAnalysisSettingsArrayOutput + ToEnterpriseSecurityAnalysisSettingsArrayOutputWithContext(context.Context) EnterpriseSecurityAnalysisSettingsArrayOutput +} + +type EnterpriseSecurityAnalysisSettingsArray []EnterpriseSecurityAnalysisSettingsInput + +func (EnterpriseSecurityAnalysisSettingsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*EnterpriseSecurityAnalysisSettings)(nil)).Elem() +} + +func (i EnterpriseSecurityAnalysisSettingsArray) ToEnterpriseSecurityAnalysisSettingsArrayOutput() EnterpriseSecurityAnalysisSettingsArrayOutput { + return i.ToEnterpriseSecurityAnalysisSettingsArrayOutputWithContext(context.Background()) +} + +func (i EnterpriseSecurityAnalysisSettingsArray) ToEnterpriseSecurityAnalysisSettingsArrayOutputWithContext(ctx context.Context) EnterpriseSecurityAnalysisSettingsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseSecurityAnalysisSettingsArrayOutput) +} + +// EnterpriseSecurityAnalysisSettingsMapInput is an input type that accepts EnterpriseSecurityAnalysisSettingsMap and EnterpriseSecurityAnalysisSettingsMapOutput values. +// You can construct a concrete instance of `EnterpriseSecurityAnalysisSettingsMapInput` via: +// +// EnterpriseSecurityAnalysisSettingsMap{ "key": EnterpriseSecurityAnalysisSettingsArgs{...} } +type EnterpriseSecurityAnalysisSettingsMapInput interface { + pulumi.Input + + ToEnterpriseSecurityAnalysisSettingsMapOutput() EnterpriseSecurityAnalysisSettingsMapOutput + ToEnterpriseSecurityAnalysisSettingsMapOutputWithContext(context.Context) EnterpriseSecurityAnalysisSettingsMapOutput +} + +type EnterpriseSecurityAnalysisSettingsMap map[string]EnterpriseSecurityAnalysisSettingsInput + +func (EnterpriseSecurityAnalysisSettingsMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*EnterpriseSecurityAnalysisSettings)(nil)).Elem() +} + +func (i EnterpriseSecurityAnalysisSettingsMap) ToEnterpriseSecurityAnalysisSettingsMapOutput() EnterpriseSecurityAnalysisSettingsMapOutput { + return i.ToEnterpriseSecurityAnalysisSettingsMapOutputWithContext(context.Background()) +} + +func (i EnterpriseSecurityAnalysisSettingsMap) ToEnterpriseSecurityAnalysisSettingsMapOutputWithContext(ctx context.Context) EnterpriseSecurityAnalysisSettingsMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseSecurityAnalysisSettingsMapOutput) +} + +type EnterpriseSecurityAnalysisSettingsOutput struct{ *pulumi.OutputState } + +func (EnterpriseSecurityAnalysisSettingsOutput) ElementType() reflect.Type { + return reflect.TypeOf((**EnterpriseSecurityAnalysisSettings)(nil)).Elem() +} + +func (o EnterpriseSecurityAnalysisSettingsOutput) ToEnterpriseSecurityAnalysisSettingsOutput() EnterpriseSecurityAnalysisSettingsOutput { + return o +} + +func (o EnterpriseSecurityAnalysisSettingsOutput) ToEnterpriseSecurityAnalysisSettingsOutputWithContext(ctx context.Context) EnterpriseSecurityAnalysisSettingsOutput { + return o +} + +// Whether GitHub Advanced Security is automatically enabled for new repositories. Defaults to `false`. Requires Advanced Security license. +func (o EnterpriseSecurityAnalysisSettingsOutput) AdvancedSecurityEnabledForNewRepositories() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *EnterpriseSecurityAnalysisSettings) pulumi.BoolPtrOutput { + return v.AdvancedSecurityEnabledForNewRepositories + }).(pulumi.BoolPtrOutput) +} + +// The slug of the enterprise. +func (o EnterpriseSecurityAnalysisSettingsOutput) EnterpriseSlug() pulumi.StringOutput { + return o.ApplyT(func(v *EnterpriseSecurityAnalysisSettings) pulumi.StringOutput { return v.EnterpriseSlug }).(pulumi.StringOutput) +} + +// Whether secret scanning is automatically enabled for new repositories. Defaults to `false`. +func (o EnterpriseSecurityAnalysisSettingsOutput) SecretScanningEnabledForNewRepositories() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *EnterpriseSecurityAnalysisSettings) pulumi.BoolPtrOutput { + return v.SecretScanningEnabledForNewRepositories + }).(pulumi.BoolPtrOutput) +} + +// Custom URL for secret scanning push protection bypass instructions. +func (o EnterpriseSecurityAnalysisSettingsOutput) SecretScanningPushProtectionCustomLink() pulumi.StringPtrOutput { + return o.ApplyT(func(v *EnterpriseSecurityAnalysisSettings) pulumi.StringPtrOutput { + return v.SecretScanningPushProtectionCustomLink + }).(pulumi.StringPtrOutput) +} + +// Whether secret scanning push protection is automatically enabled for new repositories. Defaults to `false`. +func (o EnterpriseSecurityAnalysisSettingsOutput) SecretScanningPushProtectionEnabledForNewRepositories() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *EnterpriseSecurityAnalysisSettings) pulumi.BoolPtrOutput { + return v.SecretScanningPushProtectionEnabledForNewRepositories + }).(pulumi.BoolPtrOutput) +} + +// Whether secret scanning validity checks are enabled. Defaults to `false`. +func (o EnterpriseSecurityAnalysisSettingsOutput) SecretScanningValidityChecksEnabled() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *EnterpriseSecurityAnalysisSettings) pulumi.BoolPtrOutput { + return v.SecretScanningValidityChecksEnabled + }).(pulumi.BoolPtrOutput) +} + +type EnterpriseSecurityAnalysisSettingsArrayOutput struct{ *pulumi.OutputState } + +func (EnterpriseSecurityAnalysisSettingsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*EnterpriseSecurityAnalysisSettings)(nil)).Elem() +} + +func (o EnterpriseSecurityAnalysisSettingsArrayOutput) ToEnterpriseSecurityAnalysisSettingsArrayOutput() EnterpriseSecurityAnalysisSettingsArrayOutput { + return o +} + +func (o EnterpriseSecurityAnalysisSettingsArrayOutput) ToEnterpriseSecurityAnalysisSettingsArrayOutputWithContext(ctx context.Context) EnterpriseSecurityAnalysisSettingsArrayOutput { + return o +} + +func (o EnterpriseSecurityAnalysisSettingsArrayOutput) Index(i pulumi.IntInput) EnterpriseSecurityAnalysisSettingsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *EnterpriseSecurityAnalysisSettings { + return vs[0].([]*EnterpriseSecurityAnalysisSettings)[vs[1].(int)] + }).(EnterpriseSecurityAnalysisSettingsOutput) +} + +type EnterpriseSecurityAnalysisSettingsMapOutput struct{ *pulumi.OutputState } + +func (EnterpriseSecurityAnalysisSettingsMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*EnterpriseSecurityAnalysisSettings)(nil)).Elem() +} + +func (o EnterpriseSecurityAnalysisSettingsMapOutput) ToEnterpriseSecurityAnalysisSettingsMapOutput() EnterpriseSecurityAnalysisSettingsMapOutput { + return o +} + +func (o EnterpriseSecurityAnalysisSettingsMapOutput) ToEnterpriseSecurityAnalysisSettingsMapOutputWithContext(ctx context.Context) EnterpriseSecurityAnalysisSettingsMapOutput { + return o +} + +func (o EnterpriseSecurityAnalysisSettingsMapOutput) MapIndex(k pulumi.StringInput) EnterpriseSecurityAnalysisSettingsOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *EnterpriseSecurityAnalysisSettings { + return vs[0].(map[string]*EnterpriseSecurityAnalysisSettings)[vs[1].(string)] + }).(EnterpriseSecurityAnalysisSettingsOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseSecurityAnalysisSettingsInput)(nil)).Elem(), &EnterpriseSecurityAnalysisSettings{}) + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseSecurityAnalysisSettingsArrayInput)(nil)).Elem(), EnterpriseSecurityAnalysisSettingsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseSecurityAnalysisSettingsMapInput)(nil)).Elem(), EnterpriseSecurityAnalysisSettingsMap{}) + pulumi.RegisterOutputType(EnterpriseSecurityAnalysisSettingsOutput{}) + pulumi.RegisterOutputType(EnterpriseSecurityAnalysisSettingsArrayOutput{}) + pulumi.RegisterOutputType(EnterpriseSecurityAnalysisSettingsMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsEnvironmentPublicKey.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsEnvironmentPublicKey.go new file mode 100644 index 000000000..34caf730b --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsEnvironmentPublicKey.go @@ -0,0 +1,134 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a GitHub Actions public key of a specific environment. This data source is required to be used with other GitHub secrets interactions. +// Note that the provider `token` must have admin rights to a repository to retrieve the action public keys of it's environments. +// +// ## Example Usage +// +// ```go +// 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.GetActionsEnvironmentPublicKey(ctx, &github.GetActionsEnvironmentPublicKeyArgs{ +// Repository: "example_repo", +// Environment: "example_environment", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetActionsEnvironmentPublicKey(ctx *pulumi.Context, args *GetActionsEnvironmentPublicKeyArgs, opts ...pulumi.InvokeOption) (*GetActionsEnvironmentPublicKeyResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetActionsEnvironmentPublicKeyResult + err := ctx.Invoke("github:index/getActionsEnvironmentPublicKey:getActionsEnvironmentPublicKey", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getActionsEnvironmentPublicKey. +type GetActionsEnvironmentPublicKeyArgs struct { + // Name of the environment to get public key from. + Environment string `pulumi:"environment"` + // Name of the repository to get public key from. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getActionsEnvironmentPublicKey. +type GetActionsEnvironmentPublicKeyResult struct { + Environment string `pulumi:"environment"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Actual key retrieved. + Key string `pulumi:"key"` + // ID of the key that has been retrieved. + KeyId string `pulumi:"keyId"` + Repository string `pulumi:"repository"` +} + +func GetActionsEnvironmentPublicKeyOutput(ctx *pulumi.Context, args GetActionsEnvironmentPublicKeyOutputArgs, opts ...pulumi.InvokeOption) GetActionsEnvironmentPublicKeyResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetActionsEnvironmentPublicKeyResultOutput, error) { + args := v.(GetActionsEnvironmentPublicKeyArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getActionsEnvironmentPublicKey:getActionsEnvironmentPublicKey", args, GetActionsEnvironmentPublicKeyResultOutput{}, options).(GetActionsEnvironmentPublicKeyResultOutput), nil + }).(GetActionsEnvironmentPublicKeyResultOutput) +} + +// A collection of arguments for invoking getActionsEnvironmentPublicKey. +type GetActionsEnvironmentPublicKeyOutputArgs struct { + // Name of the environment to get public key from. + Environment pulumi.StringInput `pulumi:"environment"` + // Name of the repository to get public key from. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetActionsEnvironmentPublicKeyOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsEnvironmentPublicKeyArgs)(nil)).Elem() +} + +// A collection of values returned by getActionsEnvironmentPublicKey. +type GetActionsEnvironmentPublicKeyResultOutput struct{ *pulumi.OutputState } + +func (GetActionsEnvironmentPublicKeyResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsEnvironmentPublicKeyResult)(nil)).Elem() +} + +func (o GetActionsEnvironmentPublicKeyResultOutput) ToGetActionsEnvironmentPublicKeyResultOutput() GetActionsEnvironmentPublicKeyResultOutput { + return o +} + +func (o GetActionsEnvironmentPublicKeyResultOutput) ToGetActionsEnvironmentPublicKeyResultOutputWithContext(ctx context.Context) GetActionsEnvironmentPublicKeyResultOutput { + return o +} + +func (o GetActionsEnvironmentPublicKeyResultOutput) Environment() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentPublicKeyResult) string { return v.Environment }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetActionsEnvironmentPublicKeyResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentPublicKeyResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Actual key retrieved. +func (o GetActionsEnvironmentPublicKeyResultOutput) Key() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentPublicKeyResult) string { return v.Key }).(pulumi.StringOutput) +} + +// ID of the key that has been retrieved. +func (o GetActionsEnvironmentPublicKeyResultOutput) KeyId() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentPublicKeyResult) string { return v.KeyId }).(pulumi.StringOutput) +} + +func (o GetActionsEnvironmentPublicKeyResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentPublicKeyResult) string { return v.Repository }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetActionsEnvironmentPublicKeyResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsEnvironmentSecrets.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsEnvironmentSecrets.go new file mode 100644 index 000000000..f742454ab --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsEnvironmentSecrets.go @@ -0,0 +1,133 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the list of secrets of the repository environment. +// +// ## Example Usage +// +// ```go +// 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.GetActionsEnvironmentSecrets(ctx, &github.GetActionsEnvironmentSecretsArgs{ +// Name: pulumi.StringRef("exampleRepo"), +// Environment: "exampleEnvironment", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetActionsEnvironmentSecrets(ctx *pulumi.Context, args *GetActionsEnvironmentSecretsArgs, opts ...pulumi.InvokeOption) (*GetActionsEnvironmentSecretsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetActionsEnvironmentSecretsResult + err := ctx.Invoke("github:index/getActionsEnvironmentSecrets:getActionsEnvironmentSecrets", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getActionsEnvironmentSecrets. +type GetActionsEnvironmentSecretsArgs struct { + Environment string `pulumi:"environment"` + FullName *string `pulumi:"fullName"` + // Name of the secret + Name *string `pulumi:"name"` +} + +// A collection of values returned by getActionsEnvironmentSecrets. +type GetActionsEnvironmentSecretsResult struct { + Environment string `pulumi:"environment"` + FullName string `pulumi:"fullName"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Name of the secret + Name string `pulumi:"name"` + // list of secrets for the environment + Secrets []GetActionsEnvironmentSecretsSecret `pulumi:"secrets"` +} + +func GetActionsEnvironmentSecretsOutput(ctx *pulumi.Context, args GetActionsEnvironmentSecretsOutputArgs, opts ...pulumi.InvokeOption) GetActionsEnvironmentSecretsResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetActionsEnvironmentSecretsResultOutput, error) { + args := v.(GetActionsEnvironmentSecretsArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getActionsEnvironmentSecrets:getActionsEnvironmentSecrets", args, GetActionsEnvironmentSecretsResultOutput{}, options).(GetActionsEnvironmentSecretsResultOutput), nil + }).(GetActionsEnvironmentSecretsResultOutput) +} + +// A collection of arguments for invoking getActionsEnvironmentSecrets. +type GetActionsEnvironmentSecretsOutputArgs struct { + Environment pulumi.StringInput `pulumi:"environment"` + FullName pulumi.StringPtrInput `pulumi:"fullName"` + // Name of the secret + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (GetActionsEnvironmentSecretsOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsEnvironmentSecretsArgs)(nil)).Elem() +} + +// A collection of values returned by getActionsEnvironmentSecrets. +type GetActionsEnvironmentSecretsResultOutput struct{ *pulumi.OutputState } + +func (GetActionsEnvironmentSecretsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsEnvironmentSecretsResult)(nil)).Elem() +} + +func (o GetActionsEnvironmentSecretsResultOutput) ToGetActionsEnvironmentSecretsResultOutput() GetActionsEnvironmentSecretsResultOutput { + return o +} + +func (o GetActionsEnvironmentSecretsResultOutput) ToGetActionsEnvironmentSecretsResultOutputWithContext(ctx context.Context) GetActionsEnvironmentSecretsResultOutput { + return o +} + +func (o GetActionsEnvironmentSecretsResultOutput) Environment() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentSecretsResult) string { return v.Environment }).(pulumi.StringOutput) +} + +func (o GetActionsEnvironmentSecretsResultOutput) FullName() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentSecretsResult) string { return v.FullName }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetActionsEnvironmentSecretsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentSecretsResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Name of the secret +func (o GetActionsEnvironmentSecretsResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentSecretsResult) string { return v.Name }).(pulumi.StringOutput) +} + +// list of secrets for the environment +func (o GetActionsEnvironmentSecretsResultOutput) Secrets() GetActionsEnvironmentSecretsSecretArrayOutput { + return o.ApplyT(func(v GetActionsEnvironmentSecretsResult) []GetActionsEnvironmentSecretsSecret { return v.Secrets }).(GetActionsEnvironmentSecretsSecretArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetActionsEnvironmentSecretsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsEnvironmentVariables.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsEnvironmentVariables.go new file mode 100644 index 000000000..e652a4f93 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsEnvironmentVariables.go @@ -0,0 +1,135 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the list of variables of the repository environment. +// +// ## Example Usage +// +// ```go +// 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.GetActionsEnvironmentVariables(ctx, &github.GetActionsEnvironmentVariablesArgs{ +// Name: pulumi.StringRef("exampleRepo"), +// Environment: "exampleEnvironment", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetActionsEnvironmentVariables(ctx *pulumi.Context, args *GetActionsEnvironmentVariablesArgs, opts ...pulumi.InvokeOption) (*GetActionsEnvironmentVariablesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetActionsEnvironmentVariablesResult + err := ctx.Invoke("github:index/getActionsEnvironmentVariables:getActionsEnvironmentVariables", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getActionsEnvironmentVariables. +type GetActionsEnvironmentVariablesArgs struct { + Environment string `pulumi:"environment"` + FullName *string `pulumi:"fullName"` + // Name of the variable + Name *string `pulumi:"name"` +} + +// A collection of values returned by getActionsEnvironmentVariables. +type GetActionsEnvironmentVariablesResult struct { + Environment string `pulumi:"environment"` + FullName string `pulumi:"fullName"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Name of the variable + Name string `pulumi:"name"` + // list of variables for the environment + Variables []GetActionsEnvironmentVariablesVariable `pulumi:"variables"` +} + +func GetActionsEnvironmentVariablesOutput(ctx *pulumi.Context, args GetActionsEnvironmentVariablesOutputArgs, opts ...pulumi.InvokeOption) GetActionsEnvironmentVariablesResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetActionsEnvironmentVariablesResultOutput, error) { + args := v.(GetActionsEnvironmentVariablesArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getActionsEnvironmentVariables:getActionsEnvironmentVariables", args, GetActionsEnvironmentVariablesResultOutput{}, options).(GetActionsEnvironmentVariablesResultOutput), nil + }).(GetActionsEnvironmentVariablesResultOutput) +} + +// A collection of arguments for invoking getActionsEnvironmentVariables. +type GetActionsEnvironmentVariablesOutputArgs struct { + Environment pulumi.StringInput `pulumi:"environment"` + FullName pulumi.StringPtrInput `pulumi:"fullName"` + // Name of the variable + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (GetActionsEnvironmentVariablesOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsEnvironmentVariablesArgs)(nil)).Elem() +} + +// A collection of values returned by getActionsEnvironmentVariables. +type GetActionsEnvironmentVariablesResultOutput struct{ *pulumi.OutputState } + +func (GetActionsEnvironmentVariablesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsEnvironmentVariablesResult)(nil)).Elem() +} + +func (o GetActionsEnvironmentVariablesResultOutput) ToGetActionsEnvironmentVariablesResultOutput() GetActionsEnvironmentVariablesResultOutput { + return o +} + +func (o GetActionsEnvironmentVariablesResultOutput) ToGetActionsEnvironmentVariablesResultOutputWithContext(ctx context.Context) GetActionsEnvironmentVariablesResultOutput { + return o +} + +func (o GetActionsEnvironmentVariablesResultOutput) Environment() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentVariablesResult) string { return v.Environment }).(pulumi.StringOutput) +} + +func (o GetActionsEnvironmentVariablesResultOutput) FullName() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentVariablesResult) string { return v.FullName }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetActionsEnvironmentVariablesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentVariablesResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Name of the variable +func (o GetActionsEnvironmentVariablesResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentVariablesResult) string { return v.Name }).(pulumi.StringOutput) +} + +// list of variables for the environment +func (o GetActionsEnvironmentVariablesResultOutput) Variables() GetActionsEnvironmentVariablesVariableArrayOutput { + return o.ApplyT(func(v GetActionsEnvironmentVariablesResult) []GetActionsEnvironmentVariablesVariable { + return v.Variables + }).(GetActionsEnvironmentVariablesVariableArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetActionsEnvironmentVariablesResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsOrganizationOidcSubjectClaimCustomizationTemplate.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsOrganizationOidcSubjectClaimCustomizationTemplate.go new file mode 100644 index 000000000..31707ba57 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsOrganizationOidcSubjectClaimCustomizationTemplate.go @@ -0,0 +1,93 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the OpenID Connect subject claim customization template for an organization +// +// ## Example Usage +// +// ```go +// 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.GetActionsOrganizationOidcSubjectClaimCustomizationTemplate(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupActionsOrganizationOidcSubjectClaimCustomizationTemplate(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResult + err := ctx.Invoke("github:index/getActionsOrganizationOidcSubjectClaimCustomizationTemplate:getActionsOrganizationOidcSubjectClaimCustomizationTemplate", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getActionsOrganizationOidcSubjectClaimCustomizationTemplate. +type LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The list of OpenID Connect claim keys. + IncludeClaimKeys []string `pulumi:"includeClaimKeys"` +} + +func LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getActionsOrganizationOidcSubjectClaimCustomizationTemplate:getActionsOrganizationOidcSubjectClaimCustomizationTemplate", nil, LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResultOutput{}, options).(LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResultOutput), nil + }).(LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResultOutput) +} + +// A collection of values returned by getActionsOrganizationOidcSubjectClaimCustomizationTemplate. +type LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResultOutput struct{ *pulumi.OutputState } + +func (LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResult)(nil)).Elem() +} + +func (o LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResultOutput) ToLookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResultOutput() LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResultOutput { + return o +} + +func (o LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResultOutput) ToLookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResultOutputWithContext(ctx context.Context) LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The list of OpenID Connect claim keys. +func (o LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResultOutput) IncludeClaimKeys() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResult) []string { + return v.IncludeClaimKeys + }).(pulumi.StringArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupActionsOrganizationOidcSubjectClaimCustomizationTemplateResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsOrganizationPublicKey.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsOrganizationPublicKey.go new file mode 100644 index 000000000..3b7392fc6 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsOrganizationPublicKey.go @@ -0,0 +1,99 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a GitHub Actions Organization public key. This data source is required to be used with other GitHub secrets interactions. +// Note that the provider `token` must have admin rights to an organization to retrieve it's action public key. +// +// ## Example Usage +// +// ```go +// 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.GetActionsOrganizationPublicKey(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetActionsOrganizationPublicKey(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetActionsOrganizationPublicKeyResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetActionsOrganizationPublicKeyResult + err := ctx.Invoke("github:index/getActionsOrganizationPublicKey:getActionsOrganizationPublicKey", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getActionsOrganizationPublicKey. +type GetActionsOrganizationPublicKeyResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Actual key retrieved. + Key string `pulumi:"key"` + // ID of the key that has been retrieved. + KeyId string `pulumi:"keyId"` +} + +func GetActionsOrganizationPublicKeyOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetActionsOrganizationPublicKeyResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetActionsOrganizationPublicKeyResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getActionsOrganizationPublicKey:getActionsOrganizationPublicKey", nil, GetActionsOrganizationPublicKeyResultOutput{}, options).(GetActionsOrganizationPublicKeyResultOutput), nil + }).(GetActionsOrganizationPublicKeyResultOutput) +} + +// A collection of values returned by getActionsOrganizationPublicKey. +type GetActionsOrganizationPublicKeyResultOutput struct{ *pulumi.OutputState } + +func (GetActionsOrganizationPublicKeyResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsOrganizationPublicKeyResult)(nil)).Elem() +} + +func (o GetActionsOrganizationPublicKeyResultOutput) ToGetActionsOrganizationPublicKeyResultOutput() GetActionsOrganizationPublicKeyResultOutput { + return o +} + +func (o GetActionsOrganizationPublicKeyResultOutput) ToGetActionsOrganizationPublicKeyResultOutputWithContext(ctx context.Context) GetActionsOrganizationPublicKeyResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetActionsOrganizationPublicKeyResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsOrganizationPublicKeyResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Actual key retrieved. +func (o GetActionsOrganizationPublicKeyResultOutput) Key() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsOrganizationPublicKeyResult) string { return v.Key }).(pulumi.StringOutput) +} + +// ID of the key that has been retrieved. +func (o GetActionsOrganizationPublicKeyResultOutput) KeyId() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsOrganizationPublicKeyResult) string { return v.KeyId }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetActionsOrganizationPublicKeyResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsOrganizationRegistrationToken.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsOrganizationRegistrationToken.go new file mode 100644 index 000000000..30a8afd4e --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsOrganizationRegistrationToken.go @@ -0,0 +1,98 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve a GitHub Actions organization registration token. This token can then be used to register a self-hosted runner. +// +// ## Example Usage +// +// ```go +// 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.GetActionsOrganizationRegistrationToken(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetActionsOrganizationRegistrationToken(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetActionsOrganizationRegistrationTokenResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetActionsOrganizationRegistrationTokenResult + err := ctx.Invoke("github:index/getActionsOrganizationRegistrationToken:getActionsOrganizationRegistrationToken", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getActionsOrganizationRegistrationToken. +type GetActionsOrganizationRegistrationTokenResult struct { + // The token expiration date. + ExpiresAt int `pulumi:"expiresAt"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The token that has been retrieved. + Token string `pulumi:"token"` +} + +func GetActionsOrganizationRegistrationTokenOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetActionsOrganizationRegistrationTokenResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetActionsOrganizationRegistrationTokenResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getActionsOrganizationRegistrationToken:getActionsOrganizationRegistrationToken", nil, GetActionsOrganizationRegistrationTokenResultOutput{}, options).(GetActionsOrganizationRegistrationTokenResultOutput), nil + }).(GetActionsOrganizationRegistrationTokenResultOutput) +} + +// A collection of values returned by getActionsOrganizationRegistrationToken. +type GetActionsOrganizationRegistrationTokenResultOutput struct{ *pulumi.OutputState } + +func (GetActionsOrganizationRegistrationTokenResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsOrganizationRegistrationTokenResult)(nil)).Elem() +} + +func (o GetActionsOrganizationRegistrationTokenResultOutput) ToGetActionsOrganizationRegistrationTokenResultOutput() GetActionsOrganizationRegistrationTokenResultOutput { + return o +} + +func (o GetActionsOrganizationRegistrationTokenResultOutput) ToGetActionsOrganizationRegistrationTokenResultOutputWithContext(ctx context.Context) GetActionsOrganizationRegistrationTokenResultOutput { + return o +} + +// The token expiration date. +func (o GetActionsOrganizationRegistrationTokenResultOutput) ExpiresAt() pulumi.IntOutput { + return o.ApplyT(func(v GetActionsOrganizationRegistrationTokenResult) int { return v.ExpiresAt }).(pulumi.IntOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetActionsOrganizationRegistrationTokenResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsOrganizationRegistrationTokenResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The token that has been retrieved. +func (o GetActionsOrganizationRegistrationTokenResultOutput) Token() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsOrganizationRegistrationTokenResult) string { return v.Token }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetActionsOrganizationRegistrationTokenResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsOrganizationSecrets.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsOrganizationSecrets.go new file mode 100644 index 000000000..678e57a89 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsOrganizationSecrets.go @@ -0,0 +1,91 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the list of secrets of the organization. +// +// ## Example Usage +// +// ```go +// 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.GetActionsOrganizationSecrets(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetActionsOrganizationSecrets(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetActionsOrganizationSecretsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetActionsOrganizationSecretsResult + err := ctx.Invoke("github:index/getActionsOrganizationSecrets:getActionsOrganizationSecrets", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getActionsOrganizationSecrets. +type GetActionsOrganizationSecretsResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // list of secrets for the repository + Secrets []GetActionsOrganizationSecretsSecret `pulumi:"secrets"` +} + +func GetActionsOrganizationSecretsOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetActionsOrganizationSecretsResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetActionsOrganizationSecretsResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getActionsOrganizationSecrets:getActionsOrganizationSecrets", nil, GetActionsOrganizationSecretsResultOutput{}, options).(GetActionsOrganizationSecretsResultOutput), nil + }).(GetActionsOrganizationSecretsResultOutput) +} + +// A collection of values returned by getActionsOrganizationSecrets. +type GetActionsOrganizationSecretsResultOutput struct{ *pulumi.OutputState } + +func (GetActionsOrganizationSecretsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsOrganizationSecretsResult)(nil)).Elem() +} + +func (o GetActionsOrganizationSecretsResultOutput) ToGetActionsOrganizationSecretsResultOutput() GetActionsOrganizationSecretsResultOutput { + return o +} + +func (o GetActionsOrganizationSecretsResultOutput) ToGetActionsOrganizationSecretsResultOutputWithContext(ctx context.Context) GetActionsOrganizationSecretsResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetActionsOrganizationSecretsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsOrganizationSecretsResult) string { return v.Id }).(pulumi.StringOutput) +} + +// list of secrets for the repository +func (o GetActionsOrganizationSecretsResultOutput) Secrets() GetActionsOrganizationSecretsSecretArrayOutput { + return o.ApplyT(func(v GetActionsOrganizationSecretsResult) []GetActionsOrganizationSecretsSecret { return v.Secrets }).(GetActionsOrganizationSecretsSecretArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetActionsOrganizationSecretsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsOrganizationVariables.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsOrganizationVariables.go new file mode 100644 index 000000000..eeec4b595 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsOrganizationVariables.go @@ -0,0 +1,93 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the list of variables of the organization. +// +// ## Example Usage +// +// ```go +// 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.GetActionsOrganizationVariables(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetActionsOrganizationVariables(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetActionsOrganizationVariablesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetActionsOrganizationVariablesResult + err := ctx.Invoke("github:index/getActionsOrganizationVariables:getActionsOrganizationVariables", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getActionsOrganizationVariables. +type GetActionsOrganizationVariablesResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // list of variables for the repository + Variables []GetActionsOrganizationVariablesVariable `pulumi:"variables"` +} + +func GetActionsOrganizationVariablesOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetActionsOrganizationVariablesResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetActionsOrganizationVariablesResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getActionsOrganizationVariables:getActionsOrganizationVariables", nil, GetActionsOrganizationVariablesResultOutput{}, options).(GetActionsOrganizationVariablesResultOutput), nil + }).(GetActionsOrganizationVariablesResultOutput) +} + +// A collection of values returned by getActionsOrganizationVariables. +type GetActionsOrganizationVariablesResultOutput struct{ *pulumi.OutputState } + +func (GetActionsOrganizationVariablesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsOrganizationVariablesResult)(nil)).Elem() +} + +func (o GetActionsOrganizationVariablesResultOutput) ToGetActionsOrganizationVariablesResultOutput() GetActionsOrganizationVariablesResultOutput { + return o +} + +func (o GetActionsOrganizationVariablesResultOutput) ToGetActionsOrganizationVariablesResultOutputWithContext(ctx context.Context) GetActionsOrganizationVariablesResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetActionsOrganizationVariablesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsOrganizationVariablesResult) string { return v.Id }).(pulumi.StringOutput) +} + +// list of variables for the repository +func (o GetActionsOrganizationVariablesResultOutput) Variables() GetActionsOrganizationVariablesVariableArrayOutput { + return o.ApplyT(func(v GetActionsOrganizationVariablesResult) []GetActionsOrganizationVariablesVariable { + return v.Variables + }).(GetActionsOrganizationVariablesVariableArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetActionsOrganizationVariablesResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsPublicKey.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsPublicKey.go new file mode 100644 index 000000000..806713e47 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsPublicKey.go @@ -0,0 +1,124 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a GitHub Actions public key. This data source is required to be used with other GitHub secrets interactions. +// Note that the provider `token` must have admin rights to a repository to retrieve it's action public key. +// +// ## Example Usage +// +// ```go +// 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.GetActionsPublicKey(ctx, &github.GetActionsPublicKeyArgs{ +// Repository: "example_repo", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetActionsPublicKey(ctx *pulumi.Context, args *GetActionsPublicKeyArgs, opts ...pulumi.InvokeOption) (*GetActionsPublicKeyResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetActionsPublicKeyResult + err := ctx.Invoke("github:index/getActionsPublicKey:getActionsPublicKey", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getActionsPublicKey. +type GetActionsPublicKeyArgs struct { + // Name of the repository to get public key from. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getActionsPublicKey. +type GetActionsPublicKeyResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Actual key retrieved. + Key string `pulumi:"key"` + // ID of the key that has been retrieved. + KeyId string `pulumi:"keyId"` + Repository string `pulumi:"repository"` +} + +func GetActionsPublicKeyOutput(ctx *pulumi.Context, args GetActionsPublicKeyOutputArgs, opts ...pulumi.InvokeOption) GetActionsPublicKeyResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetActionsPublicKeyResultOutput, error) { + args := v.(GetActionsPublicKeyArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getActionsPublicKey:getActionsPublicKey", args, GetActionsPublicKeyResultOutput{}, options).(GetActionsPublicKeyResultOutput), nil + }).(GetActionsPublicKeyResultOutput) +} + +// A collection of arguments for invoking getActionsPublicKey. +type GetActionsPublicKeyOutputArgs struct { + // Name of the repository to get public key from. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetActionsPublicKeyOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsPublicKeyArgs)(nil)).Elem() +} + +// A collection of values returned by getActionsPublicKey. +type GetActionsPublicKeyResultOutput struct{ *pulumi.OutputState } + +func (GetActionsPublicKeyResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsPublicKeyResult)(nil)).Elem() +} + +func (o GetActionsPublicKeyResultOutput) ToGetActionsPublicKeyResultOutput() GetActionsPublicKeyResultOutput { + return o +} + +func (o GetActionsPublicKeyResultOutput) ToGetActionsPublicKeyResultOutputWithContext(ctx context.Context) GetActionsPublicKeyResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetActionsPublicKeyResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsPublicKeyResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Actual key retrieved. +func (o GetActionsPublicKeyResultOutput) Key() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsPublicKeyResult) string { return v.Key }).(pulumi.StringOutput) +} + +// ID of the key that has been retrieved. +func (o GetActionsPublicKeyResultOutput) KeyId() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsPublicKeyResult) string { return v.KeyId }).(pulumi.StringOutput) +} + +func (o GetActionsPublicKeyResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsPublicKeyResult) string { return v.Repository }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetActionsPublicKeyResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsRegistrationToken.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsRegistrationToken.go new file mode 100644 index 000000000..a1457108a --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsRegistrationToken.go @@ -0,0 +1,123 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve a GitHub Actions repository registration token. This token can then be used to register a self-hosted runner. +// +// ## Example Usage +// +// ```go +// 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.GetActionsRegistrationToken(ctx, &github.GetActionsRegistrationTokenArgs{ +// Repository: "example_repo", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetActionsRegistrationToken(ctx *pulumi.Context, args *GetActionsRegistrationTokenArgs, opts ...pulumi.InvokeOption) (*GetActionsRegistrationTokenResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetActionsRegistrationTokenResult + err := ctx.Invoke("github:index/getActionsRegistrationToken:getActionsRegistrationToken", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getActionsRegistrationToken. +type GetActionsRegistrationTokenArgs struct { + // Name of the repository to get a GitHub Actions registration token for. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getActionsRegistrationToken. +type GetActionsRegistrationTokenResult struct { + // The token expiration date. + ExpiresAt int `pulumi:"expiresAt"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Repository string `pulumi:"repository"` + // The token that has been retrieved. + Token string `pulumi:"token"` +} + +func GetActionsRegistrationTokenOutput(ctx *pulumi.Context, args GetActionsRegistrationTokenOutputArgs, opts ...pulumi.InvokeOption) GetActionsRegistrationTokenResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetActionsRegistrationTokenResultOutput, error) { + args := v.(GetActionsRegistrationTokenArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getActionsRegistrationToken:getActionsRegistrationToken", args, GetActionsRegistrationTokenResultOutput{}, options).(GetActionsRegistrationTokenResultOutput), nil + }).(GetActionsRegistrationTokenResultOutput) +} + +// A collection of arguments for invoking getActionsRegistrationToken. +type GetActionsRegistrationTokenOutputArgs struct { + // Name of the repository to get a GitHub Actions registration token for. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetActionsRegistrationTokenOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsRegistrationTokenArgs)(nil)).Elem() +} + +// A collection of values returned by getActionsRegistrationToken. +type GetActionsRegistrationTokenResultOutput struct{ *pulumi.OutputState } + +func (GetActionsRegistrationTokenResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsRegistrationTokenResult)(nil)).Elem() +} + +func (o GetActionsRegistrationTokenResultOutput) ToGetActionsRegistrationTokenResultOutput() GetActionsRegistrationTokenResultOutput { + return o +} + +func (o GetActionsRegistrationTokenResultOutput) ToGetActionsRegistrationTokenResultOutputWithContext(ctx context.Context) GetActionsRegistrationTokenResultOutput { + return o +} + +// The token expiration date. +func (o GetActionsRegistrationTokenResultOutput) ExpiresAt() pulumi.IntOutput { + return o.ApplyT(func(v GetActionsRegistrationTokenResult) int { return v.ExpiresAt }).(pulumi.IntOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetActionsRegistrationTokenResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsRegistrationTokenResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetActionsRegistrationTokenResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsRegistrationTokenResult) string { return v.Repository }).(pulumi.StringOutput) +} + +// The token that has been retrieved. +func (o GetActionsRegistrationTokenResultOutput) Token() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsRegistrationTokenResult) string { return v.Token }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetActionsRegistrationTokenResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsRepositoryOidcSubjectClaimCustomizationTemplate.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsRepositoryOidcSubjectClaimCustomizationTemplate.go new file mode 100644 index 000000000..1c121e62a --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsRepositoryOidcSubjectClaimCustomizationTemplate.go @@ -0,0 +1,125 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the OpenID Connect subject claim customization template for a repository +// +// ## Example Usage +// +// ```go +// 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.GetActionsRepositoryOidcSubjectClaimCustomizationTemplate(ctx, &github.LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateArgs{ +// Name: "example_repository", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupActionsRepositoryOidcSubjectClaimCustomizationTemplate(ctx *pulumi.Context, args *LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateArgs, opts ...pulumi.InvokeOption) (*LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResult + err := ctx.Invoke("github:index/getActionsRepositoryOidcSubjectClaimCustomizationTemplate:getActionsRepositoryOidcSubjectClaimCustomizationTemplate", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getActionsRepositoryOidcSubjectClaimCustomizationTemplate. +type LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateArgs struct { + // Name of the repository to get the OpenID Connect subject claim customization template for. + Name string `pulumi:"name"` +} + +// A collection of values returned by getActionsRepositoryOidcSubjectClaimCustomizationTemplate. +type LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The list of OpenID Connect claim keys. + IncludeClaimKeys []string `pulumi:"includeClaimKeys"` + Name string `pulumi:"name"` + // Whether the repository uses the default template. + UseDefault bool `pulumi:"useDefault"` +} + +func LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateOutput(ctx *pulumi.Context, args LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateOutputArgs, opts ...pulumi.InvokeOption) LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput, error) { + args := v.(LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getActionsRepositoryOidcSubjectClaimCustomizationTemplate:getActionsRepositoryOidcSubjectClaimCustomizationTemplate", args, LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput{}, options).(LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput), nil + }).(LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput) +} + +// A collection of arguments for invoking getActionsRepositoryOidcSubjectClaimCustomizationTemplate. +type LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateOutputArgs struct { + // Name of the repository to get the OpenID Connect subject claim customization template for. + Name pulumi.StringInput `pulumi:"name"` +} + +func (LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateArgs)(nil)).Elem() +} + +// A collection of values returned by getActionsRepositoryOidcSubjectClaimCustomizationTemplate. +type LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput struct{ *pulumi.OutputState } + +func (LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResult)(nil)).Elem() +} + +func (o LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput) ToLookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput() LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput { + return o +} + +func (o LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput) ToLookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutputWithContext(ctx context.Context) LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The list of OpenID Connect claim keys. +func (o LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput) IncludeClaimKeys() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResult) []string { + return v.IncludeClaimKeys + }).(pulumi.StringArrayOutput) +} + +func (o LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResult) string { return v.Name }).(pulumi.StringOutput) +} + +// Whether the repository uses the default template. +func (o LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput) UseDefault() pulumi.BoolOutput { + return o.ApplyT(func(v LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResult) bool { return v.UseDefault }).(pulumi.BoolOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupActionsRepositoryOidcSubjectClaimCustomizationTemplateResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsSecrets.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsSecrets.go new file mode 100644 index 000000000..7a8f43115 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsSecrets.go @@ -0,0 +1,127 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the list of secrets for a GitHub repository. +// +// ## Example Usage +// +// ```go +// 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.GetActionsSecrets(ctx, &github.GetActionsSecretsArgs{ +// Name: pulumi.StringRef("example"), +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetActionsSecrets(ctx *pulumi.Context, args *GetActionsSecretsArgs, opts ...pulumi.InvokeOption) (*GetActionsSecretsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetActionsSecretsResult + err := ctx.Invoke("github:index/getActionsSecrets:getActionsSecrets", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getActionsSecrets. +type GetActionsSecretsArgs struct { + // Full name of the repository (in `org/name` format). + FullName *string `pulumi:"fullName"` + // The name of the repository. + Name *string `pulumi:"name"` +} + +// A collection of values returned by getActionsSecrets. +type GetActionsSecretsResult struct { + FullName string `pulumi:"fullName"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Secret name + Name string `pulumi:"name"` + // list of secrets for the repository + Secrets []GetActionsSecretsSecret `pulumi:"secrets"` +} + +func GetActionsSecretsOutput(ctx *pulumi.Context, args GetActionsSecretsOutputArgs, opts ...pulumi.InvokeOption) GetActionsSecretsResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetActionsSecretsResultOutput, error) { + args := v.(GetActionsSecretsArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getActionsSecrets:getActionsSecrets", args, GetActionsSecretsResultOutput{}, options).(GetActionsSecretsResultOutput), nil + }).(GetActionsSecretsResultOutput) +} + +// A collection of arguments for invoking getActionsSecrets. +type GetActionsSecretsOutputArgs struct { + // Full name of the repository (in `org/name` format). + FullName pulumi.StringPtrInput `pulumi:"fullName"` + // The name of the repository. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (GetActionsSecretsOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsSecretsArgs)(nil)).Elem() +} + +// A collection of values returned by getActionsSecrets. +type GetActionsSecretsResultOutput struct{ *pulumi.OutputState } + +func (GetActionsSecretsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsSecretsResult)(nil)).Elem() +} + +func (o GetActionsSecretsResultOutput) ToGetActionsSecretsResultOutput() GetActionsSecretsResultOutput { + return o +} + +func (o GetActionsSecretsResultOutput) ToGetActionsSecretsResultOutputWithContext(ctx context.Context) GetActionsSecretsResultOutput { + return o +} + +func (o GetActionsSecretsResultOutput) FullName() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsSecretsResult) string { return v.FullName }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetActionsSecretsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsSecretsResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Secret name +func (o GetActionsSecretsResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsSecretsResult) string { return v.Name }).(pulumi.StringOutput) +} + +// list of secrets for the repository +func (o GetActionsSecretsResultOutput) Secrets() GetActionsSecretsSecretArrayOutput { + return o.ApplyT(func(v GetActionsSecretsResult) []GetActionsSecretsSecret { return v.Secrets }).(GetActionsSecretsSecretArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetActionsSecretsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsVariables.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsVariables.go new file mode 100644 index 000000000..9d685222c --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getActionsVariables.go @@ -0,0 +1,127 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the list of variables for a GitHub repository. +// +// ## Example Usage +// +// ```go +// 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.GetActionsVariables(ctx, &github.GetActionsVariablesArgs{ +// Name: pulumi.StringRef("example"), +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetActionsVariables(ctx *pulumi.Context, args *GetActionsVariablesArgs, opts ...pulumi.InvokeOption) (*GetActionsVariablesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetActionsVariablesResult + err := ctx.Invoke("github:index/getActionsVariables:getActionsVariables", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getActionsVariables. +type GetActionsVariablesArgs struct { + // Full name of the repository (in `org/name` format). + FullName *string `pulumi:"fullName"` + // The name of the repository. + Name *string `pulumi:"name"` +} + +// A collection of values returned by getActionsVariables. +type GetActionsVariablesResult struct { + FullName string `pulumi:"fullName"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Name of the variable + Name string `pulumi:"name"` + // list of variables for the repository + Variables []GetActionsVariablesVariable `pulumi:"variables"` +} + +func GetActionsVariablesOutput(ctx *pulumi.Context, args GetActionsVariablesOutputArgs, opts ...pulumi.InvokeOption) GetActionsVariablesResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetActionsVariablesResultOutput, error) { + args := v.(GetActionsVariablesArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getActionsVariables:getActionsVariables", args, GetActionsVariablesResultOutput{}, options).(GetActionsVariablesResultOutput), nil + }).(GetActionsVariablesResultOutput) +} + +// A collection of arguments for invoking getActionsVariables. +type GetActionsVariablesOutputArgs struct { + // Full name of the repository (in `org/name` format). + FullName pulumi.StringPtrInput `pulumi:"fullName"` + // The name of the repository. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (GetActionsVariablesOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsVariablesArgs)(nil)).Elem() +} + +// A collection of values returned by getActionsVariables. +type GetActionsVariablesResultOutput struct{ *pulumi.OutputState } + +func (GetActionsVariablesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsVariablesResult)(nil)).Elem() +} + +func (o GetActionsVariablesResultOutput) ToGetActionsVariablesResultOutput() GetActionsVariablesResultOutput { + return o +} + +func (o GetActionsVariablesResultOutput) ToGetActionsVariablesResultOutputWithContext(ctx context.Context) GetActionsVariablesResultOutput { + return o +} + +func (o GetActionsVariablesResultOutput) FullName() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsVariablesResult) string { return v.FullName }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetActionsVariablesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsVariablesResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Name of the variable +func (o GetActionsVariablesResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsVariablesResult) string { return v.Name }).(pulumi.StringOutput) +} + +// list of variables for the repository +func (o GetActionsVariablesResultOutput) Variables() GetActionsVariablesVariableArrayOutput { + return o.ApplyT(func(v GetActionsVariablesResult) []GetActionsVariablesVariable { return v.Variables }).(GetActionsVariablesVariableArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetActionsVariablesResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getAppToken.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getAppToken.go new file mode 100644 index 000000000..8d247d8bf --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getAppToken.go @@ -0,0 +1,139 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to generate a [GitHub App JWT](https://docs.github.com/en/apps/creating-github-apps/authenticating-with-a-github-app/generating-a-json-web-token-jwt-for-a-github-app). +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi-github/sdk/v6/go/github" +// "github.com/pulumi/pulumi-std/sdk/go/std" +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// _, err := github.GetAppToken(ctx, &github.GetAppTokenArgs{ +// AppId: "123456", +// InstallationId: "78910", +// PemFile: std.File(ctx, &std.FileArgs{ +// Input: "foo/bar.pem", +// }, nil).Result, +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetAppToken(ctx *pulumi.Context, args *GetAppTokenArgs, opts ...pulumi.InvokeOption) (*GetAppTokenResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetAppTokenResult + err := ctx.Invoke("github:index/getAppToken:getAppToken", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getAppToken. +type GetAppTokenArgs struct { + // This is the ID of the GitHub App. + AppId string `pulumi:"appId"` + // This is the ID of the GitHub App installation. + InstallationId string `pulumi:"installationId"` + // This is the contents of the GitHub App private key PEM file. + PemFile string `pulumi:"pemFile"` +} + +// A collection of values returned by getAppToken. +type GetAppTokenResult struct { + AppId string `pulumi:"appId"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + InstallationId string `pulumi:"installationId"` + PemFile string `pulumi:"pemFile"` + // The generated GitHub APP JWT. + Token string `pulumi:"token"` +} + +func GetAppTokenOutput(ctx *pulumi.Context, args GetAppTokenOutputArgs, opts ...pulumi.InvokeOption) GetAppTokenResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetAppTokenResultOutput, error) { + args := v.(GetAppTokenArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getAppToken:getAppToken", args, GetAppTokenResultOutput{}, options).(GetAppTokenResultOutput), nil + }).(GetAppTokenResultOutput) +} + +// A collection of arguments for invoking getAppToken. +type GetAppTokenOutputArgs struct { + // This is the ID of the GitHub App. + AppId pulumi.StringInput `pulumi:"appId"` + // This is the ID of the GitHub App installation. + InstallationId pulumi.StringInput `pulumi:"installationId"` + // This is the contents of the GitHub App private key PEM file. + PemFile pulumi.StringInput `pulumi:"pemFile"` +} + +func (GetAppTokenOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetAppTokenArgs)(nil)).Elem() +} + +// A collection of values returned by getAppToken. +type GetAppTokenResultOutput struct{ *pulumi.OutputState } + +func (GetAppTokenResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetAppTokenResult)(nil)).Elem() +} + +func (o GetAppTokenResultOutput) ToGetAppTokenResultOutput() GetAppTokenResultOutput { + return o +} + +func (o GetAppTokenResultOutput) ToGetAppTokenResultOutputWithContext(ctx context.Context) GetAppTokenResultOutput { + return o +} + +func (o GetAppTokenResultOutput) AppId() pulumi.StringOutput { + return o.ApplyT(func(v GetAppTokenResult) string { return v.AppId }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetAppTokenResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetAppTokenResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetAppTokenResultOutput) InstallationId() pulumi.StringOutput { + return o.ApplyT(func(v GetAppTokenResult) string { return v.InstallationId }).(pulumi.StringOutput) +} + +func (o GetAppTokenResultOutput) PemFile() pulumi.StringOutput { + return o.ApplyT(func(v GetAppTokenResult) string { return v.PemFile }).(pulumi.StringOutput) +} + +// The generated GitHub APP JWT. +func (o GetAppTokenResultOutput) Token() pulumi.StringOutput { + return o.ApplyT(func(v GetAppTokenResult) string { return v.Token }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetAppTokenResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getBranch.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getBranch.go new file mode 100644 index 000000000..19c74591c --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getBranch.go @@ -0,0 +1,140 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a repository branch. +// +// ## Example Usage +// +// ```go +// 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.GetBranch(ctx, &github.LookupBranchArgs{ +// Repository: "example", +// Branch: "development", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupBranch(ctx *pulumi.Context, args *LookupBranchArgs, opts ...pulumi.InvokeOption) (*LookupBranchResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupBranchResult + err := ctx.Invoke("github:index/getBranch:getBranch", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getBranch. +type LookupBranchArgs struct { + // The repository branch to retrieve. + Branch string `pulumi:"branch"` + // The GitHub repository name. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getBranch. +type LookupBranchResult struct { + Branch string `pulumi:"branch"` + // An etag representing the Branch object. + Etag string `pulumi:"etag"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // A string representing a branch reference, in the form of `refs/heads/`. + Ref string `pulumi:"ref"` + Repository string `pulumi:"repository"` + // A string storing the reference's `HEAD` commit's SHA1. + Sha string `pulumi:"sha"` +} + +func LookupBranchOutput(ctx *pulumi.Context, args LookupBranchOutputArgs, opts ...pulumi.InvokeOption) LookupBranchResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupBranchResultOutput, error) { + args := v.(LookupBranchArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getBranch:getBranch", args, LookupBranchResultOutput{}, options).(LookupBranchResultOutput), nil + }).(LookupBranchResultOutput) +} + +// A collection of arguments for invoking getBranch. +type LookupBranchOutputArgs struct { + // The repository branch to retrieve. + Branch pulumi.StringInput `pulumi:"branch"` + // The GitHub repository name. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (LookupBranchOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupBranchArgs)(nil)).Elem() +} + +// A collection of values returned by getBranch. +type LookupBranchResultOutput struct{ *pulumi.OutputState } + +func (LookupBranchResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupBranchResult)(nil)).Elem() +} + +func (o LookupBranchResultOutput) ToLookupBranchResultOutput() LookupBranchResultOutput { + return o +} + +func (o LookupBranchResultOutput) ToLookupBranchResultOutputWithContext(ctx context.Context) LookupBranchResultOutput { + return o +} + +func (o LookupBranchResultOutput) Branch() pulumi.StringOutput { + return o.ApplyT(func(v LookupBranchResult) string { return v.Branch }).(pulumi.StringOutput) +} + +// An etag representing the Branch object. +func (o LookupBranchResultOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v LookupBranchResult) string { return v.Etag }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupBranchResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupBranchResult) string { return v.Id }).(pulumi.StringOutput) +} + +// A string representing a branch reference, in the form of `refs/heads/`. +func (o LookupBranchResultOutput) Ref() pulumi.StringOutput { + return o.ApplyT(func(v LookupBranchResult) string { return v.Ref }).(pulumi.StringOutput) +} + +func (o LookupBranchResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v LookupBranchResult) string { return v.Repository }).(pulumi.StringOutput) +} + +// A string storing the reference's `HEAD` commit's SHA1. +func (o LookupBranchResultOutput) Sha() pulumi.StringOutput { + return o.ApplyT(func(v LookupBranchResult) string { return v.Sha }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupBranchResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getBranchProtectionRules.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getBranchProtectionRules.go new file mode 100644 index 000000000..ed06c9151 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getBranchProtectionRules.go @@ -0,0 +1,116 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve a list of repository branch protection rules. +// +// ## Example Usage +// +// ```go +// 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.GetBranchProtectionRules(ctx, &github.GetBranchProtectionRulesArgs{ +// Repository: "example", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetBranchProtectionRules(ctx *pulumi.Context, args *GetBranchProtectionRulesArgs, opts ...pulumi.InvokeOption) (*GetBranchProtectionRulesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetBranchProtectionRulesResult + err := ctx.Invoke("github:index/getBranchProtectionRules:getBranchProtectionRules", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getBranchProtectionRules. +type GetBranchProtectionRulesArgs struct { + // The GitHub repository name. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getBranchProtectionRules. +type GetBranchProtectionRulesResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Repository string `pulumi:"repository"` + // Collection of Branch Protection Rules. Each of the results conforms to the following scheme: + Rules []GetBranchProtectionRulesRule `pulumi:"rules"` +} + +func GetBranchProtectionRulesOutput(ctx *pulumi.Context, args GetBranchProtectionRulesOutputArgs, opts ...pulumi.InvokeOption) GetBranchProtectionRulesResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetBranchProtectionRulesResultOutput, error) { + args := v.(GetBranchProtectionRulesArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getBranchProtectionRules:getBranchProtectionRules", args, GetBranchProtectionRulesResultOutput{}, options).(GetBranchProtectionRulesResultOutput), nil + }).(GetBranchProtectionRulesResultOutput) +} + +// A collection of arguments for invoking getBranchProtectionRules. +type GetBranchProtectionRulesOutputArgs struct { + // The GitHub repository name. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetBranchProtectionRulesOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetBranchProtectionRulesArgs)(nil)).Elem() +} + +// A collection of values returned by getBranchProtectionRules. +type GetBranchProtectionRulesResultOutput struct{ *pulumi.OutputState } + +func (GetBranchProtectionRulesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetBranchProtectionRulesResult)(nil)).Elem() +} + +func (o GetBranchProtectionRulesResultOutput) ToGetBranchProtectionRulesResultOutput() GetBranchProtectionRulesResultOutput { + return o +} + +func (o GetBranchProtectionRulesResultOutput) ToGetBranchProtectionRulesResultOutputWithContext(ctx context.Context) GetBranchProtectionRulesResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetBranchProtectionRulesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetBranchProtectionRulesResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetBranchProtectionRulesResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetBranchProtectionRulesResult) string { return v.Repository }).(pulumi.StringOutput) +} + +// Collection of Branch Protection Rules. Each of the results conforms to the following scheme: +func (o GetBranchProtectionRulesResultOutput) Rules() GetBranchProtectionRulesRuleArrayOutput { + return o.ApplyT(func(v GetBranchProtectionRulesResult) []GetBranchProtectionRulesRule { return v.Rules }).(GetBranchProtectionRulesRuleArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetBranchProtectionRulesResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesOrganizationPublicKey.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesOrganizationPublicKey.go new file mode 100644 index 000000000..ae2b1c9b4 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesOrganizationPublicKey.go @@ -0,0 +1,99 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a GitHub Codespaces Organization public key. This data source is required to be used with other GitHub secrets interactions. +// Note that the provider `token` must have admin rights to an organization to retrieve it's Codespaces public key. +// +// ## Example Usage +// +// ```go +// 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.GetCodespacesOrganizationPublicKey(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetCodespacesOrganizationPublicKey(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetCodespacesOrganizationPublicKeyResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetCodespacesOrganizationPublicKeyResult + err := ctx.Invoke("github:index/getCodespacesOrganizationPublicKey:getCodespacesOrganizationPublicKey", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getCodespacesOrganizationPublicKey. +type GetCodespacesOrganizationPublicKeyResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Actual key retrieved. + Key string `pulumi:"key"` + // ID of the key that has been retrieved. + KeyId string `pulumi:"keyId"` +} + +func GetCodespacesOrganizationPublicKeyOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetCodespacesOrganizationPublicKeyResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetCodespacesOrganizationPublicKeyResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getCodespacesOrganizationPublicKey:getCodespacesOrganizationPublicKey", nil, GetCodespacesOrganizationPublicKeyResultOutput{}, options).(GetCodespacesOrganizationPublicKeyResultOutput), nil + }).(GetCodespacesOrganizationPublicKeyResultOutput) +} + +// A collection of values returned by getCodespacesOrganizationPublicKey. +type GetCodespacesOrganizationPublicKeyResultOutput struct{ *pulumi.OutputState } + +func (GetCodespacesOrganizationPublicKeyResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetCodespacesOrganizationPublicKeyResult)(nil)).Elem() +} + +func (o GetCodespacesOrganizationPublicKeyResultOutput) ToGetCodespacesOrganizationPublicKeyResultOutput() GetCodespacesOrganizationPublicKeyResultOutput { + return o +} + +func (o GetCodespacesOrganizationPublicKeyResultOutput) ToGetCodespacesOrganizationPublicKeyResultOutputWithContext(ctx context.Context) GetCodespacesOrganizationPublicKeyResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetCodespacesOrganizationPublicKeyResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesOrganizationPublicKeyResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Actual key retrieved. +func (o GetCodespacesOrganizationPublicKeyResultOutput) Key() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesOrganizationPublicKeyResult) string { return v.Key }).(pulumi.StringOutput) +} + +// ID of the key that has been retrieved. +func (o GetCodespacesOrganizationPublicKeyResultOutput) KeyId() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesOrganizationPublicKeyResult) string { return v.KeyId }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetCodespacesOrganizationPublicKeyResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesOrganizationSecrets.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesOrganizationSecrets.go new file mode 100644 index 000000000..a7a0cfa47 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesOrganizationSecrets.go @@ -0,0 +1,93 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the list of codespaces secrets of the organization. +// +// ## Example Usage +// +// ```go +// 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.GetCodespacesOrganizationSecrets(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetCodespacesOrganizationSecrets(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetCodespacesOrganizationSecretsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetCodespacesOrganizationSecretsResult + err := ctx.Invoke("github:index/getCodespacesOrganizationSecrets:getCodespacesOrganizationSecrets", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getCodespacesOrganizationSecrets. +type GetCodespacesOrganizationSecretsResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // list of secrets for the repository + Secrets []GetCodespacesOrganizationSecretsSecret `pulumi:"secrets"` +} + +func GetCodespacesOrganizationSecretsOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetCodespacesOrganizationSecretsResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetCodespacesOrganizationSecretsResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getCodespacesOrganizationSecrets:getCodespacesOrganizationSecrets", nil, GetCodespacesOrganizationSecretsResultOutput{}, options).(GetCodespacesOrganizationSecretsResultOutput), nil + }).(GetCodespacesOrganizationSecretsResultOutput) +} + +// A collection of values returned by getCodespacesOrganizationSecrets. +type GetCodespacesOrganizationSecretsResultOutput struct{ *pulumi.OutputState } + +func (GetCodespacesOrganizationSecretsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetCodespacesOrganizationSecretsResult)(nil)).Elem() +} + +func (o GetCodespacesOrganizationSecretsResultOutput) ToGetCodespacesOrganizationSecretsResultOutput() GetCodespacesOrganizationSecretsResultOutput { + return o +} + +func (o GetCodespacesOrganizationSecretsResultOutput) ToGetCodespacesOrganizationSecretsResultOutputWithContext(ctx context.Context) GetCodespacesOrganizationSecretsResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetCodespacesOrganizationSecretsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesOrganizationSecretsResult) string { return v.Id }).(pulumi.StringOutput) +} + +// list of secrets for the repository +func (o GetCodespacesOrganizationSecretsResultOutput) Secrets() GetCodespacesOrganizationSecretsSecretArrayOutput { + return o.ApplyT(func(v GetCodespacesOrganizationSecretsResult) []GetCodespacesOrganizationSecretsSecret { + return v.Secrets + }).(GetCodespacesOrganizationSecretsSecretArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetCodespacesOrganizationSecretsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesPublicKey.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesPublicKey.go new file mode 100644 index 000000000..9a7a8a9e3 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesPublicKey.go @@ -0,0 +1,124 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a GitHub Codespaces public key. This data source is required to be used with other GitHub secrets interactions. +// Note that the provider `token` must have admin rights to a repository to retrieve it's Codespaces public key. +// +// ## Example Usage +// +// ```go +// 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.GetCodespacesPublicKey(ctx, &github.GetCodespacesPublicKeyArgs{ +// Repository: "example_repo", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetCodespacesPublicKey(ctx *pulumi.Context, args *GetCodespacesPublicKeyArgs, opts ...pulumi.InvokeOption) (*GetCodespacesPublicKeyResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetCodespacesPublicKeyResult + err := ctx.Invoke("github:index/getCodespacesPublicKey:getCodespacesPublicKey", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getCodespacesPublicKey. +type GetCodespacesPublicKeyArgs struct { + // Name of the repository to get public key from. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getCodespacesPublicKey. +type GetCodespacesPublicKeyResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Actual key retrieved. + Key string `pulumi:"key"` + // ID of the key that has been retrieved. + KeyId string `pulumi:"keyId"` + Repository string `pulumi:"repository"` +} + +func GetCodespacesPublicKeyOutput(ctx *pulumi.Context, args GetCodespacesPublicKeyOutputArgs, opts ...pulumi.InvokeOption) GetCodespacesPublicKeyResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetCodespacesPublicKeyResultOutput, error) { + args := v.(GetCodespacesPublicKeyArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getCodespacesPublicKey:getCodespacesPublicKey", args, GetCodespacesPublicKeyResultOutput{}, options).(GetCodespacesPublicKeyResultOutput), nil + }).(GetCodespacesPublicKeyResultOutput) +} + +// A collection of arguments for invoking getCodespacesPublicKey. +type GetCodespacesPublicKeyOutputArgs struct { + // Name of the repository to get public key from. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetCodespacesPublicKeyOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetCodespacesPublicKeyArgs)(nil)).Elem() +} + +// A collection of values returned by getCodespacesPublicKey. +type GetCodespacesPublicKeyResultOutput struct{ *pulumi.OutputState } + +func (GetCodespacesPublicKeyResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetCodespacesPublicKeyResult)(nil)).Elem() +} + +func (o GetCodespacesPublicKeyResultOutput) ToGetCodespacesPublicKeyResultOutput() GetCodespacesPublicKeyResultOutput { + return o +} + +func (o GetCodespacesPublicKeyResultOutput) ToGetCodespacesPublicKeyResultOutputWithContext(ctx context.Context) GetCodespacesPublicKeyResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetCodespacesPublicKeyResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesPublicKeyResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Actual key retrieved. +func (o GetCodespacesPublicKeyResultOutput) Key() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesPublicKeyResult) string { return v.Key }).(pulumi.StringOutput) +} + +// ID of the key that has been retrieved. +func (o GetCodespacesPublicKeyResultOutput) KeyId() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesPublicKeyResult) string { return v.KeyId }).(pulumi.StringOutput) +} + +func (o GetCodespacesPublicKeyResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesPublicKeyResult) string { return v.Repository }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetCodespacesPublicKeyResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesSecrets.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesSecrets.go new file mode 100644 index 000000000..a030011fc --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesSecrets.go @@ -0,0 +1,133 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the list of codespaces secrets for a GitHub repository. +// +// ## Example Usage +// +// ```go +// 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.GetCodespacesSecrets(ctx, &github.GetCodespacesSecretsArgs{ +// Name: pulumi.StringRef("example_repository"), +// }, nil) +// if err != nil { +// return err +// } +// _, err = github.GetCodespacesSecrets(ctx, &github.GetCodespacesSecretsArgs{ +// FullName: pulumi.StringRef("org/example_repository"), +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetCodespacesSecrets(ctx *pulumi.Context, args *GetCodespacesSecretsArgs, opts ...pulumi.InvokeOption) (*GetCodespacesSecretsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetCodespacesSecretsResult + err := ctx.Invoke("github:index/getCodespacesSecrets:getCodespacesSecrets", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getCodespacesSecrets. +type GetCodespacesSecretsArgs struct { + // Full name of the repository (in `org/name` format). + FullName *string `pulumi:"fullName"` + // The name of the repository. + Name *string `pulumi:"name"` +} + +// A collection of values returned by getCodespacesSecrets. +type GetCodespacesSecretsResult struct { + FullName string `pulumi:"fullName"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Secret name + Name string `pulumi:"name"` + // list of codespaces secrets for the repository + Secrets []GetCodespacesSecretsSecret `pulumi:"secrets"` +} + +func GetCodespacesSecretsOutput(ctx *pulumi.Context, args GetCodespacesSecretsOutputArgs, opts ...pulumi.InvokeOption) GetCodespacesSecretsResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetCodespacesSecretsResultOutput, error) { + args := v.(GetCodespacesSecretsArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getCodespacesSecrets:getCodespacesSecrets", args, GetCodespacesSecretsResultOutput{}, options).(GetCodespacesSecretsResultOutput), nil + }).(GetCodespacesSecretsResultOutput) +} + +// A collection of arguments for invoking getCodespacesSecrets. +type GetCodespacesSecretsOutputArgs struct { + // Full name of the repository (in `org/name` format). + FullName pulumi.StringPtrInput `pulumi:"fullName"` + // The name of the repository. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (GetCodespacesSecretsOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetCodespacesSecretsArgs)(nil)).Elem() +} + +// A collection of values returned by getCodespacesSecrets. +type GetCodespacesSecretsResultOutput struct{ *pulumi.OutputState } + +func (GetCodespacesSecretsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetCodespacesSecretsResult)(nil)).Elem() +} + +func (o GetCodespacesSecretsResultOutput) ToGetCodespacesSecretsResultOutput() GetCodespacesSecretsResultOutput { + return o +} + +func (o GetCodespacesSecretsResultOutput) ToGetCodespacesSecretsResultOutputWithContext(ctx context.Context) GetCodespacesSecretsResultOutput { + return o +} + +func (o GetCodespacesSecretsResultOutput) FullName() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesSecretsResult) string { return v.FullName }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetCodespacesSecretsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesSecretsResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Secret name +func (o GetCodespacesSecretsResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesSecretsResult) string { return v.Name }).(pulumi.StringOutput) +} + +// list of codespaces secrets for the repository +func (o GetCodespacesSecretsResultOutput) Secrets() GetCodespacesSecretsSecretArrayOutput { + return o.ApplyT(func(v GetCodespacesSecretsResult) []GetCodespacesSecretsSecret { return v.Secrets }).(GetCodespacesSecretsSecretArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetCodespacesSecretsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesUserPublicKey.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesUserPublicKey.go new file mode 100644 index 000000000..7141d786b --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesUserPublicKey.go @@ -0,0 +1,99 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a GitHub Codespaces User public key. This data source is required to be used with other GitHub secrets interactions. +// Note that the provider `token` must have admin rights to an user to retrieve it's Codespaces public key. +// +// ## Example Usage +// +// ```go +// 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.GetCodespacesUserPublicKey(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetCodespacesUserPublicKey(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetCodespacesUserPublicKeyResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetCodespacesUserPublicKeyResult + err := ctx.Invoke("github:index/getCodespacesUserPublicKey:getCodespacesUserPublicKey", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getCodespacesUserPublicKey. +type GetCodespacesUserPublicKeyResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Actual key retrieved. + Key string `pulumi:"key"` + // ID of the key that has been retrieved. + KeyId string `pulumi:"keyId"` +} + +func GetCodespacesUserPublicKeyOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetCodespacesUserPublicKeyResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetCodespacesUserPublicKeyResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getCodespacesUserPublicKey:getCodespacesUserPublicKey", nil, GetCodespacesUserPublicKeyResultOutput{}, options).(GetCodespacesUserPublicKeyResultOutput), nil + }).(GetCodespacesUserPublicKeyResultOutput) +} + +// A collection of values returned by getCodespacesUserPublicKey. +type GetCodespacesUserPublicKeyResultOutput struct{ *pulumi.OutputState } + +func (GetCodespacesUserPublicKeyResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetCodespacesUserPublicKeyResult)(nil)).Elem() +} + +func (o GetCodespacesUserPublicKeyResultOutput) ToGetCodespacesUserPublicKeyResultOutput() GetCodespacesUserPublicKeyResultOutput { + return o +} + +func (o GetCodespacesUserPublicKeyResultOutput) ToGetCodespacesUserPublicKeyResultOutputWithContext(ctx context.Context) GetCodespacesUserPublicKeyResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetCodespacesUserPublicKeyResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesUserPublicKeyResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Actual key retrieved. +func (o GetCodespacesUserPublicKeyResultOutput) Key() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesUserPublicKeyResult) string { return v.Key }).(pulumi.StringOutput) +} + +// ID of the key that has been retrieved. +func (o GetCodespacesUserPublicKeyResultOutput) KeyId() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesUserPublicKeyResult) string { return v.KeyId }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetCodespacesUserPublicKeyResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesUserSecrets.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesUserSecrets.go new file mode 100644 index 000000000..f1c536c49 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCodespacesUserSecrets.go @@ -0,0 +1,91 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the list of codespaces secrets of the user. +// +// ## Example Usage +// +// ```go +// 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.GetCodespacesUserSecrets(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetCodespacesUserSecrets(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetCodespacesUserSecretsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetCodespacesUserSecretsResult + err := ctx.Invoke("github:index/getCodespacesUserSecrets:getCodespacesUserSecrets", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getCodespacesUserSecrets. +type GetCodespacesUserSecretsResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // list of secrets for the repository + Secrets []GetCodespacesUserSecretsSecret `pulumi:"secrets"` +} + +func GetCodespacesUserSecretsOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetCodespacesUserSecretsResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetCodespacesUserSecretsResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getCodespacesUserSecrets:getCodespacesUserSecrets", nil, GetCodespacesUserSecretsResultOutput{}, options).(GetCodespacesUserSecretsResultOutput), nil + }).(GetCodespacesUserSecretsResultOutput) +} + +// A collection of values returned by getCodespacesUserSecrets. +type GetCodespacesUserSecretsResultOutput struct{ *pulumi.OutputState } + +func (GetCodespacesUserSecretsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetCodespacesUserSecretsResult)(nil)).Elem() +} + +func (o GetCodespacesUserSecretsResultOutput) ToGetCodespacesUserSecretsResultOutput() GetCodespacesUserSecretsResultOutput { + return o +} + +func (o GetCodespacesUserSecretsResultOutput) ToGetCodespacesUserSecretsResultOutputWithContext(ctx context.Context) GetCodespacesUserSecretsResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetCodespacesUserSecretsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesUserSecretsResult) string { return v.Id }).(pulumi.StringOutput) +} + +// list of secrets for the repository +func (o GetCodespacesUserSecretsResultOutput) Secrets() GetCodespacesUserSecretsSecretArrayOutput { + return o.ApplyT(func(v GetCodespacesUserSecretsResult) []GetCodespacesUserSecretsSecret { return v.Secrets }).(GetCodespacesUserSecretsSecretArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetCodespacesUserSecretsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCollaborators.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCollaborators.go new file mode 100644 index 000000000..c1bf80732 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getCollaborators.go @@ -0,0 +1,146 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the collaborators for a given repository. +// +// ## Example Usage +// +// ```go +// 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.GetCollaborators(ctx, &github.GetCollaboratorsArgs{ +// Owner: "example_owner", +// Repository: "example_repository", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetCollaborators(ctx *pulumi.Context, args *GetCollaboratorsArgs, opts ...pulumi.InvokeOption) (*GetCollaboratorsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetCollaboratorsResult + err := ctx.Invoke("github:index/getCollaborators:getCollaborators", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getCollaborators. +type GetCollaboratorsArgs struct { + // Filter collaborators returned by their affiliation. Can be one of: `outside`, `direct`, `all`. Defaults to `all`. + Affiliation *string `pulumi:"affiliation"` + // The organization that owns the repository. + Owner string `pulumi:"owner"` + // Filter collaborators returned by their permission. Can be one of: `pull`, `triage`, `push`, `maintain`, `admin`. Defaults to not doing any filtering on permission. + Permission *string `pulumi:"permission"` + // The name of the repository. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getCollaborators. +type GetCollaboratorsResult struct { + Affiliation *string `pulumi:"affiliation"` + // An Array of GitHub collaborators. Each `collaborator` block consists of the fields documented below. + Collaborators []GetCollaboratorsCollaborator `pulumi:"collaborators"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Owner string `pulumi:"owner"` + // The permission of the collaborator. + Permission *string `pulumi:"permission"` + Repository string `pulumi:"repository"` +} + +func GetCollaboratorsOutput(ctx *pulumi.Context, args GetCollaboratorsOutputArgs, opts ...pulumi.InvokeOption) GetCollaboratorsResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetCollaboratorsResultOutput, error) { + args := v.(GetCollaboratorsArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getCollaborators:getCollaborators", args, GetCollaboratorsResultOutput{}, options).(GetCollaboratorsResultOutput), nil + }).(GetCollaboratorsResultOutput) +} + +// A collection of arguments for invoking getCollaborators. +type GetCollaboratorsOutputArgs struct { + // Filter collaborators returned by their affiliation. Can be one of: `outside`, `direct`, `all`. Defaults to `all`. + Affiliation pulumi.StringPtrInput `pulumi:"affiliation"` + // The organization that owns the repository. + Owner pulumi.StringInput `pulumi:"owner"` + // Filter collaborators returned by their permission. Can be one of: `pull`, `triage`, `push`, `maintain`, `admin`. Defaults to not doing any filtering on permission. + Permission pulumi.StringPtrInput `pulumi:"permission"` + // The name of the repository. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetCollaboratorsOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetCollaboratorsArgs)(nil)).Elem() +} + +// A collection of values returned by getCollaborators. +type GetCollaboratorsResultOutput struct{ *pulumi.OutputState } + +func (GetCollaboratorsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetCollaboratorsResult)(nil)).Elem() +} + +func (o GetCollaboratorsResultOutput) ToGetCollaboratorsResultOutput() GetCollaboratorsResultOutput { + return o +} + +func (o GetCollaboratorsResultOutput) ToGetCollaboratorsResultOutputWithContext(ctx context.Context) GetCollaboratorsResultOutput { + return o +} + +func (o GetCollaboratorsResultOutput) Affiliation() pulumi.StringPtrOutput { + return o.ApplyT(func(v GetCollaboratorsResult) *string { return v.Affiliation }).(pulumi.StringPtrOutput) +} + +// An Array of GitHub collaborators. Each `collaborator` block consists of the fields documented below. +func (o GetCollaboratorsResultOutput) Collaborators() GetCollaboratorsCollaboratorArrayOutput { + return o.ApplyT(func(v GetCollaboratorsResult) []GetCollaboratorsCollaborator { return v.Collaborators }).(GetCollaboratorsCollaboratorArrayOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetCollaboratorsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetCollaboratorsResultOutput) Owner() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsResult) string { return v.Owner }).(pulumi.StringOutput) +} + +// The permission of the collaborator. +func (o GetCollaboratorsResultOutput) Permission() pulumi.StringPtrOutput { + return o.ApplyT(func(v GetCollaboratorsResult) *string { return v.Permission }).(pulumi.StringPtrOutput) +} + +func (o GetCollaboratorsResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsResult) string { return v.Repository }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetCollaboratorsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getDependabotOrganizationPublicKey.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getDependabotOrganizationPublicKey.go new file mode 100644 index 000000000..b7fa6ce58 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getDependabotOrganizationPublicKey.go @@ -0,0 +1,99 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a GitHub Dependabot Organization public key. This data source is required to be used with other GitHub secrets interactions. +// Note that the provider `token` must have admin rights to an organization to retrieve it's Dependabot public key. +// +// ## Example Usage +// +// ```go +// 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.GetDependabotOrganizationPublicKey(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetDependabotOrganizationPublicKey(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetDependabotOrganizationPublicKeyResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetDependabotOrganizationPublicKeyResult + err := ctx.Invoke("github:index/getDependabotOrganizationPublicKey:getDependabotOrganizationPublicKey", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getDependabotOrganizationPublicKey. +type GetDependabotOrganizationPublicKeyResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Actual key retrieved. + Key string `pulumi:"key"` + // ID of the key that has been retrieved. + KeyId string `pulumi:"keyId"` +} + +func GetDependabotOrganizationPublicKeyOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetDependabotOrganizationPublicKeyResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetDependabotOrganizationPublicKeyResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getDependabotOrganizationPublicKey:getDependabotOrganizationPublicKey", nil, GetDependabotOrganizationPublicKeyResultOutput{}, options).(GetDependabotOrganizationPublicKeyResultOutput), nil + }).(GetDependabotOrganizationPublicKeyResultOutput) +} + +// A collection of values returned by getDependabotOrganizationPublicKey. +type GetDependabotOrganizationPublicKeyResultOutput struct{ *pulumi.OutputState } + +func (GetDependabotOrganizationPublicKeyResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetDependabotOrganizationPublicKeyResult)(nil)).Elem() +} + +func (o GetDependabotOrganizationPublicKeyResultOutput) ToGetDependabotOrganizationPublicKeyResultOutput() GetDependabotOrganizationPublicKeyResultOutput { + return o +} + +func (o GetDependabotOrganizationPublicKeyResultOutput) ToGetDependabotOrganizationPublicKeyResultOutputWithContext(ctx context.Context) GetDependabotOrganizationPublicKeyResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetDependabotOrganizationPublicKeyResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotOrganizationPublicKeyResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Actual key retrieved. +func (o GetDependabotOrganizationPublicKeyResultOutput) Key() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotOrganizationPublicKeyResult) string { return v.Key }).(pulumi.StringOutput) +} + +// ID of the key that has been retrieved. +func (o GetDependabotOrganizationPublicKeyResultOutput) KeyId() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotOrganizationPublicKeyResult) string { return v.KeyId }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetDependabotOrganizationPublicKeyResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getDependabotOrganizationSecrets.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getDependabotOrganizationSecrets.go new file mode 100644 index 000000000..8ae232672 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getDependabotOrganizationSecrets.go @@ -0,0 +1,93 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the list of dependabot secrets of the organization. +// +// ## Example Usage +// +// ```go +// 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.GetDependabotOrganizationSecrets(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetDependabotOrganizationSecrets(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetDependabotOrganizationSecretsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetDependabotOrganizationSecretsResult + err := ctx.Invoke("github:index/getDependabotOrganizationSecrets:getDependabotOrganizationSecrets", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getDependabotOrganizationSecrets. +type GetDependabotOrganizationSecretsResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // list of secrets for the repository + Secrets []GetDependabotOrganizationSecretsSecret `pulumi:"secrets"` +} + +func GetDependabotOrganizationSecretsOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetDependabotOrganizationSecretsResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetDependabotOrganizationSecretsResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getDependabotOrganizationSecrets:getDependabotOrganizationSecrets", nil, GetDependabotOrganizationSecretsResultOutput{}, options).(GetDependabotOrganizationSecretsResultOutput), nil + }).(GetDependabotOrganizationSecretsResultOutput) +} + +// A collection of values returned by getDependabotOrganizationSecrets. +type GetDependabotOrganizationSecretsResultOutput struct{ *pulumi.OutputState } + +func (GetDependabotOrganizationSecretsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetDependabotOrganizationSecretsResult)(nil)).Elem() +} + +func (o GetDependabotOrganizationSecretsResultOutput) ToGetDependabotOrganizationSecretsResultOutput() GetDependabotOrganizationSecretsResultOutput { + return o +} + +func (o GetDependabotOrganizationSecretsResultOutput) ToGetDependabotOrganizationSecretsResultOutputWithContext(ctx context.Context) GetDependabotOrganizationSecretsResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetDependabotOrganizationSecretsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotOrganizationSecretsResult) string { return v.Id }).(pulumi.StringOutput) +} + +// list of secrets for the repository +func (o GetDependabotOrganizationSecretsResultOutput) Secrets() GetDependabotOrganizationSecretsSecretArrayOutput { + return o.ApplyT(func(v GetDependabotOrganizationSecretsResult) []GetDependabotOrganizationSecretsSecret { + return v.Secrets + }).(GetDependabotOrganizationSecretsSecretArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetDependabotOrganizationSecretsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getDependabotPublicKey.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getDependabotPublicKey.go new file mode 100644 index 000000000..a00655288 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getDependabotPublicKey.go @@ -0,0 +1,124 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a GitHub Dependabot public key. This data source is required to be used with other GitHub secrets interactions. +// Note that the provider `token` must have admin rights to a repository to retrieve it's Dependabot public key. +// +// ## Example Usage +// +// ```go +// 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.GetDependabotPublicKey(ctx, &github.GetDependabotPublicKeyArgs{ +// Repository: "example_repo", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetDependabotPublicKey(ctx *pulumi.Context, args *GetDependabotPublicKeyArgs, opts ...pulumi.InvokeOption) (*GetDependabotPublicKeyResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetDependabotPublicKeyResult + err := ctx.Invoke("github:index/getDependabotPublicKey:getDependabotPublicKey", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getDependabotPublicKey. +type GetDependabotPublicKeyArgs struct { + // Name of the repository to get public key from. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getDependabotPublicKey. +type GetDependabotPublicKeyResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Actual key retrieved. + Key string `pulumi:"key"` + // ID of the key that has been retrieved. + KeyId string `pulumi:"keyId"` + Repository string `pulumi:"repository"` +} + +func GetDependabotPublicKeyOutput(ctx *pulumi.Context, args GetDependabotPublicKeyOutputArgs, opts ...pulumi.InvokeOption) GetDependabotPublicKeyResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetDependabotPublicKeyResultOutput, error) { + args := v.(GetDependabotPublicKeyArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getDependabotPublicKey:getDependabotPublicKey", args, GetDependabotPublicKeyResultOutput{}, options).(GetDependabotPublicKeyResultOutput), nil + }).(GetDependabotPublicKeyResultOutput) +} + +// A collection of arguments for invoking getDependabotPublicKey. +type GetDependabotPublicKeyOutputArgs struct { + // Name of the repository to get public key from. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetDependabotPublicKeyOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetDependabotPublicKeyArgs)(nil)).Elem() +} + +// A collection of values returned by getDependabotPublicKey. +type GetDependabotPublicKeyResultOutput struct{ *pulumi.OutputState } + +func (GetDependabotPublicKeyResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetDependabotPublicKeyResult)(nil)).Elem() +} + +func (o GetDependabotPublicKeyResultOutput) ToGetDependabotPublicKeyResultOutput() GetDependabotPublicKeyResultOutput { + return o +} + +func (o GetDependabotPublicKeyResultOutput) ToGetDependabotPublicKeyResultOutputWithContext(ctx context.Context) GetDependabotPublicKeyResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetDependabotPublicKeyResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotPublicKeyResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Actual key retrieved. +func (o GetDependabotPublicKeyResultOutput) Key() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotPublicKeyResult) string { return v.Key }).(pulumi.StringOutput) +} + +// ID of the key that has been retrieved. +func (o GetDependabotPublicKeyResultOutput) KeyId() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotPublicKeyResult) string { return v.KeyId }).(pulumi.StringOutput) +} + +func (o GetDependabotPublicKeyResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotPublicKeyResult) string { return v.Repository }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetDependabotPublicKeyResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getDependabotSecrets.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getDependabotSecrets.go new file mode 100644 index 000000000..305c75b5b --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getDependabotSecrets.go @@ -0,0 +1,127 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the list of dependabot secrets for a GitHub repository. +// +// ## Example Usage +// +// ```go +// 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.GetDependabotSecrets(ctx, &github.GetDependabotSecretsArgs{ +// Name: pulumi.StringRef("example"), +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetDependabotSecrets(ctx *pulumi.Context, args *GetDependabotSecretsArgs, opts ...pulumi.InvokeOption) (*GetDependabotSecretsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetDependabotSecretsResult + err := ctx.Invoke("github:index/getDependabotSecrets:getDependabotSecrets", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getDependabotSecrets. +type GetDependabotSecretsArgs struct { + // Full name of the repository (in `org/name` format). + FullName *string `pulumi:"fullName"` + // The name of the repository. + Name *string `pulumi:"name"` +} + +// A collection of values returned by getDependabotSecrets. +type GetDependabotSecretsResult struct { + FullName string `pulumi:"fullName"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Secret name + Name string `pulumi:"name"` + // list of dependabot secrets for the repository + Secrets []GetDependabotSecretsSecret `pulumi:"secrets"` +} + +func GetDependabotSecretsOutput(ctx *pulumi.Context, args GetDependabotSecretsOutputArgs, opts ...pulumi.InvokeOption) GetDependabotSecretsResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetDependabotSecretsResultOutput, error) { + args := v.(GetDependabotSecretsArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getDependabotSecrets:getDependabotSecrets", args, GetDependabotSecretsResultOutput{}, options).(GetDependabotSecretsResultOutput), nil + }).(GetDependabotSecretsResultOutput) +} + +// A collection of arguments for invoking getDependabotSecrets. +type GetDependabotSecretsOutputArgs struct { + // Full name of the repository (in `org/name` format). + FullName pulumi.StringPtrInput `pulumi:"fullName"` + // The name of the repository. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (GetDependabotSecretsOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetDependabotSecretsArgs)(nil)).Elem() +} + +// A collection of values returned by getDependabotSecrets. +type GetDependabotSecretsResultOutput struct{ *pulumi.OutputState } + +func (GetDependabotSecretsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetDependabotSecretsResult)(nil)).Elem() +} + +func (o GetDependabotSecretsResultOutput) ToGetDependabotSecretsResultOutput() GetDependabotSecretsResultOutput { + return o +} + +func (o GetDependabotSecretsResultOutput) ToGetDependabotSecretsResultOutputWithContext(ctx context.Context) GetDependabotSecretsResultOutput { + return o +} + +func (o GetDependabotSecretsResultOutput) FullName() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotSecretsResult) string { return v.FullName }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetDependabotSecretsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotSecretsResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Secret name +func (o GetDependabotSecretsResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotSecretsResult) string { return v.Name }).(pulumi.StringOutput) +} + +// list of dependabot secrets for the repository +func (o GetDependabotSecretsResultOutput) Secrets() GetDependabotSecretsSecretArrayOutput { + return o.ApplyT(func(v GetDependabotSecretsResult) []GetDependabotSecretsSecret { return v.Secrets }).(GetDependabotSecretsSecretArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetDependabotSecretsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getEnterprise.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getEnterprise.go new file mode 100644 index 000000000..a2e817053 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getEnterprise.go @@ -0,0 +1,146 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve basic information about a GitHub enterprise. +// +// ## Example Usage +// +// ```go +// 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.GetEnterprise(ctx, &github.GetEnterpriseArgs{ +// Slug: "example-co", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetEnterprise(ctx *pulumi.Context, args *GetEnterpriseArgs, opts ...pulumi.InvokeOption) (*GetEnterpriseResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetEnterpriseResult + err := ctx.Invoke("github:index/getEnterprise:getEnterprise", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getEnterprise. +type GetEnterpriseArgs struct { + // The URL slug identifying the enterprise. + Slug string `pulumi:"slug"` +} + +// A collection of values returned by getEnterprise. +type GetEnterpriseResult struct { + // The time the enterprise was created. + CreatedAt string `pulumi:"createdAt"` + // The database ID of the enterprise. + DatabaseId int `pulumi:"databaseId"` + // The description of the enterprise. + Description string `pulumi:"description"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The name of the enterprise. + Name string `pulumi:"name"` + // The URL slug identifying the enterprise. + Slug string `pulumi:"slug"` + // The url for the enterprise. + Url string `pulumi:"url"` +} + +func GetEnterpriseOutput(ctx *pulumi.Context, args GetEnterpriseOutputArgs, opts ...pulumi.InvokeOption) GetEnterpriseResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetEnterpriseResultOutput, error) { + args := v.(GetEnterpriseArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getEnterprise:getEnterprise", args, GetEnterpriseResultOutput{}, options).(GetEnterpriseResultOutput), nil + }).(GetEnterpriseResultOutput) +} + +// A collection of arguments for invoking getEnterprise. +type GetEnterpriseOutputArgs struct { + // The URL slug identifying the enterprise. + Slug pulumi.StringInput `pulumi:"slug"` +} + +func (GetEnterpriseOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetEnterpriseArgs)(nil)).Elem() +} + +// A collection of values returned by getEnterprise. +type GetEnterpriseResultOutput struct{ *pulumi.OutputState } + +func (GetEnterpriseResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetEnterpriseResult)(nil)).Elem() +} + +func (o GetEnterpriseResultOutput) ToGetEnterpriseResultOutput() GetEnterpriseResultOutput { + return o +} + +func (o GetEnterpriseResultOutput) ToGetEnterpriseResultOutputWithContext(ctx context.Context) GetEnterpriseResultOutput { + return o +} + +// The time the enterprise was created. +func (o GetEnterpriseResultOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetEnterpriseResult) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// The database ID of the enterprise. +func (o GetEnterpriseResultOutput) DatabaseId() pulumi.IntOutput { + return o.ApplyT(func(v GetEnterpriseResult) int { return v.DatabaseId }).(pulumi.IntOutput) +} + +// The description of the enterprise. +func (o GetEnterpriseResultOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v GetEnterpriseResult) string { return v.Description }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetEnterpriseResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetEnterpriseResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The name of the enterprise. +func (o GetEnterpriseResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetEnterpriseResult) string { return v.Name }).(pulumi.StringOutput) +} + +// The URL slug identifying the enterprise. +func (o GetEnterpriseResultOutput) Slug() pulumi.StringOutput { + return o.ApplyT(func(v GetEnterpriseResult) string { return v.Slug }).(pulumi.StringOutput) +} + +// The url for the enterprise. +func (o GetEnterpriseResultOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v GetEnterpriseResult) string { return v.Url }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetEnterpriseResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getExternalGroups.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getExternalGroups.go new file mode 100644 index 000000000..5bc9058ae --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getExternalGroups.go @@ -0,0 +1,93 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve external groups belonging to an organization. +// +// ## Example Usage +// +// ```go +// 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 { +// exampleExternalGroups, err := github.GetExternalGroups(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// localGroups := exampleExternalGroups +// ctx.Export("groups", localGroups) +// return nil +// }) +// } +// +// ``` +func GetExternalGroups(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetExternalGroupsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetExternalGroupsResult + err := ctx.Invoke("github:index/getExternalGroups:getExternalGroups", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getExternalGroups. +type GetExternalGroupsResult struct { + // an array of external groups belonging to the organization. Each group consists of the fields documented below. + ExternalGroups []GetExternalGroupsExternalGroup `pulumi:"externalGroups"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` +} + +func GetExternalGroupsOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetExternalGroupsResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetExternalGroupsResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getExternalGroups:getExternalGroups", nil, GetExternalGroupsResultOutput{}, options).(GetExternalGroupsResultOutput), nil + }).(GetExternalGroupsResultOutput) +} + +// A collection of values returned by getExternalGroups. +type GetExternalGroupsResultOutput struct{ *pulumi.OutputState } + +func (GetExternalGroupsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetExternalGroupsResult)(nil)).Elem() +} + +func (o GetExternalGroupsResultOutput) ToGetExternalGroupsResultOutput() GetExternalGroupsResultOutput { + return o +} + +func (o GetExternalGroupsResultOutput) ToGetExternalGroupsResultOutputWithContext(ctx context.Context) GetExternalGroupsResultOutput { + return o +} + +// an array of external groups belonging to the organization. Each group consists of the fields documented below. +func (o GetExternalGroupsResultOutput) ExternalGroups() GetExternalGroupsExternalGroupArrayOutput { + return o.ApplyT(func(v GetExternalGroupsResult) []GetExternalGroupsExternalGroup { return v.ExternalGroups }).(GetExternalGroupsExternalGroupArrayOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetExternalGroupsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetExternalGroupsResult) string { return v.Id }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetExternalGroupsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getGithubApp.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getGithubApp.go new file mode 100644 index 000000000..89d34d7c3 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getGithubApp.go @@ -0,0 +1,130 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about an app. +// +// ## Example Usage +// +// ```go +// 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.GetGithubApp(ctx, &github.GetGithubAppArgs{ +// Slug: "foobar", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetGithubApp(ctx *pulumi.Context, args *GetGithubAppArgs, opts ...pulumi.InvokeOption) (*GetGithubAppResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetGithubAppResult + err := ctx.Invoke("github:index/getGithubApp:getGithubApp", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getGithubApp. +type GetGithubAppArgs struct { + // The URL-friendly name of your GitHub App. + Slug string `pulumi:"slug"` +} + +// A collection of values returned by getGithubApp. +type GetGithubAppResult struct { + // The app's description. + Description string `pulumi:"description"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The app's full name. + Name string `pulumi:"name"` + // The Node ID of the app. + NodeId string `pulumi:"nodeId"` + Slug string `pulumi:"slug"` +} + +func GetGithubAppOutput(ctx *pulumi.Context, args GetGithubAppOutputArgs, opts ...pulumi.InvokeOption) GetGithubAppResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetGithubAppResultOutput, error) { + args := v.(GetGithubAppArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getGithubApp:getGithubApp", args, GetGithubAppResultOutput{}, options).(GetGithubAppResultOutput), nil + }).(GetGithubAppResultOutput) +} + +// A collection of arguments for invoking getGithubApp. +type GetGithubAppOutputArgs struct { + // The URL-friendly name of your GitHub App. + Slug pulumi.StringInput `pulumi:"slug"` +} + +func (GetGithubAppOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetGithubAppArgs)(nil)).Elem() +} + +// A collection of values returned by getGithubApp. +type GetGithubAppResultOutput struct{ *pulumi.OutputState } + +func (GetGithubAppResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetGithubAppResult)(nil)).Elem() +} + +func (o GetGithubAppResultOutput) ToGetGithubAppResultOutput() GetGithubAppResultOutput { + return o +} + +func (o GetGithubAppResultOutput) ToGetGithubAppResultOutputWithContext(ctx context.Context) GetGithubAppResultOutput { + return o +} + +// The app's description. +func (o GetGithubAppResultOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v GetGithubAppResult) string { return v.Description }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetGithubAppResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetGithubAppResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The app's full name. +func (o GetGithubAppResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetGithubAppResult) string { return v.Name }).(pulumi.StringOutput) +} + +// The Node ID of the app. +func (o GetGithubAppResultOutput) NodeId() pulumi.StringOutput { + return o.ApplyT(func(v GetGithubAppResult) string { return v.NodeId }).(pulumi.StringOutput) +} + +func (o GetGithubAppResultOutput) Slug() pulumi.StringOutput { + return o.ApplyT(func(v GetGithubAppResult) string { return v.Slug }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetGithubAppResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getIpRanges.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getIpRanges.go new file mode 100644 index 000000000..c948649eb --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getIpRanges.go @@ -0,0 +1,327 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about GitHub's IP addresses. +// +// ## Example Usage +// +// ```go +// 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.GetIpRanges(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetIpRanges(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetIpRangesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetIpRangesResult + err := ctx.Invoke("github:index/getIpRanges:getIpRanges", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getIpRanges. +type GetIpRangesResult struct { + // An array of IP addresses in CIDR format specifying the addresses that incoming requests from GitHub Actions will originate from. + Actions []string `pulumi:"actions"` + // A subset of the `actions` array that contains IP addresses in IPv4 CIDR format. + ActionsIpv4s []string `pulumi:"actionsIpv4s"` + // A subset of the `actions` array that contains IP addresses in IPv6 CIDR format. + ActionsIpv6s []string `pulumi:"actionsIpv6s"` + // An array of IP addresses in CIDR format specifying the addresses that GitHub Actions macOS runners will originate from. + ActionsMacos []string `pulumi:"actionsMacos"` + // A subset of the `actionsMacos` array that contains IP addresses in IPv4 CIDR format. + ActionsMacosIpv4s []string `pulumi:"actionsMacosIpv4s"` + // A subset of the `actionsMacos` array that contains IP addresses in IPv6 CIDR format. + ActionsMacosIpv6s []string `pulumi:"actionsMacosIpv6s"` + // A subset of the `api` array that contains IP addresses in IPv4 CIDR format. + ApiIpv4s []string `pulumi:"apiIpv4s"` + // A subset of the `api` array that contains IP addresses in IPv6 CIDR format. + ApiIpv6s []string `pulumi:"apiIpv6s"` + // An Array of IP addresses in CIDR format for the GitHub API. + Apis []string `pulumi:"apis"` + // **Deprecated.** A subset of the `dependabot` array that contains IP addresses in IPv4 CIDR format. + // + // Deprecated: This attribute is no longer returned form the API, Dependabot now uses the GitHub Actions IP addresses. + DependabotIpv4s []string `pulumi:"dependabotIpv4s"` + // **Deprecated.** A subset of the `dependabot` array that contains IP addresses in IPv6 CIDR format. + // + // Deprecated: This attribute is no longer returned form the API, Dependabot now uses the GitHub Actions IP addresses. + DependabotIpv6s []string `pulumi:"dependabotIpv6s"` + // **Deprecated.** Dependabot now uses GitHub Actions IP addresses. An array of IP addresses in CIDR format specifying the A records for Dependabot. + // + // Deprecated: This attribute is no longer returned form the API, Dependabot now uses the GitHub Actions IP addresses. + Dependabots []string `pulumi:"dependabots"` + // A subset of the `git` array that contains IP addresses in IPv4 CIDR format. + GitIpv4s []string `pulumi:"gitIpv4s"` + // A subset of the `git` array that contains IP addresses in IPv6 CIDR format. + GitIpv6s []string `pulumi:"gitIpv6s"` + // A subset of the `githubEnterpriseImporter` array that contains IP addresses in IPv4 CIDR format. + GithubEnterpriseImporterIpv4s []string `pulumi:"githubEnterpriseImporterIpv4s"` + // A subset of the `githubEnterpriseImporter` array that contains IP addresses in IPv6 CIDR format. + GithubEnterpriseImporterIpv6s []string `pulumi:"githubEnterpriseImporterIpv6s"` + // An array of IP addresses in CIDR format specifying the addresses that GitHub Enterprise Importer will originate from. + GithubEnterpriseImporters []string `pulumi:"githubEnterpriseImporters"` + // An Array of IP addresses in CIDR format specifying the Git servers. + Gits []string `pulumi:"gits"` + // An Array of IP addresses in CIDR format specifying the addresses that incoming service hooks will originate from. + Hooks []string `pulumi:"hooks"` + // A subset of the `hooks` array that contains IP addresses in IPv4 CIDR format. + HooksIpv4s []string `pulumi:"hooksIpv4s"` + // A subset of the `hooks` array that contains IP addresses in IPv6 CIDR format. + HooksIpv6s []string `pulumi:"hooksIpv6s"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // A subset of the `importer` array that contains IP addresses in IPv4 CIDR format. + ImporterIpv4s []string `pulumi:"importerIpv4s"` + // A subset of the `importer` array that contains IP addresses in IPv6 CIDR format. + ImporterIpv6s []string `pulumi:"importerIpv6s"` + // An Array of IP addresses in CIDR format specifying the A records for GitHub Importer. + Importers []string `pulumi:"importers"` + // An Array of IP addresses in CIDR format specifying the A records for GitHub Packages. + Packages []string `pulumi:"packages"` + // A subset of the `packages` array that contains IP addresses in IPv4 CIDR format. + PackagesIpv4s []string `pulumi:"packagesIpv4s"` + // A subset of the `packages` array that contains IP addresses in IPv6 CIDR format. + PackagesIpv6s []string `pulumi:"packagesIpv6s"` + // An Array of IP addresses in CIDR format specifying the A records for GitHub Pages. + Pages []string `pulumi:"pages"` + // A subset of the `pages` array that contains IP addresses in IPv4 CIDR format. + PagesIpv4s []string `pulumi:"pagesIpv4s"` + // A subset of the `pages` array that contains IP addresses in IPv6 CIDR format. + PagesIpv6s []string `pulumi:"pagesIpv6s"` + // A subset of the `web` array that contains IP addresses in IPv4 CIDR format. + WebIpv4s []string `pulumi:"webIpv4s"` + // A subset of the `web` array that contains IP addresses in IPv6 CIDR format. + WebIpv6s []string `pulumi:"webIpv6s"` + // An Array of IP addresses in CIDR format for GitHub Web. + Webs []string `pulumi:"webs"` +} + +func GetIpRangesOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetIpRangesResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetIpRangesResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getIpRanges:getIpRanges", nil, GetIpRangesResultOutput{}, options).(GetIpRangesResultOutput), nil + }).(GetIpRangesResultOutput) +} + +// A collection of values returned by getIpRanges. +type GetIpRangesResultOutput struct{ *pulumi.OutputState } + +func (GetIpRangesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetIpRangesResult)(nil)).Elem() +} + +func (o GetIpRangesResultOutput) ToGetIpRangesResultOutput() GetIpRangesResultOutput { + return o +} + +func (o GetIpRangesResultOutput) ToGetIpRangesResultOutputWithContext(ctx context.Context) GetIpRangesResultOutput { + return o +} + +// An array of IP addresses in CIDR format specifying the addresses that incoming requests from GitHub Actions will originate from. +func (o GetIpRangesResultOutput) Actions() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.Actions }).(pulumi.StringArrayOutput) +} + +// A subset of the `actions` array that contains IP addresses in IPv4 CIDR format. +func (o GetIpRangesResultOutput) ActionsIpv4s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.ActionsIpv4s }).(pulumi.StringArrayOutput) +} + +// A subset of the `actions` array that contains IP addresses in IPv6 CIDR format. +func (o GetIpRangesResultOutput) ActionsIpv6s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.ActionsIpv6s }).(pulumi.StringArrayOutput) +} + +// An array of IP addresses in CIDR format specifying the addresses that GitHub Actions macOS runners will originate from. +func (o GetIpRangesResultOutput) ActionsMacos() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.ActionsMacos }).(pulumi.StringArrayOutput) +} + +// A subset of the `actionsMacos` array that contains IP addresses in IPv4 CIDR format. +func (o GetIpRangesResultOutput) ActionsMacosIpv4s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.ActionsMacosIpv4s }).(pulumi.StringArrayOutput) +} + +// A subset of the `actionsMacos` array that contains IP addresses in IPv6 CIDR format. +func (o GetIpRangesResultOutput) ActionsMacosIpv6s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.ActionsMacosIpv6s }).(pulumi.StringArrayOutput) +} + +// A subset of the `api` array that contains IP addresses in IPv4 CIDR format. +func (o GetIpRangesResultOutput) ApiIpv4s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.ApiIpv4s }).(pulumi.StringArrayOutput) +} + +// A subset of the `api` array that contains IP addresses in IPv6 CIDR format. +func (o GetIpRangesResultOutput) ApiIpv6s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.ApiIpv6s }).(pulumi.StringArrayOutput) +} + +// An Array of IP addresses in CIDR format for the GitHub API. +func (o GetIpRangesResultOutput) Apis() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.Apis }).(pulumi.StringArrayOutput) +} + +// **Deprecated.** A subset of the `dependabot` array that contains IP addresses in IPv4 CIDR format. +// +// Deprecated: This attribute is no longer returned form the API, Dependabot now uses the GitHub Actions IP addresses. +func (o GetIpRangesResultOutput) DependabotIpv4s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.DependabotIpv4s }).(pulumi.StringArrayOutput) +} + +// **Deprecated.** A subset of the `dependabot` array that contains IP addresses in IPv6 CIDR format. +// +// Deprecated: This attribute is no longer returned form the API, Dependabot now uses the GitHub Actions IP addresses. +func (o GetIpRangesResultOutput) DependabotIpv6s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.DependabotIpv6s }).(pulumi.StringArrayOutput) +} + +// **Deprecated.** Dependabot now uses GitHub Actions IP addresses. An array of IP addresses in CIDR format specifying the A records for Dependabot. +// +// Deprecated: This attribute is no longer returned form the API, Dependabot now uses the GitHub Actions IP addresses. +func (o GetIpRangesResultOutput) Dependabots() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.Dependabots }).(pulumi.StringArrayOutput) +} + +// A subset of the `git` array that contains IP addresses in IPv4 CIDR format. +func (o GetIpRangesResultOutput) GitIpv4s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.GitIpv4s }).(pulumi.StringArrayOutput) +} + +// A subset of the `git` array that contains IP addresses in IPv6 CIDR format. +func (o GetIpRangesResultOutput) GitIpv6s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.GitIpv6s }).(pulumi.StringArrayOutput) +} + +// A subset of the `githubEnterpriseImporter` array that contains IP addresses in IPv4 CIDR format. +func (o GetIpRangesResultOutput) GithubEnterpriseImporterIpv4s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.GithubEnterpriseImporterIpv4s }).(pulumi.StringArrayOutput) +} + +// A subset of the `githubEnterpriseImporter` array that contains IP addresses in IPv6 CIDR format. +func (o GetIpRangesResultOutput) GithubEnterpriseImporterIpv6s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.GithubEnterpriseImporterIpv6s }).(pulumi.StringArrayOutput) +} + +// An array of IP addresses in CIDR format specifying the addresses that GitHub Enterprise Importer will originate from. +func (o GetIpRangesResultOutput) GithubEnterpriseImporters() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.GithubEnterpriseImporters }).(pulumi.StringArrayOutput) +} + +// An Array of IP addresses in CIDR format specifying the Git servers. +func (o GetIpRangesResultOutput) Gits() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.Gits }).(pulumi.StringArrayOutput) +} + +// An Array of IP addresses in CIDR format specifying the addresses that incoming service hooks will originate from. +func (o GetIpRangesResultOutput) Hooks() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.Hooks }).(pulumi.StringArrayOutput) +} + +// A subset of the `hooks` array that contains IP addresses in IPv4 CIDR format. +func (o GetIpRangesResultOutput) HooksIpv4s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.HooksIpv4s }).(pulumi.StringArrayOutput) +} + +// A subset of the `hooks` array that contains IP addresses in IPv6 CIDR format. +func (o GetIpRangesResultOutput) HooksIpv6s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.HooksIpv6s }).(pulumi.StringArrayOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetIpRangesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetIpRangesResult) string { return v.Id }).(pulumi.StringOutput) +} + +// A subset of the `importer` array that contains IP addresses in IPv4 CIDR format. +func (o GetIpRangesResultOutput) ImporterIpv4s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.ImporterIpv4s }).(pulumi.StringArrayOutput) +} + +// A subset of the `importer` array that contains IP addresses in IPv6 CIDR format. +func (o GetIpRangesResultOutput) ImporterIpv6s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.ImporterIpv6s }).(pulumi.StringArrayOutput) +} + +// An Array of IP addresses in CIDR format specifying the A records for GitHub Importer. +func (o GetIpRangesResultOutput) Importers() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.Importers }).(pulumi.StringArrayOutput) +} + +// An Array of IP addresses in CIDR format specifying the A records for GitHub Packages. +func (o GetIpRangesResultOutput) Packages() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.Packages }).(pulumi.StringArrayOutput) +} + +// A subset of the `packages` array that contains IP addresses in IPv4 CIDR format. +func (o GetIpRangesResultOutput) PackagesIpv4s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.PackagesIpv4s }).(pulumi.StringArrayOutput) +} + +// A subset of the `packages` array that contains IP addresses in IPv6 CIDR format. +func (o GetIpRangesResultOutput) PackagesIpv6s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.PackagesIpv6s }).(pulumi.StringArrayOutput) +} + +// An Array of IP addresses in CIDR format specifying the A records for GitHub Pages. +func (o GetIpRangesResultOutput) Pages() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.Pages }).(pulumi.StringArrayOutput) +} + +// A subset of the `pages` array that contains IP addresses in IPv4 CIDR format. +func (o GetIpRangesResultOutput) PagesIpv4s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.PagesIpv4s }).(pulumi.StringArrayOutput) +} + +// A subset of the `pages` array that contains IP addresses in IPv6 CIDR format. +func (o GetIpRangesResultOutput) PagesIpv6s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.PagesIpv6s }).(pulumi.StringArrayOutput) +} + +// A subset of the `web` array that contains IP addresses in IPv4 CIDR format. +func (o GetIpRangesResultOutput) WebIpv4s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.WebIpv4s }).(pulumi.StringArrayOutput) +} + +// A subset of the `web` array that contains IP addresses in IPv6 CIDR format. +func (o GetIpRangesResultOutput) WebIpv6s() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.WebIpv6s }).(pulumi.StringArrayOutput) +} + +// An Array of IP addresses in CIDR format for GitHub Web. +func (o GetIpRangesResultOutput) Webs() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetIpRangesResult) []string { return v.Webs }).(pulumi.StringArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetIpRangesResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getIssueLabels.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getIssueLabels.go new file mode 100644 index 000000000..408ebce6b --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getIssueLabels.go @@ -0,0 +1,90 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the labels for a given repository. +func LookupIssueLabels(ctx *pulumi.Context, args *LookupIssueLabelsArgs, opts ...pulumi.InvokeOption) (*LookupIssueLabelsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupIssueLabelsResult + err := ctx.Invoke("github:index/getIssueLabels:getIssueLabels", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getIssueLabels. +type LookupIssueLabelsArgs struct { + // The name of the repository. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getIssueLabels. +type LookupIssueLabelsResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The list of this repository's labels. Each element of `labels` has the following attributes: + Labels []GetIssueLabelsLabel `pulumi:"labels"` + Repository string `pulumi:"repository"` +} + +func LookupIssueLabelsOutput(ctx *pulumi.Context, args LookupIssueLabelsOutputArgs, opts ...pulumi.InvokeOption) LookupIssueLabelsResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupIssueLabelsResultOutput, error) { + args := v.(LookupIssueLabelsArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getIssueLabels:getIssueLabels", args, LookupIssueLabelsResultOutput{}, options).(LookupIssueLabelsResultOutput), nil + }).(LookupIssueLabelsResultOutput) +} + +// A collection of arguments for invoking getIssueLabels. +type LookupIssueLabelsOutputArgs struct { + // The name of the repository. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (LookupIssueLabelsOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupIssueLabelsArgs)(nil)).Elem() +} + +// A collection of values returned by getIssueLabels. +type LookupIssueLabelsResultOutput struct{ *pulumi.OutputState } + +func (LookupIssueLabelsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupIssueLabelsResult)(nil)).Elem() +} + +func (o LookupIssueLabelsResultOutput) ToLookupIssueLabelsResultOutput() LookupIssueLabelsResultOutput { + return o +} + +func (o LookupIssueLabelsResultOutput) ToLookupIssueLabelsResultOutputWithContext(ctx context.Context) LookupIssueLabelsResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupIssueLabelsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupIssueLabelsResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The list of this repository's labels. Each element of `labels` has the following attributes: +func (o LookupIssueLabelsResultOutput) Labels() GetIssueLabelsLabelArrayOutput { + return o.ApplyT(func(v LookupIssueLabelsResult) []GetIssueLabelsLabel { return v.Labels }).(GetIssueLabelsLabelArrayOutput) +} + +func (o LookupIssueLabelsResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v LookupIssueLabelsResult) string { return v.Repository }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupIssueLabelsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getMembership.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getMembership.go new file mode 100644 index 000000000..5c76559fb --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getMembership.go @@ -0,0 +1,144 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to find out if a user is a member of your organization, as well +// as what role they have within it. +// If the user's membership in the organization is pending their acceptance of an invite, +// the role they would have once they accept will be returned. +// +// ## Example Usage +// +// ```go +// 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.GetMembership(ctx, &github.LookupMembershipArgs{ +// Username: "SomeUser", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupMembership(ctx *pulumi.Context, args *LookupMembershipArgs, opts ...pulumi.InvokeOption) (*LookupMembershipResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupMembershipResult + err := ctx.Invoke("github:index/getMembership:getMembership", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getMembership. +type LookupMembershipArgs struct { + // The organization to check for the above username. + Organization *string `pulumi:"organization"` + // The username to lookup in the organization. + Username string `pulumi:"username"` +} + +// A collection of values returned by getMembership. +type LookupMembershipResult struct { + // An etag representing the membership object. + Etag string `pulumi:"etag"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Organization *string `pulumi:"organization"` + // `admin` or `member` -- the role the user has within the organization. + Role string `pulumi:"role"` + // `active` or `pending` -- the state of membership within the organization. `active` if the member has accepted the invite, or `pending` if the invite is still pending. + State string `pulumi:"state"` + // The username. + Username string `pulumi:"username"` +} + +func LookupMembershipOutput(ctx *pulumi.Context, args LookupMembershipOutputArgs, opts ...pulumi.InvokeOption) LookupMembershipResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupMembershipResultOutput, error) { + args := v.(LookupMembershipArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getMembership:getMembership", args, LookupMembershipResultOutput{}, options).(LookupMembershipResultOutput), nil + }).(LookupMembershipResultOutput) +} + +// A collection of arguments for invoking getMembership. +type LookupMembershipOutputArgs struct { + // The organization to check for the above username. + Organization pulumi.StringPtrInput `pulumi:"organization"` + // The username to lookup in the organization. + Username pulumi.StringInput `pulumi:"username"` +} + +func (LookupMembershipOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupMembershipArgs)(nil)).Elem() +} + +// A collection of values returned by getMembership. +type LookupMembershipResultOutput struct{ *pulumi.OutputState } + +func (LookupMembershipResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupMembershipResult)(nil)).Elem() +} + +func (o LookupMembershipResultOutput) ToLookupMembershipResultOutput() LookupMembershipResultOutput { + return o +} + +func (o LookupMembershipResultOutput) ToLookupMembershipResultOutputWithContext(ctx context.Context) LookupMembershipResultOutput { + return o +} + +// An etag representing the membership object. +func (o LookupMembershipResultOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v LookupMembershipResult) string { return v.Etag }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupMembershipResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupMembershipResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o LookupMembershipResultOutput) Organization() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupMembershipResult) *string { return v.Organization }).(pulumi.StringPtrOutput) +} + +// `admin` or `member` -- the role the user has within the organization. +func (o LookupMembershipResultOutput) Role() pulumi.StringOutput { + return o.ApplyT(func(v LookupMembershipResult) string { return v.Role }).(pulumi.StringOutput) +} + +// `active` or `pending` -- the state of membership within the organization. `active` if the member has accepted the invite, or `pending` if the invite is still pending. +func (o LookupMembershipResultOutput) State() pulumi.StringOutput { + return o.ApplyT(func(v LookupMembershipResult) string { return v.State }).(pulumi.StringOutput) +} + +// The username. +func (o LookupMembershipResultOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v LookupMembershipResult) string { return v.Username }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupMembershipResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganization.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganization.go new file mode 100644 index 000000000..6e673c739 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganization.go @@ -0,0 +1,315 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve basic information about a GitHub Organization. +// +// ## Example Usage +// +// ```go +// 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.GetOrganization(ctx, &github.GetOrganizationArgs{ +// Name: "github", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetOrganization(ctx *pulumi.Context, args *GetOrganizationArgs, opts ...pulumi.InvokeOption) (*GetOrganizationResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetOrganizationResult + err := ctx.Invoke("github:index/getOrganization:getOrganization", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getOrganization. +type GetOrganizationArgs struct { + // Whether or not to include archived repos in the `repositories` list. Defaults to `false`. + IgnoreArchivedRepos *bool `pulumi:"ignoreArchivedRepos"` + // The name of the organization. + Name string `pulumi:"name"` + // Exclude the repos, members and other attributes from the returned result. Defaults to `false`. + SummaryOnly *bool `pulumi:"summaryOnly"` +} + +// A collection of values returned by getOrganization. +type GetOrganizationResult struct { + // Whether advanced security is enabled for new repositories. + AdvancedSecurityEnabledForNewRepositories bool `pulumi:"advancedSecurityEnabledForNewRepositories"` + // Default permission level members have for organization repositories. + DefaultRepositoryPermission string `pulumi:"defaultRepositoryPermission"` + // Whether Dependabot alerts is automatically enabled for new repositories. + DependabotAlertsEnabledForNewRepositories bool `pulumi:"dependabotAlertsEnabledForNewRepositories"` + // Whether Dependabot security updates is automatically enabled for new repositories. + DependabotSecurityUpdatesEnabledForNewRepositories bool `pulumi:"dependabotSecurityUpdatesEnabledForNewRepositories"` + // Whether dependency graph is automatically enabled for new repositories. + DependencyGraphEnabledForNewRepositories bool `pulumi:"dependencyGraphEnabledForNewRepositories"` + // The organization account description + Description string `pulumi:"description"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + IgnoreArchivedRepos *bool `pulumi:"ignoreArchivedRepos"` + // The members login + Login string `pulumi:"login"` + // **Deprecated**: use `users` instead by replacing `github_organization.example.members` to `github_organization.example.users[*].login` which will give you the same value, expect this field to be removed in next major version + // + // Deprecated: Use `users` instead by replacing `github_organization.example.members` to `github_organization.example.users[*].login`. Expect this field to be removed in next major version. + Members []string `pulumi:"members"` + // The type of repository allowed to be created by members of the organization. Can be one of `ALL`, `PUBLIC`, `PRIVATE`, `NONE`. + MembersAllowedRepositoryCreationType string `pulumi:"membersAllowedRepositoryCreationType"` + // Whether organization members can create internal repositories. + MembersCanCreateInternalRepositories bool `pulumi:"membersCanCreateInternalRepositories"` + // Whether organization members can create pages sites. + MembersCanCreatePages bool `pulumi:"membersCanCreatePages"` + // Whether organization members can create private pages sites. + MembersCanCreatePrivatePages bool `pulumi:"membersCanCreatePrivatePages"` + // Whether organization members can create private repositories. + MembersCanCreatePrivateRepositories bool `pulumi:"membersCanCreatePrivateRepositories"` + // Whether organization members can create public pages sites. + MembersCanCreatePublicPages bool `pulumi:"membersCanCreatePublicPages"` + // Whether organization members can create public repositories. + MembersCanCreatePublicRepositories bool `pulumi:"membersCanCreatePublicRepositories"` + // Whether non-admin organization members can create repositories. + MembersCanCreateRepositories bool `pulumi:"membersCanCreateRepositories"` + // Whether organization members can create private repository forks. + MembersCanForkPrivateRepositories bool `pulumi:"membersCanForkPrivateRepositories"` + // The organization's public profile name + Name string `pulumi:"name"` + // GraphQL global node ID for use with the v4 API + NodeId string `pulumi:"nodeId"` + // The organization's name as used in URLs and the API + Orgname string `pulumi:"orgname"` + // The organization account plan name + Plan string `pulumi:"plan"` + // (`list`) A list of the full names of the repositories in the organization formatted as `owner/name` strings + Repositories []string `pulumi:"repositories"` + // Whether secret scanning is automatically enabled for new repositories. + SecretScanningEnabledForNewRepositories bool `pulumi:"secretScanningEnabledForNewRepositories"` + // Whether secret scanning push protection is automatically enabled for new repositories. + SecretScanningPushProtectionEnabledForNewRepositories bool `pulumi:"secretScanningPushProtectionEnabledForNewRepositories"` + SummaryOnly *bool `pulumi:"summaryOnly"` + // Whether two-factor authentication is required for all members of the organization. + TwoFactorRequirementEnabled bool `pulumi:"twoFactorRequirementEnabled"` + // (`list`) A list with the members of the organization with following fields: + Users []map[string]string `pulumi:"users"` + // Whether organization members must sign all commits. + WebCommitSignoffRequired bool `pulumi:"webCommitSignoffRequired"` +} + +func GetOrganizationOutput(ctx *pulumi.Context, args GetOrganizationOutputArgs, opts ...pulumi.InvokeOption) GetOrganizationResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetOrganizationResultOutput, error) { + args := v.(GetOrganizationArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getOrganization:getOrganization", args, GetOrganizationResultOutput{}, options).(GetOrganizationResultOutput), nil + }).(GetOrganizationResultOutput) +} + +// A collection of arguments for invoking getOrganization. +type GetOrganizationOutputArgs struct { + // Whether or not to include archived repos in the `repositories` list. Defaults to `false`. + IgnoreArchivedRepos pulumi.BoolPtrInput `pulumi:"ignoreArchivedRepos"` + // The name of the organization. + Name pulumi.StringInput `pulumi:"name"` + // Exclude the repos, members and other attributes from the returned result. Defaults to `false`. + SummaryOnly pulumi.BoolPtrInput `pulumi:"summaryOnly"` +} + +func (GetOrganizationOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationArgs)(nil)).Elem() +} + +// A collection of values returned by getOrganization. +type GetOrganizationResultOutput struct{ *pulumi.OutputState } + +func (GetOrganizationResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationResult)(nil)).Elem() +} + +func (o GetOrganizationResultOutput) ToGetOrganizationResultOutput() GetOrganizationResultOutput { + return o +} + +func (o GetOrganizationResultOutput) ToGetOrganizationResultOutputWithContext(ctx context.Context) GetOrganizationResultOutput { + return o +} + +// Whether advanced security is enabled for new repositories. +func (o GetOrganizationResultOutput) AdvancedSecurityEnabledForNewRepositories() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationResult) bool { return v.AdvancedSecurityEnabledForNewRepositories }).(pulumi.BoolOutput) +} + +// Default permission level members have for organization repositories. +func (o GetOrganizationResultOutput) DefaultRepositoryPermission() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationResult) string { return v.DefaultRepositoryPermission }).(pulumi.StringOutput) +} + +// Whether Dependabot alerts is automatically enabled for new repositories. +func (o GetOrganizationResultOutput) DependabotAlertsEnabledForNewRepositories() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationResult) bool { return v.DependabotAlertsEnabledForNewRepositories }).(pulumi.BoolOutput) +} + +// Whether Dependabot security updates is automatically enabled for new repositories. +func (o GetOrganizationResultOutput) DependabotSecurityUpdatesEnabledForNewRepositories() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationResult) bool { return v.DependabotSecurityUpdatesEnabledForNewRepositories }).(pulumi.BoolOutput) +} + +// Whether dependency graph is automatically enabled for new repositories. +func (o GetOrganizationResultOutput) DependencyGraphEnabledForNewRepositories() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationResult) bool { return v.DependencyGraphEnabledForNewRepositories }).(pulumi.BoolOutput) +} + +// The organization account description +func (o GetOrganizationResultOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationResult) string { return v.Description }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetOrganizationResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetOrganizationResultOutput) IgnoreArchivedRepos() pulumi.BoolPtrOutput { + return o.ApplyT(func(v GetOrganizationResult) *bool { return v.IgnoreArchivedRepos }).(pulumi.BoolPtrOutput) +} + +// The members login +func (o GetOrganizationResultOutput) Login() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationResult) string { return v.Login }).(pulumi.StringOutput) +} + +// **Deprecated**: use `users` instead by replacing `github_organization.example.members` to `github_organization.example.users[*].login` which will give you the same value, expect this field to be removed in next major version +// +// Deprecated: Use `users` instead by replacing `github_organization.example.members` to `github_organization.example.users[*].login`. Expect this field to be removed in next major version. +func (o GetOrganizationResultOutput) Members() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetOrganizationResult) []string { return v.Members }).(pulumi.StringArrayOutput) +} + +// The type of repository allowed to be created by members of the organization. Can be one of `ALL`, `PUBLIC`, `PRIVATE`, `NONE`. +func (o GetOrganizationResultOutput) MembersAllowedRepositoryCreationType() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationResult) string { return v.MembersAllowedRepositoryCreationType }).(pulumi.StringOutput) +} + +// Whether organization members can create internal repositories. +func (o GetOrganizationResultOutput) MembersCanCreateInternalRepositories() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationResult) bool { return v.MembersCanCreateInternalRepositories }).(pulumi.BoolOutput) +} + +// Whether organization members can create pages sites. +func (o GetOrganizationResultOutput) MembersCanCreatePages() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationResult) bool { return v.MembersCanCreatePages }).(pulumi.BoolOutput) +} + +// Whether organization members can create private pages sites. +func (o GetOrganizationResultOutput) MembersCanCreatePrivatePages() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationResult) bool { return v.MembersCanCreatePrivatePages }).(pulumi.BoolOutput) +} + +// Whether organization members can create private repositories. +func (o GetOrganizationResultOutput) MembersCanCreatePrivateRepositories() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationResult) bool { return v.MembersCanCreatePrivateRepositories }).(pulumi.BoolOutput) +} + +// Whether organization members can create public pages sites. +func (o GetOrganizationResultOutput) MembersCanCreatePublicPages() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationResult) bool { return v.MembersCanCreatePublicPages }).(pulumi.BoolOutput) +} + +// Whether organization members can create public repositories. +func (o GetOrganizationResultOutput) MembersCanCreatePublicRepositories() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationResult) bool { return v.MembersCanCreatePublicRepositories }).(pulumi.BoolOutput) +} + +// Whether non-admin organization members can create repositories. +func (o GetOrganizationResultOutput) MembersCanCreateRepositories() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationResult) bool { return v.MembersCanCreateRepositories }).(pulumi.BoolOutput) +} + +// Whether organization members can create private repository forks. +func (o GetOrganizationResultOutput) MembersCanForkPrivateRepositories() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationResult) bool { return v.MembersCanForkPrivateRepositories }).(pulumi.BoolOutput) +} + +// The organization's public profile name +func (o GetOrganizationResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationResult) string { return v.Name }).(pulumi.StringOutput) +} + +// GraphQL global node ID for use with the v4 API +func (o GetOrganizationResultOutput) NodeId() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationResult) string { return v.NodeId }).(pulumi.StringOutput) +} + +// The organization's name as used in URLs and the API +func (o GetOrganizationResultOutput) Orgname() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationResult) string { return v.Orgname }).(pulumi.StringOutput) +} + +// The organization account plan name +func (o GetOrganizationResultOutput) Plan() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationResult) string { return v.Plan }).(pulumi.StringOutput) +} + +// (`list`) A list of the full names of the repositories in the organization formatted as `owner/name` strings +func (o GetOrganizationResultOutput) Repositories() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetOrganizationResult) []string { return v.Repositories }).(pulumi.StringArrayOutput) +} + +// Whether secret scanning is automatically enabled for new repositories. +func (o GetOrganizationResultOutput) SecretScanningEnabledForNewRepositories() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationResult) bool { return v.SecretScanningEnabledForNewRepositories }).(pulumi.BoolOutput) +} + +// Whether secret scanning push protection is automatically enabled for new repositories. +func (o GetOrganizationResultOutput) SecretScanningPushProtectionEnabledForNewRepositories() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationResult) bool { return v.SecretScanningPushProtectionEnabledForNewRepositories }).(pulumi.BoolOutput) +} + +func (o GetOrganizationResultOutput) SummaryOnly() pulumi.BoolPtrOutput { + return o.ApplyT(func(v GetOrganizationResult) *bool { return v.SummaryOnly }).(pulumi.BoolPtrOutput) +} + +// Whether two-factor authentication is required for all members of the organization. +func (o GetOrganizationResultOutput) TwoFactorRequirementEnabled() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationResult) bool { return v.TwoFactorRequirementEnabled }).(pulumi.BoolOutput) +} + +// (`list`) A list with the members of the organization with following fields: +func (o GetOrganizationResultOutput) Users() pulumi.StringMapArrayOutput { + return o.ApplyT(func(v GetOrganizationResult) []map[string]string { return v.Users }).(pulumi.StringMapArrayOutput) +} + +// Whether organization members must sign all commits. +func (o GetOrganizationResultOutput) WebCommitSignoffRequired() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationResult) bool { return v.WebCommitSignoffRequired }).(pulumi.BoolOutput) +} + +func init() { + pulumi.RegisterOutputType(GetOrganizationResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationAppInstallations.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationAppInstallations.go new file mode 100644 index 000000000..39af818f8 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationAppInstallations.go @@ -0,0 +1,95 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve all GitHub App installations of the organization. +// +// ## Example Usage +// +// To retrieve *all* GitHub App installations of the organization: +// +// ```go +// 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.GetOrganizationAppInstallations(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetOrganizationAppInstallations(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetOrganizationAppInstallationsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetOrganizationAppInstallationsResult + err := ctx.Invoke("github:index/getOrganizationAppInstallations:getOrganizationAppInstallations", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getOrganizationAppInstallations. +type GetOrganizationAppInstallationsResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // List of GitHub App installations in the organization. Each `installation` block consists of the fields documented below. + Installations []GetOrganizationAppInstallationsInstallation `pulumi:"installations"` +} + +func GetOrganizationAppInstallationsOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetOrganizationAppInstallationsResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetOrganizationAppInstallationsResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getOrganizationAppInstallations:getOrganizationAppInstallations", nil, GetOrganizationAppInstallationsResultOutput{}, options).(GetOrganizationAppInstallationsResultOutput), nil + }).(GetOrganizationAppInstallationsResultOutput) +} + +// A collection of values returned by getOrganizationAppInstallations. +type GetOrganizationAppInstallationsResultOutput struct{ *pulumi.OutputState } + +func (GetOrganizationAppInstallationsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationAppInstallationsResult)(nil)).Elem() +} + +func (o GetOrganizationAppInstallationsResultOutput) ToGetOrganizationAppInstallationsResultOutput() GetOrganizationAppInstallationsResultOutput { + return o +} + +func (o GetOrganizationAppInstallationsResultOutput) ToGetOrganizationAppInstallationsResultOutputWithContext(ctx context.Context) GetOrganizationAppInstallationsResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetOrganizationAppInstallationsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationAppInstallationsResult) string { return v.Id }).(pulumi.StringOutput) +} + +// List of GitHub App installations in the organization. Each `installation` block consists of the fields documented below. +func (o GetOrganizationAppInstallationsResultOutput) Installations() GetOrganizationAppInstallationsInstallationArrayOutput { + return o.ApplyT(func(v GetOrganizationAppInstallationsResult) []GetOrganizationAppInstallationsInstallation { + return v.Installations + }).(GetOrganizationAppInstallationsInstallationArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetOrganizationAppInstallationsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationCustomProperties.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationCustomProperties.go new file mode 100644 index 000000000..f0f77a28a --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationCustomProperties.go @@ -0,0 +1,177 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a GitHub organization custom property. +// +// ## Example Usage +// +// ```go +// 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.GetOrganizationCustomProperties(ctx, &github.LookupOrganizationCustomPropertiesArgs{ +// PropertyName: "environment", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupOrganizationCustomProperties(ctx *pulumi.Context, args *LookupOrganizationCustomPropertiesArgs, opts ...pulumi.InvokeOption) (*LookupOrganizationCustomPropertiesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupOrganizationCustomPropertiesResult + err := ctx.Invoke("github:index/getOrganizationCustomProperties:getOrganizationCustomProperties", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getOrganizationCustomProperties. +type LookupOrganizationCustomPropertiesArgs struct { + // List of allowed values for the custom property. Only populated when `valueType` is `singleSelect` or `multiSelect`. + AllowedValues []string `pulumi:"allowedValues"` + // The default value of the custom property. + DefaultValue *string `pulumi:"defaultValue"` + // The description of the custom property. + Description *string `pulumi:"description"` + // The name of the custom property to retrieve. + PropertyName string `pulumi:"propertyName"` + // Whether the custom property is required. + Required *bool `pulumi:"required"` + // The type of the custom property. Can be one of `string`, `singleSelect`, `multiSelect`, or `trueFalse`. + ValueType *string `pulumi:"valueType"` + // Who can edit the values of the custom property. Can be one of `orgActors` or `orgAndRepoActors`. + ValuesEditableBy *string `pulumi:"valuesEditableBy"` +} + +// A collection of values returned by getOrganizationCustomProperties. +type LookupOrganizationCustomPropertiesResult struct { + // List of allowed values for the custom property. Only populated when `valueType` is `singleSelect` or `multiSelect`. + AllowedValues []string `pulumi:"allowedValues"` + // The default value of the custom property. + DefaultValue string `pulumi:"defaultValue"` + // The description of the custom property. + Description string `pulumi:"description"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The name of the custom property. + PropertyName string `pulumi:"propertyName"` + // Whether the custom property is required. + Required *bool `pulumi:"required"` + // The type of the custom property. Can be one of `string`, `singleSelect`, `multiSelect`, or `trueFalse`. + ValueType *string `pulumi:"valueType"` + // Who can edit the values of the custom property. Can be one of `orgActors` or `orgAndRepoActors`. + ValuesEditableBy string `pulumi:"valuesEditableBy"` +} + +func LookupOrganizationCustomPropertiesOutput(ctx *pulumi.Context, args LookupOrganizationCustomPropertiesOutputArgs, opts ...pulumi.InvokeOption) LookupOrganizationCustomPropertiesResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupOrganizationCustomPropertiesResultOutput, error) { + args := v.(LookupOrganizationCustomPropertiesArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getOrganizationCustomProperties:getOrganizationCustomProperties", args, LookupOrganizationCustomPropertiesResultOutput{}, options).(LookupOrganizationCustomPropertiesResultOutput), nil + }).(LookupOrganizationCustomPropertiesResultOutput) +} + +// A collection of arguments for invoking getOrganizationCustomProperties. +type LookupOrganizationCustomPropertiesOutputArgs struct { + // List of allowed values for the custom property. Only populated when `valueType` is `singleSelect` or `multiSelect`. + AllowedValues pulumi.StringArrayInput `pulumi:"allowedValues"` + // The default value of the custom property. + DefaultValue pulumi.StringPtrInput `pulumi:"defaultValue"` + // The description of the custom property. + Description pulumi.StringPtrInput `pulumi:"description"` + // The name of the custom property to retrieve. + PropertyName pulumi.StringInput `pulumi:"propertyName"` + // Whether the custom property is required. + Required pulumi.BoolPtrInput `pulumi:"required"` + // The type of the custom property. Can be one of `string`, `singleSelect`, `multiSelect`, or `trueFalse`. + ValueType pulumi.StringPtrInput `pulumi:"valueType"` + // Who can edit the values of the custom property. Can be one of `orgActors` or `orgAndRepoActors`. + ValuesEditableBy pulumi.StringPtrInput `pulumi:"valuesEditableBy"` +} + +func (LookupOrganizationCustomPropertiesOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupOrganizationCustomPropertiesArgs)(nil)).Elem() +} + +// A collection of values returned by getOrganizationCustomProperties. +type LookupOrganizationCustomPropertiesResultOutput struct{ *pulumi.OutputState } + +func (LookupOrganizationCustomPropertiesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupOrganizationCustomPropertiesResult)(nil)).Elem() +} + +func (o LookupOrganizationCustomPropertiesResultOutput) ToLookupOrganizationCustomPropertiesResultOutput() LookupOrganizationCustomPropertiesResultOutput { + return o +} + +func (o LookupOrganizationCustomPropertiesResultOutput) ToLookupOrganizationCustomPropertiesResultOutputWithContext(ctx context.Context) LookupOrganizationCustomPropertiesResultOutput { + return o +} + +// List of allowed values for the custom property. Only populated when `valueType` is `singleSelect` or `multiSelect`. +func (o LookupOrganizationCustomPropertiesResultOutput) AllowedValues() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupOrganizationCustomPropertiesResult) []string { return v.AllowedValues }).(pulumi.StringArrayOutput) +} + +// The default value of the custom property. +func (o LookupOrganizationCustomPropertiesResultOutput) DefaultValue() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationCustomPropertiesResult) string { return v.DefaultValue }).(pulumi.StringOutput) +} + +// The description of the custom property. +func (o LookupOrganizationCustomPropertiesResultOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationCustomPropertiesResult) string { return v.Description }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupOrganizationCustomPropertiesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationCustomPropertiesResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The name of the custom property. +func (o LookupOrganizationCustomPropertiesResultOutput) PropertyName() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationCustomPropertiesResult) string { return v.PropertyName }).(pulumi.StringOutput) +} + +// Whether the custom property is required. +func (o LookupOrganizationCustomPropertiesResultOutput) Required() pulumi.BoolPtrOutput { + return o.ApplyT(func(v LookupOrganizationCustomPropertiesResult) *bool { return v.Required }).(pulumi.BoolPtrOutput) +} + +// The type of the custom property. Can be one of `string`, `singleSelect`, `multiSelect`, or `trueFalse`. +func (o LookupOrganizationCustomPropertiesResultOutput) ValueType() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupOrganizationCustomPropertiesResult) *string { return v.ValueType }).(pulumi.StringPtrOutput) +} + +// Who can edit the values of the custom property. Can be one of `orgActors` or `orgAndRepoActors`. +func (o LookupOrganizationCustomPropertiesResultOutput) ValuesEditableBy() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationCustomPropertiesResult) string { return v.ValuesEditableBy }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupOrganizationCustomPropertiesResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationCustomRole.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationCustomRole.go new file mode 100644 index 000000000..5422d49fa --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationCustomRole.go @@ -0,0 +1,134 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// > **Note:** This data source is deprecated, please use the `OrganizationRepositoryRole` data source instead. +// +// Use this data source to retrieve information about a custom role in a GitHub Organization. +// +// > Note: Custom roles are currently only available in GitHub Enterprise Cloud. +// +// ## Example Usage +// +// ```go +// 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.GetOrganizationCustomRole(ctx, &github.LookupOrganizationCustomRoleArgs{ +// Name: "example", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupOrganizationCustomRole(ctx *pulumi.Context, args *LookupOrganizationCustomRoleArgs, opts ...pulumi.InvokeOption) (*LookupOrganizationCustomRoleResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupOrganizationCustomRoleResult + err := ctx.Invoke("github:index/getOrganizationCustomRole:getOrganizationCustomRole", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getOrganizationCustomRole. +type LookupOrganizationCustomRoleArgs struct { + // The name of the custom role. + Name string `pulumi:"name"` +} + +// A collection of values returned by getOrganizationCustomRole. +type LookupOrganizationCustomRoleResult struct { + // The system role from which the role inherits permissions. + BaseRole string `pulumi:"baseRole"` + // The description for the custom role. + Description string `pulumi:"description"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Name string `pulumi:"name"` + // A list of additional permissions included in this role. + Permissions []string `pulumi:"permissions"` +} + +func LookupOrganizationCustomRoleOutput(ctx *pulumi.Context, args LookupOrganizationCustomRoleOutputArgs, opts ...pulumi.InvokeOption) LookupOrganizationCustomRoleResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupOrganizationCustomRoleResultOutput, error) { + args := v.(LookupOrganizationCustomRoleArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getOrganizationCustomRole:getOrganizationCustomRole", args, LookupOrganizationCustomRoleResultOutput{}, options).(LookupOrganizationCustomRoleResultOutput), nil + }).(LookupOrganizationCustomRoleResultOutput) +} + +// A collection of arguments for invoking getOrganizationCustomRole. +type LookupOrganizationCustomRoleOutputArgs struct { + // The name of the custom role. + Name pulumi.StringInput `pulumi:"name"` +} + +func (LookupOrganizationCustomRoleOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupOrganizationCustomRoleArgs)(nil)).Elem() +} + +// A collection of values returned by getOrganizationCustomRole. +type LookupOrganizationCustomRoleResultOutput struct{ *pulumi.OutputState } + +func (LookupOrganizationCustomRoleResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupOrganizationCustomRoleResult)(nil)).Elem() +} + +func (o LookupOrganizationCustomRoleResultOutput) ToLookupOrganizationCustomRoleResultOutput() LookupOrganizationCustomRoleResultOutput { + return o +} + +func (o LookupOrganizationCustomRoleResultOutput) ToLookupOrganizationCustomRoleResultOutputWithContext(ctx context.Context) LookupOrganizationCustomRoleResultOutput { + return o +} + +// The system role from which the role inherits permissions. +func (o LookupOrganizationCustomRoleResultOutput) BaseRole() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationCustomRoleResult) string { return v.BaseRole }).(pulumi.StringOutput) +} + +// The description for the custom role. +func (o LookupOrganizationCustomRoleResultOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationCustomRoleResult) string { return v.Description }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupOrganizationCustomRoleResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationCustomRoleResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o LookupOrganizationCustomRoleResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationCustomRoleResult) string { return v.Name }).(pulumi.StringOutput) +} + +// A list of additional permissions included in this role. +func (o LookupOrganizationCustomRoleResultOutput) Permissions() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupOrganizationCustomRoleResult) []string { return v.Permissions }).(pulumi.StringArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupOrganizationCustomRoleResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationExternalIdentities.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationExternalIdentities.go new file mode 100644 index 000000000..ba539c550 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationExternalIdentities.go @@ -0,0 +1,94 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve each organization member's SAML or SCIM user +// attributes. +// +// ## Example Usage +// +// ```go +// 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.GetOrganizationExternalIdentities(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetOrganizationExternalIdentities(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetOrganizationExternalIdentitiesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetOrganizationExternalIdentitiesResult + err := ctx.Invoke("github:index/getOrganizationExternalIdentities:getOrganizationExternalIdentities", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getOrganizationExternalIdentities. +type GetOrganizationExternalIdentitiesResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // An Array of identities returned from GitHub + Identities []GetOrganizationExternalIdentitiesIdentity `pulumi:"identities"` +} + +func GetOrganizationExternalIdentitiesOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetOrganizationExternalIdentitiesResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetOrganizationExternalIdentitiesResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getOrganizationExternalIdentities:getOrganizationExternalIdentities", nil, GetOrganizationExternalIdentitiesResultOutput{}, options).(GetOrganizationExternalIdentitiesResultOutput), nil + }).(GetOrganizationExternalIdentitiesResultOutput) +} + +// A collection of values returned by getOrganizationExternalIdentities. +type GetOrganizationExternalIdentitiesResultOutput struct{ *pulumi.OutputState } + +func (GetOrganizationExternalIdentitiesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationExternalIdentitiesResult)(nil)).Elem() +} + +func (o GetOrganizationExternalIdentitiesResultOutput) ToGetOrganizationExternalIdentitiesResultOutput() GetOrganizationExternalIdentitiesResultOutput { + return o +} + +func (o GetOrganizationExternalIdentitiesResultOutput) ToGetOrganizationExternalIdentitiesResultOutputWithContext(ctx context.Context) GetOrganizationExternalIdentitiesResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetOrganizationExternalIdentitiesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationExternalIdentitiesResult) string { return v.Id }).(pulumi.StringOutput) +} + +// An Array of identities returned from GitHub +func (o GetOrganizationExternalIdentitiesResultOutput) Identities() GetOrganizationExternalIdentitiesIdentityArrayOutput { + return o.ApplyT(func(v GetOrganizationExternalIdentitiesResult) []GetOrganizationExternalIdentitiesIdentity { + return v.Identities + }).(GetOrganizationExternalIdentitiesIdentityArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetOrganizationExternalIdentitiesResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationIpAllowList.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationIpAllowList.go new file mode 100644 index 000000000..663c324da --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationIpAllowList.go @@ -0,0 +1,97 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about the IP allow list of an organization. +// The allow list for IP addresses will block access to private resources via the web, API, +// and Git from any IP addresses that are not on the allow list. +// +// ## Example Usage +// +// ```go +// 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.GetOrganizationIpAllowList(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetOrganizationIpAllowList(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetOrganizationIpAllowListResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetOrganizationIpAllowListResult + err := ctx.Invoke("github:index/getOrganizationIpAllowList:getOrganizationIpAllowList", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getOrganizationIpAllowList. +type GetOrganizationIpAllowListResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // An Array of allowed IP addresses. + // *** + IpAllowLists []GetOrganizationIpAllowListIpAllowList `pulumi:"ipAllowLists"` +} + +func GetOrganizationIpAllowListOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetOrganizationIpAllowListResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetOrganizationIpAllowListResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getOrganizationIpAllowList:getOrganizationIpAllowList", nil, GetOrganizationIpAllowListResultOutput{}, options).(GetOrganizationIpAllowListResultOutput), nil + }).(GetOrganizationIpAllowListResultOutput) +} + +// A collection of values returned by getOrganizationIpAllowList. +type GetOrganizationIpAllowListResultOutput struct{ *pulumi.OutputState } + +func (GetOrganizationIpAllowListResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationIpAllowListResult)(nil)).Elem() +} + +func (o GetOrganizationIpAllowListResultOutput) ToGetOrganizationIpAllowListResultOutput() GetOrganizationIpAllowListResultOutput { + return o +} + +func (o GetOrganizationIpAllowListResultOutput) ToGetOrganizationIpAllowListResultOutputWithContext(ctx context.Context) GetOrganizationIpAllowListResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetOrganizationIpAllowListResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationIpAllowListResult) string { return v.Id }).(pulumi.StringOutput) +} + +// An Array of allowed IP addresses. +// *** +func (o GetOrganizationIpAllowListResultOutput) IpAllowLists() GetOrganizationIpAllowListIpAllowListArrayOutput { + return o.ApplyT(func(v GetOrganizationIpAllowListResult) []GetOrganizationIpAllowListIpAllowList { + return v.IpAllowLists + }).(GetOrganizationIpAllowListIpAllowListArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetOrganizationIpAllowListResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRepositoryRole.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRepositoryRole.go new file mode 100644 index 000000000..f10650576 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRepositoryRole.go @@ -0,0 +1,141 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Lookup a custom organization repository role. +// +// > **Note**: Custom organization repository roles are currently only available in GitHub Enterprise Cloud. +// +// ## Example Usage +// +// ```go +// 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.GetOrganizationRepositoryRole(ctx, &github.LookupOrganizationRepositoryRoleArgs{ +// RoleId: 1234, +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupOrganizationRepositoryRole(ctx *pulumi.Context, args *LookupOrganizationRepositoryRoleArgs, opts ...pulumi.InvokeOption) (*LookupOrganizationRepositoryRoleResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupOrganizationRepositoryRoleResult + err := ctx.Invoke("github:index/getOrganizationRepositoryRole:getOrganizationRepositoryRole", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getOrganizationRepositoryRole. +type LookupOrganizationRepositoryRoleArgs struct { + // The ID of the organization repository role. + RoleId int `pulumi:"roleId"` +} + +// A collection of values returned by getOrganizationRepositoryRole. +type LookupOrganizationRepositoryRoleResult struct { + // The system role from which this role inherits permissions. + BaseRole string `pulumi:"baseRole"` + // The description of the organization repository role. + Description string `pulumi:"description"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The name of the organization repository role. + Name string `pulumi:"name"` + // The permissions included in this role. + Permissions []string `pulumi:"permissions"` + // The ID of the organization repository role. + RoleId int `pulumi:"roleId"` +} + +func LookupOrganizationRepositoryRoleOutput(ctx *pulumi.Context, args LookupOrganizationRepositoryRoleOutputArgs, opts ...pulumi.InvokeOption) LookupOrganizationRepositoryRoleResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupOrganizationRepositoryRoleResultOutput, error) { + args := v.(LookupOrganizationRepositoryRoleArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getOrganizationRepositoryRole:getOrganizationRepositoryRole", args, LookupOrganizationRepositoryRoleResultOutput{}, options).(LookupOrganizationRepositoryRoleResultOutput), nil + }).(LookupOrganizationRepositoryRoleResultOutput) +} + +// A collection of arguments for invoking getOrganizationRepositoryRole. +type LookupOrganizationRepositoryRoleOutputArgs struct { + // The ID of the organization repository role. + RoleId pulumi.IntInput `pulumi:"roleId"` +} + +func (LookupOrganizationRepositoryRoleOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupOrganizationRepositoryRoleArgs)(nil)).Elem() +} + +// A collection of values returned by getOrganizationRepositoryRole. +type LookupOrganizationRepositoryRoleResultOutput struct{ *pulumi.OutputState } + +func (LookupOrganizationRepositoryRoleResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupOrganizationRepositoryRoleResult)(nil)).Elem() +} + +func (o LookupOrganizationRepositoryRoleResultOutput) ToLookupOrganizationRepositoryRoleResultOutput() LookupOrganizationRepositoryRoleResultOutput { + return o +} + +func (o LookupOrganizationRepositoryRoleResultOutput) ToLookupOrganizationRepositoryRoleResultOutputWithContext(ctx context.Context) LookupOrganizationRepositoryRoleResultOutput { + return o +} + +// The system role from which this role inherits permissions. +func (o LookupOrganizationRepositoryRoleResultOutput) BaseRole() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationRepositoryRoleResult) string { return v.BaseRole }).(pulumi.StringOutput) +} + +// The description of the organization repository role. +func (o LookupOrganizationRepositoryRoleResultOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationRepositoryRoleResult) string { return v.Description }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupOrganizationRepositoryRoleResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationRepositoryRoleResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The name of the organization repository role. +func (o LookupOrganizationRepositoryRoleResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationRepositoryRoleResult) string { return v.Name }).(pulumi.StringOutput) +} + +// The permissions included in this role. +func (o LookupOrganizationRepositoryRoleResultOutput) Permissions() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupOrganizationRepositoryRoleResult) []string { return v.Permissions }).(pulumi.StringArrayOutput) +} + +// The ID of the organization repository role. +func (o LookupOrganizationRepositoryRoleResultOutput) RoleId() pulumi.IntOutput { + return o.ApplyT(func(v LookupOrganizationRepositoryRoleResult) int { return v.RoleId }).(pulumi.IntOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupOrganizationRepositoryRoleResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRepositoryRoles.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRepositoryRoles.go new file mode 100644 index 000000000..3b735816c --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRepositoryRoles.go @@ -0,0 +1,103 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Lookup all custom repository roles in an organization. +// +// > **Note**: Custom organization repository roles are currently only available in GitHub Enterprise Cloud. +// +// ## Example Usage +// +// ```go +// 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.GetOrganizationRepositoryRoles(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Nested Schema for `roles` +// +// ### Read-Only +// +// - `roleId` (Number) The ID of the organization repository role. +// - `name` (String) The name of the organization repository role. +// - `description` (String) The description of the organization repository role. +// - `baseRole` (String) The system role from which this role inherits permissions. +// - `permissions` (Set of String) The permissions included in this role. +func GetOrganizationRepositoryRoles(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetOrganizationRepositoryRolesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetOrganizationRepositoryRolesResult + err := ctx.Invoke("github:index/getOrganizationRepositoryRoles:getOrganizationRepositoryRoles", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getOrganizationRepositoryRoles. +type GetOrganizationRepositoryRolesResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // (Set of Object, see schema) Available organization repository roles. + Roles []GetOrganizationRepositoryRolesRole `pulumi:"roles"` +} + +func GetOrganizationRepositoryRolesOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetOrganizationRepositoryRolesResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetOrganizationRepositoryRolesResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getOrganizationRepositoryRoles:getOrganizationRepositoryRoles", nil, GetOrganizationRepositoryRolesResultOutput{}, options).(GetOrganizationRepositoryRolesResultOutput), nil + }).(GetOrganizationRepositoryRolesResultOutput) +} + +// A collection of values returned by getOrganizationRepositoryRoles. +type GetOrganizationRepositoryRolesResultOutput struct{ *pulumi.OutputState } + +func (GetOrganizationRepositoryRolesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationRepositoryRolesResult)(nil)).Elem() +} + +func (o GetOrganizationRepositoryRolesResultOutput) ToGetOrganizationRepositoryRolesResultOutput() GetOrganizationRepositoryRolesResultOutput { + return o +} + +func (o GetOrganizationRepositoryRolesResultOutput) ToGetOrganizationRepositoryRolesResultOutputWithContext(ctx context.Context) GetOrganizationRepositoryRolesResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetOrganizationRepositoryRolesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationRepositoryRolesResult) string { return v.Id }).(pulumi.StringOutput) +} + +// (Set of Object, see schema) Available organization repository roles. +func (o GetOrganizationRepositoryRolesResultOutput) Roles() GetOrganizationRepositoryRolesRoleArrayOutput { + return o.ApplyT(func(v GetOrganizationRepositoryRolesResult) []GetOrganizationRepositoryRolesRole { return v.Roles }).(GetOrganizationRepositoryRolesRoleArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetOrganizationRepositoryRolesResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRole.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRole.go new file mode 100644 index 000000000..9124707cc --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRole.go @@ -0,0 +1,146 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Lookup a custom organization role. +// +// ## Example Usage +// +// ```go +// 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.GetOrganizationRole(ctx, &github.LookupOrganizationRoleArgs{ +// RoleId: 1234, +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupOrganizationRole(ctx *pulumi.Context, args *LookupOrganizationRoleArgs, opts ...pulumi.InvokeOption) (*LookupOrganizationRoleResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupOrganizationRoleResult + err := ctx.Invoke("github:index/getOrganizationRole:getOrganizationRole", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getOrganizationRole. +type LookupOrganizationRoleArgs struct { + // The ID of the organization role. + RoleId int `pulumi:"roleId"` +} + +// A collection of values returned by getOrganizationRole. +type LookupOrganizationRoleResult struct { + // The system role from which this role inherits permissions. + BaseRole string `pulumi:"baseRole"` + // The description of the organization role. + Description string `pulumi:"description"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The name of the organization role. + Name string `pulumi:"name"` + // The permissions included in this role. + Permissions []string `pulumi:"permissions"` + // The ID of the organization role. + RoleId int `pulumi:"roleId"` + // The source of this role; one of `Predefined`, `Organization`, or `Enterprise`. + Source string `pulumi:"source"` +} + +func LookupOrganizationRoleOutput(ctx *pulumi.Context, args LookupOrganizationRoleOutputArgs, opts ...pulumi.InvokeOption) LookupOrganizationRoleResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupOrganizationRoleResultOutput, error) { + args := v.(LookupOrganizationRoleArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getOrganizationRole:getOrganizationRole", args, LookupOrganizationRoleResultOutput{}, options).(LookupOrganizationRoleResultOutput), nil + }).(LookupOrganizationRoleResultOutput) +} + +// A collection of arguments for invoking getOrganizationRole. +type LookupOrganizationRoleOutputArgs struct { + // The ID of the organization role. + RoleId pulumi.IntInput `pulumi:"roleId"` +} + +func (LookupOrganizationRoleOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupOrganizationRoleArgs)(nil)).Elem() +} + +// A collection of values returned by getOrganizationRole. +type LookupOrganizationRoleResultOutput struct{ *pulumi.OutputState } + +func (LookupOrganizationRoleResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupOrganizationRoleResult)(nil)).Elem() +} + +func (o LookupOrganizationRoleResultOutput) ToLookupOrganizationRoleResultOutput() LookupOrganizationRoleResultOutput { + return o +} + +func (o LookupOrganizationRoleResultOutput) ToLookupOrganizationRoleResultOutputWithContext(ctx context.Context) LookupOrganizationRoleResultOutput { + return o +} + +// The system role from which this role inherits permissions. +func (o LookupOrganizationRoleResultOutput) BaseRole() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationRoleResult) string { return v.BaseRole }).(pulumi.StringOutput) +} + +// The description of the organization role. +func (o LookupOrganizationRoleResultOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationRoleResult) string { return v.Description }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupOrganizationRoleResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationRoleResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The name of the organization role. +func (o LookupOrganizationRoleResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationRoleResult) string { return v.Name }).(pulumi.StringOutput) +} + +// The permissions included in this role. +func (o LookupOrganizationRoleResultOutput) Permissions() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupOrganizationRoleResult) []string { return v.Permissions }).(pulumi.StringArrayOutput) +} + +// The ID of the organization role. +func (o LookupOrganizationRoleResultOutput) RoleId() pulumi.IntOutput { + return o.ApplyT(func(v LookupOrganizationRoleResult) int { return v.RoleId }).(pulumi.IntOutput) +} + +// The source of this role; one of `Predefined`, `Organization`, or `Enterprise`. +func (o LookupOrganizationRoleResultOutput) Source() pulumi.StringOutput { + return o.ApplyT(func(v LookupOrganizationRoleResult) string { return v.Source }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupOrganizationRoleResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRoleTeams.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRoleTeams.go new file mode 100644 index 000000000..083651627 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRoleTeams.go @@ -0,0 +1,127 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Lookup all teams assigned to a custom organization role. +// +// ## Example Usage +// +// ```go +// 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.GetOrganizationRoleTeams(ctx, &github.GetOrganizationRoleTeamsArgs{ +// RoleId: 1234, +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Nested Schema for `teams` +// +// ### Read-Only +// +// - `teamId` (Number) The ID of the team. +// - `slug` (String) The Slug of the team name. +// - `name` (String) The name of the team. +// - `permission` (String) The permission that the team will have for its repositories. +func GetOrganizationRoleTeams(ctx *pulumi.Context, args *GetOrganizationRoleTeamsArgs, opts ...pulumi.InvokeOption) (*GetOrganizationRoleTeamsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetOrganizationRoleTeamsResult + err := ctx.Invoke("github:index/getOrganizationRoleTeams:getOrganizationRoleTeams", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getOrganizationRoleTeams. +type GetOrganizationRoleTeamsArgs struct { + // The ID of the organization role. + RoleId int `pulumi:"roleId"` +} + +// A collection of values returned by getOrganizationRoleTeams. +type GetOrganizationRoleTeamsResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The ID of the organization role. + RoleId int `pulumi:"roleId"` + // (Set of Object, see schema) Teams assigned to the organization role. + Teams []GetOrganizationRoleTeamsTeam `pulumi:"teams"` +} + +func GetOrganizationRoleTeamsOutput(ctx *pulumi.Context, args GetOrganizationRoleTeamsOutputArgs, opts ...pulumi.InvokeOption) GetOrganizationRoleTeamsResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetOrganizationRoleTeamsResultOutput, error) { + args := v.(GetOrganizationRoleTeamsArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getOrganizationRoleTeams:getOrganizationRoleTeams", args, GetOrganizationRoleTeamsResultOutput{}, options).(GetOrganizationRoleTeamsResultOutput), nil + }).(GetOrganizationRoleTeamsResultOutput) +} + +// A collection of arguments for invoking getOrganizationRoleTeams. +type GetOrganizationRoleTeamsOutputArgs struct { + // The ID of the organization role. + RoleId pulumi.IntInput `pulumi:"roleId"` +} + +func (GetOrganizationRoleTeamsOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationRoleTeamsArgs)(nil)).Elem() +} + +// A collection of values returned by getOrganizationRoleTeams. +type GetOrganizationRoleTeamsResultOutput struct{ *pulumi.OutputState } + +func (GetOrganizationRoleTeamsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationRoleTeamsResult)(nil)).Elem() +} + +func (o GetOrganizationRoleTeamsResultOutput) ToGetOrganizationRoleTeamsResultOutput() GetOrganizationRoleTeamsResultOutput { + return o +} + +func (o GetOrganizationRoleTeamsResultOutput) ToGetOrganizationRoleTeamsResultOutputWithContext(ctx context.Context) GetOrganizationRoleTeamsResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetOrganizationRoleTeamsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationRoleTeamsResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The ID of the organization role. +func (o GetOrganizationRoleTeamsResultOutput) RoleId() pulumi.IntOutput { + return o.ApplyT(func(v GetOrganizationRoleTeamsResult) int { return v.RoleId }).(pulumi.IntOutput) +} + +// (Set of Object, see schema) Teams assigned to the organization role. +func (o GetOrganizationRoleTeamsResultOutput) Teams() GetOrganizationRoleTeamsTeamArrayOutput { + return o.ApplyT(func(v GetOrganizationRoleTeamsResult) []GetOrganizationRoleTeamsTeam { return v.Teams }).(GetOrganizationRoleTeamsTeamArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetOrganizationRoleTeamsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRoleUsers.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRoleUsers.go new file mode 100644 index 000000000..523723d51 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRoleUsers.go @@ -0,0 +1,125 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Lookup all users assigned to a custom organization role. +// +// ## Example Usage +// +// ```go +// 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.GetOrganizationRoleUsers(ctx, &github.GetOrganizationRoleUsersArgs{ +// RoleId: 1234, +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Nested Schema for `users` +// +// ### Read-Only +// +// - `userId` (Number) The ID of the user. +// - `login` (String) The login for the GitHub user account. +func GetOrganizationRoleUsers(ctx *pulumi.Context, args *GetOrganizationRoleUsersArgs, opts ...pulumi.InvokeOption) (*GetOrganizationRoleUsersResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetOrganizationRoleUsersResult + err := ctx.Invoke("github:index/getOrganizationRoleUsers:getOrganizationRoleUsers", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getOrganizationRoleUsers. +type GetOrganizationRoleUsersArgs struct { + // The ID of the organization role. + RoleId int `pulumi:"roleId"` +} + +// A collection of values returned by getOrganizationRoleUsers. +type GetOrganizationRoleUsersResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The ID of the organization role. + RoleId int `pulumi:"roleId"` + // (Set of Object, see schema) Users assigned to the organization role. + Users []GetOrganizationRoleUsersUser `pulumi:"users"` +} + +func GetOrganizationRoleUsersOutput(ctx *pulumi.Context, args GetOrganizationRoleUsersOutputArgs, opts ...pulumi.InvokeOption) GetOrganizationRoleUsersResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetOrganizationRoleUsersResultOutput, error) { + args := v.(GetOrganizationRoleUsersArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getOrganizationRoleUsers:getOrganizationRoleUsers", args, GetOrganizationRoleUsersResultOutput{}, options).(GetOrganizationRoleUsersResultOutput), nil + }).(GetOrganizationRoleUsersResultOutput) +} + +// A collection of arguments for invoking getOrganizationRoleUsers. +type GetOrganizationRoleUsersOutputArgs struct { + // The ID of the organization role. + RoleId pulumi.IntInput `pulumi:"roleId"` +} + +func (GetOrganizationRoleUsersOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationRoleUsersArgs)(nil)).Elem() +} + +// A collection of values returned by getOrganizationRoleUsers. +type GetOrganizationRoleUsersResultOutput struct{ *pulumi.OutputState } + +func (GetOrganizationRoleUsersResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationRoleUsersResult)(nil)).Elem() +} + +func (o GetOrganizationRoleUsersResultOutput) ToGetOrganizationRoleUsersResultOutput() GetOrganizationRoleUsersResultOutput { + return o +} + +func (o GetOrganizationRoleUsersResultOutput) ToGetOrganizationRoleUsersResultOutputWithContext(ctx context.Context) GetOrganizationRoleUsersResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetOrganizationRoleUsersResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationRoleUsersResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The ID of the organization role. +func (o GetOrganizationRoleUsersResultOutput) RoleId() pulumi.IntOutput { + return o.ApplyT(func(v GetOrganizationRoleUsersResult) int { return v.RoleId }).(pulumi.IntOutput) +} + +// (Set of Object, see schema) Users assigned to the organization role. +func (o GetOrganizationRoleUsersResultOutput) Users() GetOrganizationRoleUsersUserArrayOutput { + return o.ApplyT(func(v GetOrganizationRoleUsersResult) []GetOrganizationRoleUsersUser { return v.Users }).(GetOrganizationRoleUsersUserArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetOrganizationRoleUsersResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRoles.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRoles.go new file mode 100644 index 000000000..1b5a6c598 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationRoles.go @@ -0,0 +1,102 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Lookup all custom roles in an organization. +// +// ## Example Usage +// +// ```go +// 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.GetOrganizationRoles(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Nested Schema for `roles` +// +// ### Read-Only +// +// - `roleId` (Number) The ID of the organization role. +// - `name` (String) The name of the organization role. +// - `description` (String) The description of the organization role. +// - `source` (String) The source of this role; one of `Predefined`, `Organization`, or `Enterprise`. +// - `baseRole` (String) The system role from which this role inherits permissions. +// - `permissions` (Set of String) The permissions included in this role. +func GetOrganizationRoles(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetOrganizationRolesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetOrganizationRolesResult + err := ctx.Invoke("github:index/getOrganizationRoles:getOrganizationRoles", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getOrganizationRoles. +type GetOrganizationRolesResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // (Set of Object, see schema) Available organization roles. + Roles []GetOrganizationRolesRole `pulumi:"roles"` +} + +func GetOrganizationRolesOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetOrganizationRolesResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetOrganizationRolesResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getOrganizationRoles:getOrganizationRoles", nil, GetOrganizationRolesResultOutput{}, options).(GetOrganizationRolesResultOutput), nil + }).(GetOrganizationRolesResultOutput) +} + +// A collection of values returned by getOrganizationRoles. +type GetOrganizationRolesResultOutput struct{ *pulumi.OutputState } + +func (GetOrganizationRolesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationRolesResult)(nil)).Elem() +} + +func (o GetOrganizationRolesResultOutput) ToGetOrganizationRolesResultOutput() GetOrganizationRolesResultOutput { + return o +} + +func (o GetOrganizationRolesResultOutput) ToGetOrganizationRolesResultOutputWithContext(ctx context.Context) GetOrganizationRolesResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetOrganizationRolesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationRolesResult) string { return v.Id }).(pulumi.StringOutput) +} + +// (Set of Object, see schema) Available organization roles. +func (o GetOrganizationRolesResultOutput) Roles() GetOrganizationRolesRoleArrayOutput { + return o.ApplyT(func(v GetOrganizationRolesResult) []GetOrganizationRolesRole { return v.Roles }).(GetOrganizationRolesRoleArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetOrganizationRolesResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationSecurityManagers.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationSecurityManagers.go new file mode 100644 index 000000000..87ceb1d56 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationSecurityManagers.go @@ -0,0 +1,93 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// > **Note:** This data source is deprecated, please use the `OrganizationRoleTeam` resource instead. +// +// Use this data source to retrieve the security managers for an organization. +// +// ## Example Usage +// +// ```go +// 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.GetOrganizationSecurityManagers(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetOrganizationSecurityManagers(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetOrganizationSecurityManagersResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetOrganizationSecurityManagersResult + err := ctx.Invoke("github:index/getOrganizationSecurityManagers:getOrganizationSecurityManagers", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getOrganizationSecurityManagers. +type GetOrganizationSecurityManagersResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // An list of GitHub teams. Each `team` block consists of the fields documented below. + Teams []GetOrganizationSecurityManagersTeam `pulumi:"teams"` +} + +func GetOrganizationSecurityManagersOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetOrganizationSecurityManagersResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetOrganizationSecurityManagersResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getOrganizationSecurityManagers:getOrganizationSecurityManagers", nil, GetOrganizationSecurityManagersResultOutput{}, options).(GetOrganizationSecurityManagersResultOutput), nil + }).(GetOrganizationSecurityManagersResultOutput) +} + +// A collection of values returned by getOrganizationSecurityManagers. +type GetOrganizationSecurityManagersResultOutput struct{ *pulumi.OutputState } + +func (GetOrganizationSecurityManagersResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationSecurityManagersResult)(nil)).Elem() +} + +func (o GetOrganizationSecurityManagersResultOutput) ToGetOrganizationSecurityManagersResultOutput() GetOrganizationSecurityManagersResultOutput { + return o +} + +func (o GetOrganizationSecurityManagersResultOutput) ToGetOrganizationSecurityManagersResultOutputWithContext(ctx context.Context) GetOrganizationSecurityManagersResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetOrganizationSecurityManagersResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationSecurityManagersResult) string { return v.Id }).(pulumi.StringOutput) +} + +// An list of GitHub teams. Each `team` block consists of the fields documented below. +func (o GetOrganizationSecurityManagersResultOutput) Teams() GetOrganizationSecurityManagersTeamArrayOutput { + return o.ApplyT(func(v GetOrganizationSecurityManagersResult) []GetOrganizationSecurityManagersTeam { return v.Teams }).(GetOrganizationSecurityManagersTeamArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetOrganizationSecurityManagersResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationTeamSyncGroups.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationTeamSyncGroups.go new file mode 100644 index 000000000..355a25e60 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationTeamSyncGroups.go @@ -0,0 +1,91 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the identity provider (IdP) groups for an organization. +// +// ## Example Usage +// +// ```go +// 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.GetOrganizationTeamSyncGroups(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetOrganizationTeamSyncGroups(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetOrganizationTeamSyncGroupsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetOrganizationTeamSyncGroupsResult + err := ctx.Invoke("github:index/getOrganizationTeamSyncGroups:getOrganizationTeamSyncGroups", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getOrganizationTeamSyncGroups. +type GetOrganizationTeamSyncGroupsResult struct { + // An Array of GitHub Identity Provider Groups. Each `group` block consists of the fields documented below. + Groups []GetOrganizationTeamSyncGroupsGroup `pulumi:"groups"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` +} + +func GetOrganizationTeamSyncGroupsOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetOrganizationTeamSyncGroupsResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetOrganizationTeamSyncGroupsResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getOrganizationTeamSyncGroups:getOrganizationTeamSyncGroups", nil, GetOrganizationTeamSyncGroupsResultOutput{}, options).(GetOrganizationTeamSyncGroupsResultOutput), nil + }).(GetOrganizationTeamSyncGroupsResultOutput) +} + +// A collection of values returned by getOrganizationTeamSyncGroups. +type GetOrganizationTeamSyncGroupsResultOutput struct{ *pulumi.OutputState } + +func (GetOrganizationTeamSyncGroupsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationTeamSyncGroupsResult)(nil)).Elem() +} + +func (o GetOrganizationTeamSyncGroupsResultOutput) ToGetOrganizationTeamSyncGroupsResultOutput() GetOrganizationTeamSyncGroupsResultOutput { + return o +} + +func (o GetOrganizationTeamSyncGroupsResultOutput) ToGetOrganizationTeamSyncGroupsResultOutputWithContext(ctx context.Context) GetOrganizationTeamSyncGroupsResultOutput { + return o +} + +// An Array of GitHub Identity Provider Groups. Each `group` block consists of the fields documented below. +func (o GetOrganizationTeamSyncGroupsResultOutput) Groups() GetOrganizationTeamSyncGroupsGroupArrayOutput { + return o.ApplyT(func(v GetOrganizationTeamSyncGroupsResult) []GetOrganizationTeamSyncGroupsGroup { return v.Groups }).(GetOrganizationTeamSyncGroupsGroupArrayOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetOrganizationTeamSyncGroupsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationTeamSyncGroupsResult) string { return v.Id }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetOrganizationTeamSyncGroupsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationTeams.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationTeams.go new file mode 100644 index 000000000..fc48ebad6 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationTeams.go @@ -0,0 +1,166 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about all GitHub teams in an organization. +// +// ## Example Usage +// +// To retrieve *all* teams of the organization: +// +// ```go +// 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.GetOrganizationTeams(ctx, &github.GetOrganizationTeamsArgs{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// To retrieve only the team's at the root of the organization: +// +// ```go +// 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.GetOrganizationTeams(ctx, &github.GetOrganizationTeamsArgs{ +// RootTeamsOnly: pulumi.BoolRef(true), +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetOrganizationTeams(ctx *pulumi.Context, args *GetOrganizationTeamsArgs, opts ...pulumi.InvokeOption) (*GetOrganizationTeamsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetOrganizationTeamsResult + err := ctx.Invoke("github:index/getOrganizationTeams:getOrganizationTeams", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getOrganizationTeams. +type GetOrganizationTeamsArgs struct { + // (Optional) Set the number of results per graphql query. Reducing this number can alleviate timeout errors. Accepts a value between 0 - 100. Defaults to `100`. + ResultsPerPage *int `pulumi:"resultsPerPage"` + // (Optional) Only return teams that are at the organization's root, i.e. no nested teams. Defaults to `false`. + RootTeamsOnly *bool `pulumi:"rootTeamsOnly"` + // (Optional) Exclude the members and repositories of the team from the returned result. Defaults to `false`. + SummaryOnly *bool `pulumi:"summaryOnly"` +} + +// A collection of values returned by getOrganizationTeams. +type GetOrganizationTeamsResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // (Optional) Set the number of results per graphql query. Reducing this number can alleviate timeout errors. Accepts a value between 0 - 100. Defaults to `100`. + ResultsPerPage *int `pulumi:"resultsPerPage"` + // (Optional) Only return teams that are at the organization's root, i.e. no nested teams. Defaults to `false`. + RootTeamsOnly *bool `pulumi:"rootTeamsOnly"` + // (Optional) Exclude the members and repositories of the team from the returned result. Defaults to `false`. + SummaryOnly *bool `pulumi:"summaryOnly"` + // (Required) An Array of GitHub Teams. Each `team` block consists of the fields documented below. + Teams []GetOrganizationTeamsTeam `pulumi:"teams"` +} + +func GetOrganizationTeamsOutput(ctx *pulumi.Context, args GetOrganizationTeamsOutputArgs, opts ...pulumi.InvokeOption) GetOrganizationTeamsResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetOrganizationTeamsResultOutput, error) { + args := v.(GetOrganizationTeamsArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getOrganizationTeams:getOrganizationTeams", args, GetOrganizationTeamsResultOutput{}, options).(GetOrganizationTeamsResultOutput), nil + }).(GetOrganizationTeamsResultOutput) +} + +// A collection of arguments for invoking getOrganizationTeams. +type GetOrganizationTeamsOutputArgs struct { + // (Optional) Set the number of results per graphql query. Reducing this number can alleviate timeout errors. Accepts a value between 0 - 100. Defaults to `100`. + ResultsPerPage pulumi.IntPtrInput `pulumi:"resultsPerPage"` + // (Optional) Only return teams that are at the organization's root, i.e. no nested teams. Defaults to `false`. + RootTeamsOnly pulumi.BoolPtrInput `pulumi:"rootTeamsOnly"` + // (Optional) Exclude the members and repositories of the team from the returned result. Defaults to `false`. + SummaryOnly pulumi.BoolPtrInput `pulumi:"summaryOnly"` +} + +func (GetOrganizationTeamsOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationTeamsArgs)(nil)).Elem() +} + +// A collection of values returned by getOrganizationTeams. +type GetOrganizationTeamsResultOutput struct{ *pulumi.OutputState } + +func (GetOrganizationTeamsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationTeamsResult)(nil)).Elem() +} + +func (o GetOrganizationTeamsResultOutput) ToGetOrganizationTeamsResultOutput() GetOrganizationTeamsResultOutput { + return o +} + +func (o GetOrganizationTeamsResultOutput) ToGetOrganizationTeamsResultOutputWithContext(ctx context.Context) GetOrganizationTeamsResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetOrganizationTeamsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationTeamsResult) string { return v.Id }).(pulumi.StringOutput) +} + +// (Optional) Set the number of results per graphql query. Reducing this number can alleviate timeout errors. Accepts a value between 0 - 100. Defaults to `100`. +func (o GetOrganizationTeamsResultOutput) ResultsPerPage() pulumi.IntPtrOutput { + return o.ApplyT(func(v GetOrganizationTeamsResult) *int { return v.ResultsPerPage }).(pulumi.IntPtrOutput) +} + +// (Optional) Only return teams that are at the organization's root, i.e. no nested teams. Defaults to `false`. +func (o GetOrganizationTeamsResultOutput) RootTeamsOnly() pulumi.BoolPtrOutput { + return o.ApplyT(func(v GetOrganizationTeamsResult) *bool { return v.RootTeamsOnly }).(pulumi.BoolPtrOutput) +} + +// (Optional) Exclude the members and repositories of the team from the returned result. Defaults to `false`. +func (o GetOrganizationTeamsResultOutput) SummaryOnly() pulumi.BoolPtrOutput { + return o.ApplyT(func(v GetOrganizationTeamsResult) *bool { return v.SummaryOnly }).(pulumi.BoolPtrOutput) +} + +// (Required) An Array of GitHub Teams. Each `team` block consists of the fields documented below. +func (o GetOrganizationTeamsResultOutput) Teams() GetOrganizationTeamsTeamArrayOutput { + return o.ApplyT(func(v GetOrganizationTeamsResult) []GetOrganizationTeamsTeam { return v.Teams }).(GetOrganizationTeamsTeamArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetOrganizationTeamsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationWebhooks.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationWebhooks.go new file mode 100644 index 000000000..fc975d176 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getOrganizationWebhooks.go @@ -0,0 +1,95 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve all webhooks of the organization. +// +// ## Example Usage +// +// To retrieve *all* webhooks of the organization: +// +// ```go +// 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.GetOrganizationWebhooks(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetOrganizationWebhooks(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetOrganizationWebhooksResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetOrganizationWebhooksResult + err := ctx.Invoke("github:index/getOrganizationWebhooks:getOrganizationWebhooks", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getOrganizationWebhooks. +type GetOrganizationWebhooksResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // An Array of GitHub Webhooks. Each `webhook` block consists of the fields documented below. + // *** + Webhooks []GetOrganizationWebhooksWebhook `pulumi:"webhooks"` +} + +func GetOrganizationWebhooksOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetOrganizationWebhooksResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetOrganizationWebhooksResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getOrganizationWebhooks:getOrganizationWebhooks", nil, GetOrganizationWebhooksResultOutput{}, options).(GetOrganizationWebhooksResultOutput), nil + }).(GetOrganizationWebhooksResultOutput) +} + +// A collection of values returned by getOrganizationWebhooks. +type GetOrganizationWebhooksResultOutput struct{ *pulumi.OutputState } + +func (GetOrganizationWebhooksResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationWebhooksResult)(nil)).Elem() +} + +func (o GetOrganizationWebhooksResultOutput) ToGetOrganizationWebhooksResultOutput() GetOrganizationWebhooksResultOutput { + return o +} + +func (o GetOrganizationWebhooksResultOutput) ToGetOrganizationWebhooksResultOutputWithContext(ctx context.Context) GetOrganizationWebhooksResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetOrganizationWebhooksResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationWebhooksResult) string { return v.Id }).(pulumi.StringOutput) +} + +// An Array of GitHub Webhooks. Each `webhook` block consists of the fields documented below. +// *** +func (o GetOrganizationWebhooksResultOutput) Webhooks() GetOrganizationWebhooksWebhookArrayOutput { + return o.ApplyT(func(v GetOrganizationWebhooksResult) []GetOrganizationWebhooksWebhook { return v.Webhooks }).(GetOrganizationWebhooksWebhookArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetOrganizationWebhooksResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRef.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRef.go new file mode 100644 index 000000000..a87d9dd88 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRef.go @@ -0,0 +1,143 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a repository ref. +// +// ## Example Usage +// +// ```go +// 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.GetRef(ctx, &github.GetRefArgs{ +// Owner: pulumi.StringRef("example"), +// Repository: "example", +// Ref: "heads/development", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetRef(ctx *pulumi.Context, args *GetRefArgs, opts ...pulumi.InvokeOption) (*GetRefResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetRefResult + err := ctx.Invoke("github:index/getRef:getRef", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRef. +type GetRefArgs struct { + // Owner of the repository. + Owner *string `pulumi:"owner"` + // The repository ref to look up. Must be formatted `heads/` for branches, and `tags/` for tags. + Ref string `pulumi:"ref"` + // The GitHub repository name. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getRef. +type GetRefResult struct { + // An etag representing the ref. + Etag string `pulumi:"etag"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Owner *string `pulumi:"owner"` + Ref string `pulumi:"ref"` + Repository string `pulumi:"repository"` + // A string storing the reference's `HEAD` commit's SHA1. + Sha string `pulumi:"sha"` +} + +func GetRefOutput(ctx *pulumi.Context, args GetRefOutputArgs, opts ...pulumi.InvokeOption) GetRefResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetRefResultOutput, error) { + args := v.(GetRefArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRef:getRef", args, GetRefResultOutput{}, options).(GetRefResultOutput), nil + }).(GetRefResultOutput) +} + +// A collection of arguments for invoking getRef. +type GetRefOutputArgs struct { + // Owner of the repository. + Owner pulumi.StringPtrInput `pulumi:"owner"` + // The repository ref to look up. Must be formatted `heads/` for branches, and `tags/` for tags. + Ref pulumi.StringInput `pulumi:"ref"` + // The GitHub repository name. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetRefOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRefArgs)(nil)).Elem() +} + +// A collection of values returned by getRef. +type GetRefResultOutput struct{ *pulumi.OutputState } + +func (GetRefResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRefResult)(nil)).Elem() +} + +func (o GetRefResultOutput) ToGetRefResultOutput() GetRefResultOutput { + return o +} + +func (o GetRefResultOutput) ToGetRefResultOutputWithContext(ctx context.Context) GetRefResultOutput { + return o +} + +// An etag representing the ref. +func (o GetRefResultOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v GetRefResult) string { return v.Etag }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetRefResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetRefResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetRefResultOutput) Owner() pulumi.StringPtrOutput { + return o.ApplyT(func(v GetRefResult) *string { return v.Owner }).(pulumi.StringPtrOutput) +} + +func (o GetRefResultOutput) Ref() pulumi.StringOutput { + return o.ApplyT(func(v GetRefResult) string { return v.Ref }).(pulumi.StringOutput) +} + +func (o GetRefResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetRefResult) string { return v.Repository }).(pulumi.StringOutput) +} + +// A string storing the reference's `HEAD` commit's SHA1. +func (o GetRefResultOutput) Sha() pulumi.StringOutput { + return o.ApplyT(func(v GetRefResult) string { return v.Sha }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetRefResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRelease.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRelease.go new file mode 100644 index 000000000..cb550d36d --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRelease.go @@ -0,0 +1,293 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a GitHub release in a specific repository. +// +// ## Example Usage +// +// To retrieve the latest release that is present in a repository: +// +// ```go +// 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.GetRelease(ctx, &github.LookupReleaseArgs{ +// Repository: "example-repository", +// Owner: "example-owner", +// RetrieveBy: "latest", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// To retrieve a specific release from a repository based on its ID: +// +// Finally, to retrieve a release based on its tag: +// +// ```go +// 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.GetRelease(ctx, &github.LookupReleaseArgs{ +// Repository: "example-repository", +// Owner: "example-owner", +// RetrieveBy: "tag", +// ReleaseTag: pulumi.StringRef("v1.0.0"), +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupRelease(ctx *pulumi.Context, args *LookupReleaseArgs, opts ...pulumi.InvokeOption) (*LookupReleaseResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupReleaseResult + err := ctx.Invoke("github:index/getRelease:getRelease", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRelease. +type LookupReleaseArgs struct { + // Owner of the repository. + Owner string `pulumi:"owner"` + // ID of the release to retrieve. Must be specified when `retrieveBy` = `id`. + ReleaseId *int `pulumi:"releaseId"` + // Tag of the release to retrieve. Must be specified when `retrieveBy` = `tag`. + ReleaseTag *string `pulumi:"releaseTag"` + // Name of the repository to retrieve the release from. + Repository string `pulumi:"repository"` + // Describes how to fetch the release. Valid values are `id`, `tag`, `latest`. + RetrieveBy string `pulumi:"retrieveBy"` +} + +// A collection of values returned by getRelease. +type LookupReleaseResult struct { + // **Deprecated**: Use `assetsUrl` resource instead + // + // Deprecated: use assetsUrl instead + AssertsUrl string `pulumi:"assertsUrl"` + // Collection of assets for the release. Each asset conforms to the following schema: + Assets []GetReleaseAsset `pulumi:"assets"` + // URL of any associated assets with the release + AssetsUrl string `pulumi:"assetsUrl"` + // Contents of the description (body) of a release + Body string `pulumi:"body"` + // Date the asset was created + CreatedAt string `pulumi:"createdAt"` + // (`Boolean`) indicates whether the release is a draft + Draft bool `pulumi:"draft"` + // URL directing to detailed information on the release + HtmlUrl string `pulumi:"htmlUrl"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The file name of the asset + Name string `pulumi:"name"` + Owner string `pulumi:"owner"` + // (`Boolean`) indicates whether the release is a prerelease + Prerelease bool `pulumi:"prerelease"` + // Date of release publishing + PublishedAt string `pulumi:"publishedAt"` + // ID of release + ReleaseId *int `pulumi:"releaseId"` + // Tag of release + ReleaseTag *string `pulumi:"releaseTag"` + Repository string `pulumi:"repository"` + RetrieveBy string `pulumi:"retrieveBy"` + // Download URL of a specific release in `tar.gz` format + TarballUrl string `pulumi:"tarballUrl"` + // Commitish value that determines where the Git release is created from + TargetCommitish string `pulumi:"targetCommitish"` + // URL that can be used to upload Assets to the release + UploadUrl string `pulumi:"uploadUrl"` + // URL of the asset + Url string `pulumi:"url"` + // Download URL of a specific release in `zip` format + ZipballUrl string `pulumi:"zipballUrl"` +} + +func LookupReleaseOutput(ctx *pulumi.Context, args LookupReleaseOutputArgs, opts ...pulumi.InvokeOption) LookupReleaseResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupReleaseResultOutput, error) { + args := v.(LookupReleaseArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRelease:getRelease", args, LookupReleaseResultOutput{}, options).(LookupReleaseResultOutput), nil + }).(LookupReleaseResultOutput) +} + +// A collection of arguments for invoking getRelease. +type LookupReleaseOutputArgs struct { + // Owner of the repository. + Owner pulumi.StringInput `pulumi:"owner"` + // ID of the release to retrieve. Must be specified when `retrieveBy` = `id`. + ReleaseId pulumi.IntPtrInput `pulumi:"releaseId"` + // Tag of the release to retrieve. Must be specified when `retrieveBy` = `tag`. + ReleaseTag pulumi.StringPtrInput `pulumi:"releaseTag"` + // Name of the repository to retrieve the release from. + Repository pulumi.StringInput `pulumi:"repository"` + // Describes how to fetch the release. Valid values are `id`, `tag`, `latest`. + RetrieveBy pulumi.StringInput `pulumi:"retrieveBy"` +} + +func (LookupReleaseOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupReleaseArgs)(nil)).Elem() +} + +// A collection of values returned by getRelease. +type LookupReleaseResultOutput struct{ *pulumi.OutputState } + +func (LookupReleaseResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupReleaseResult)(nil)).Elem() +} + +func (o LookupReleaseResultOutput) ToLookupReleaseResultOutput() LookupReleaseResultOutput { + return o +} + +func (o LookupReleaseResultOutput) ToLookupReleaseResultOutputWithContext(ctx context.Context) LookupReleaseResultOutput { + return o +} + +// **Deprecated**: Use `assetsUrl` resource instead +// +// Deprecated: use assetsUrl instead +func (o LookupReleaseResultOutput) AssertsUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseResult) string { return v.AssertsUrl }).(pulumi.StringOutput) +} + +// Collection of assets for the release. Each asset conforms to the following schema: +func (o LookupReleaseResultOutput) Assets() GetReleaseAssetArrayOutput { + return o.ApplyT(func(v LookupReleaseResult) []GetReleaseAsset { return v.Assets }).(GetReleaseAssetArrayOutput) +} + +// URL of any associated assets with the release +func (o LookupReleaseResultOutput) AssetsUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseResult) string { return v.AssetsUrl }).(pulumi.StringOutput) +} + +// Contents of the description (body) of a release +func (o LookupReleaseResultOutput) Body() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseResult) string { return v.Body }).(pulumi.StringOutput) +} + +// Date the asset was created +func (o LookupReleaseResultOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseResult) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// (`Boolean`) indicates whether the release is a draft +func (o LookupReleaseResultOutput) Draft() pulumi.BoolOutput { + return o.ApplyT(func(v LookupReleaseResult) bool { return v.Draft }).(pulumi.BoolOutput) +} + +// URL directing to detailed information on the release +func (o LookupReleaseResultOutput) HtmlUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseResult) string { return v.HtmlUrl }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupReleaseResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The file name of the asset +func (o LookupReleaseResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseResult) string { return v.Name }).(pulumi.StringOutput) +} + +func (o LookupReleaseResultOutput) Owner() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseResult) string { return v.Owner }).(pulumi.StringOutput) +} + +// (`Boolean`) indicates whether the release is a prerelease +func (o LookupReleaseResultOutput) Prerelease() pulumi.BoolOutput { + return o.ApplyT(func(v LookupReleaseResult) bool { return v.Prerelease }).(pulumi.BoolOutput) +} + +// Date of release publishing +func (o LookupReleaseResultOutput) PublishedAt() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseResult) string { return v.PublishedAt }).(pulumi.StringOutput) +} + +// ID of release +func (o LookupReleaseResultOutput) ReleaseId() pulumi.IntPtrOutput { + return o.ApplyT(func(v LookupReleaseResult) *int { return v.ReleaseId }).(pulumi.IntPtrOutput) +} + +// Tag of release +func (o LookupReleaseResultOutput) ReleaseTag() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupReleaseResult) *string { return v.ReleaseTag }).(pulumi.StringPtrOutput) +} + +func (o LookupReleaseResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseResult) string { return v.Repository }).(pulumi.StringOutput) +} + +func (o LookupReleaseResultOutput) RetrieveBy() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseResult) string { return v.RetrieveBy }).(pulumi.StringOutput) +} + +// Download URL of a specific release in `tar.gz` format +func (o LookupReleaseResultOutput) TarballUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseResult) string { return v.TarballUrl }).(pulumi.StringOutput) +} + +// Commitish value that determines where the Git release is created from +func (o LookupReleaseResultOutput) TargetCommitish() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseResult) string { return v.TargetCommitish }).(pulumi.StringOutput) +} + +// URL that can be used to upload Assets to the release +func (o LookupReleaseResultOutput) UploadUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseResult) string { return v.UploadUrl }).(pulumi.StringOutput) +} + +// URL of the asset +func (o LookupReleaseResultOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseResult) string { return v.Url }).(pulumi.StringOutput) +} + +// Download URL of a specific release in `zip` format +func (o LookupReleaseResultOutput) ZipballUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseResult) string { return v.ZipballUrl }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupReleaseResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getReleaseAsset.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getReleaseAsset.go new file mode 100644 index 000000000..44f0e8b04 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getReleaseAsset.go @@ -0,0 +1,251 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a GitHub release asset. +// +// ## Example Usage +// +// To retrieve a specific release asset from a repository based on its ID: +// +// ```go +// 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.GetReleaseAsset(ctx, &github.LookupReleaseAssetArgs{ +// Repository: "example-repository", +// Owner: "example-owner", +// AssetId: 12345, +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// To retrieve a specific release asset from a repository, and download the file +// into a `file` attribute on the data source: +// +// To retrieve the first release asset associated with the latest release in a repository: +// +// ```go +// 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.GetRelease(ctx, &github.LookupReleaseArgs{ +// Repository: "example-repository", +// Owner: "example-owner", +// RetrieveBy: "latest", +// }, nil) +// if err != nil { +// return err +// } +// _, err = github.GetReleaseAsset(ctx, &github.LookupReleaseAssetArgs{ +// Repository: "example-repository", +// Owner: "example-owner", +// AssetId: example.Assets[0].Id, +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// To retrieve all release assets associated with the the latest release in a repository: +func LookupReleaseAsset(ctx *pulumi.Context, args *LookupReleaseAssetArgs, opts ...pulumi.InvokeOption) (*LookupReleaseAssetResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupReleaseAssetResult + err := ctx.Invoke("github:index/getReleaseAsset:getReleaseAsset", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getReleaseAsset. +type LookupReleaseAssetArgs struct { + // ID of the release asset to retrieve + AssetId int `pulumi:"assetId"` + // Whether to download the asset file content into the `fileContents` attribute (defaults to `false`) + DownloadFileContents *bool `pulumi:"downloadFileContents"` + // Owner of the repository + Owner string `pulumi:"owner"` + // Name of the repository to retrieve the release from + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getReleaseAsset. +type LookupReleaseAssetResult struct { + AssetId int `pulumi:"assetId"` + // Browser URL from which the release asset can be downloaded + BrowserDownloadUrl string `pulumi:"browserDownloadUrl"` + // MIME type of the asset + ContentType string `pulumi:"contentType"` + // Date the asset was created + CreatedAt string `pulumi:"createdAt"` + DownloadFileContents *bool `pulumi:"downloadFileContents"` + // The base64-encoded release asset file contents (requires `downloadFileContents` to be `true`) + FileContents string `pulumi:"fileContents"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Label for the asset + Label string `pulumi:"label"` + // The file name of the asset + Name string `pulumi:"name"` + // Node ID of the asset + NodeId string `pulumi:"nodeId"` + Owner string `pulumi:"owner"` + Repository string `pulumi:"repository"` + // Asset size in bytes + Size int `pulumi:"size"` + // Date the asset was last updated + UpdatedAt string `pulumi:"updatedAt"` + // URL of the asset + Url string `pulumi:"url"` +} + +func LookupReleaseAssetOutput(ctx *pulumi.Context, args LookupReleaseAssetOutputArgs, opts ...pulumi.InvokeOption) LookupReleaseAssetResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupReleaseAssetResultOutput, error) { + args := v.(LookupReleaseAssetArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getReleaseAsset:getReleaseAsset", args, LookupReleaseAssetResultOutput{}, options).(LookupReleaseAssetResultOutput), nil + }).(LookupReleaseAssetResultOutput) +} + +// A collection of arguments for invoking getReleaseAsset. +type LookupReleaseAssetOutputArgs struct { + // ID of the release asset to retrieve + AssetId pulumi.IntInput `pulumi:"assetId"` + // Whether to download the asset file content into the `fileContents` attribute (defaults to `false`) + DownloadFileContents pulumi.BoolPtrInput `pulumi:"downloadFileContents"` + // Owner of the repository + Owner pulumi.StringInput `pulumi:"owner"` + // Name of the repository to retrieve the release from + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (LookupReleaseAssetOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupReleaseAssetArgs)(nil)).Elem() +} + +// A collection of values returned by getReleaseAsset. +type LookupReleaseAssetResultOutput struct{ *pulumi.OutputState } + +func (LookupReleaseAssetResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupReleaseAssetResult)(nil)).Elem() +} + +func (o LookupReleaseAssetResultOutput) ToLookupReleaseAssetResultOutput() LookupReleaseAssetResultOutput { + return o +} + +func (o LookupReleaseAssetResultOutput) ToLookupReleaseAssetResultOutputWithContext(ctx context.Context) LookupReleaseAssetResultOutput { + return o +} + +func (o LookupReleaseAssetResultOutput) AssetId() pulumi.IntOutput { + return o.ApplyT(func(v LookupReleaseAssetResult) int { return v.AssetId }).(pulumi.IntOutput) +} + +// Browser URL from which the release asset can be downloaded +func (o LookupReleaseAssetResultOutput) BrowserDownloadUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseAssetResult) string { return v.BrowserDownloadUrl }).(pulumi.StringOutput) +} + +// MIME type of the asset +func (o LookupReleaseAssetResultOutput) ContentType() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseAssetResult) string { return v.ContentType }).(pulumi.StringOutput) +} + +// Date the asset was created +func (o LookupReleaseAssetResultOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseAssetResult) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +func (o LookupReleaseAssetResultOutput) DownloadFileContents() pulumi.BoolPtrOutput { + return o.ApplyT(func(v LookupReleaseAssetResult) *bool { return v.DownloadFileContents }).(pulumi.BoolPtrOutput) +} + +// The base64-encoded release asset file contents (requires `downloadFileContents` to be `true`) +func (o LookupReleaseAssetResultOutput) FileContents() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseAssetResult) string { return v.FileContents }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupReleaseAssetResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseAssetResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Label for the asset +func (o LookupReleaseAssetResultOutput) Label() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseAssetResult) string { return v.Label }).(pulumi.StringOutput) +} + +// The file name of the asset +func (o LookupReleaseAssetResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseAssetResult) string { return v.Name }).(pulumi.StringOutput) +} + +// Node ID of the asset +func (o LookupReleaseAssetResultOutput) NodeId() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseAssetResult) string { return v.NodeId }).(pulumi.StringOutput) +} + +func (o LookupReleaseAssetResultOutput) Owner() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseAssetResult) string { return v.Owner }).(pulumi.StringOutput) +} + +func (o LookupReleaseAssetResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseAssetResult) string { return v.Repository }).(pulumi.StringOutput) +} + +// Asset size in bytes +func (o LookupReleaseAssetResultOutput) Size() pulumi.IntOutput { + return o.ApplyT(func(v LookupReleaseAssetResult) int { return v.Size }).(pulumi.IntOutput) +} + +// Date the asset was last updated +func (o LookupReleaseAssetResultOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseAssetResult) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// URL of the asset +func (o LookupReleaseAssetResultOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v LookupReleaseAssetResult) string { return v.Url }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupReleaseAssetResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositories.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositories.go new file mode 100644 index 000000000..a47e1a89e --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositories.go @@ -0,0 +1,162 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// > **Note:** The data source will return a maximum of `1000` repositories +// +// [as documented in official API docs](https://developer.github.com/v3/search/#about-the-search-api). +// +// Use this data source to retrieve a list of GitHub repositories using a search query. +// +// ## Example Usage +// +// ```go +// 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.GetRepositories(ctx, &github.GetRepositoriesArgs{ +// Query: "org:hashicorp language:Go", +// IncludeRepoId: pulumi.BoolRef(true), +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetRepositories(ctx *pulumi.Context, args *GetRepositoriesArgs, opts ...pulumi.InvokeOption) (*GetRepositoriesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetRepositoriesResult + err := ctx.Invoke("github:index/getRepositories:getRepositories", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRepositories. +type GetRepositoriesArgs struct { + // Returns a list of found repository IDs + IncludeRepoId *bool `pulumi:"includeRepoId"` + // Search query. See [documentation for the search syntax](https://help.github.com/articles/understanding-the-search-syntax/). + Query string `pulumi:"query"` + // Set the number of repositories requested per API call. Can be useful to decrease if requests are timing out or to increase to reduce the number of API calls. Defaults to 100. + ResultsPerPage *int `pulumi:"resultsPerPage"` + // Sorts the repositories returned by the specified attribute. Valid values include `stars`, `fork`, and `updated`. Defaults to `updated`. + Sort *string `pulumi:"sort"` +} + +// A collection of values returned by getRepositories. +type GetRepositoriesResult struct { + // A list of full names of found repositories (e.g. `hashicorp/terraform`) + FullNames []string `pulumi:"fullNames"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + IncludeRepoId *bool `pulumi:"includeRepoId"` + // A list of found repository names (e.g. `terraform`) + Names []string `pulumi:"names"` + Query string `pulumi:"query"` + // (Optional) A list of found repository IDs (e.g. `449898861`) + RepoIds []int `pulumi:"repoIds"` + ResultsPerPage *int `pulumi:"resultsPerPage"` + Sort *string `pulumi:"sort"` +} + +func GetRepositoriesOutput(ctx *pulumi.Context, args GetRepositoriesOutputArgs, opts ...pulumi.InvokeOption) GetRepositoriesResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetRepositoriesResultOutput, error) { + args := v.(GetRepositoriesArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRepositories:getRepositories", args, GetRepositoriesResultOutput{}, options).(GetRepositoriesResultOutput), nil + }).(GetRepositoriesResultOutput) +} + +// A collection of arguments for invoking getRepositories. +type GetRepositoriesOutputArgs struct { + // Returns a list of found repository IDs + IncludeRepoId pulumi.BoolPtrInput `pulumi:"includeRepoId"` + // Search query. See [documentation for the search syntax](https://help.github.com/articles/understanding-the-search-syntax/). + Query pulumi.StringInput `pulumi:"query"` + // Set the number of repositories requested per API call. Can be useful to decrease if requests are timing out or to increase to reduce the number of API calls. Defaults to 100. + ResultsPerPage pulumi.IntPtrInput `pulumi:"resultsPerPage"` + // Sorts the repositories returned by the specified attribute. Valid values include `stars`, `fork`, and `updated`. Defaults to `updated`. + Sort pulumi.StringPtrInput `pulumi:"sort"` +} + +func (GetRepositoriesOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoriesArgs)(nil)).Elem() +} + +// A collection of values returned by getRepositories. +type GetRepositoriesResultOutput struct{ *pulumi.OutputState } + +func (GetRepositoriesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoriesResult)(nil)).Elem() +} + +func (o GetRepositoriesResultOutput) ToGetRepositoriesResultOutput() GetRepositoriesResultOutput { + return o +} + +func (o GetRepositoriesResultOutput) ToGetRepositoriesResultOutputWithContext(ctx context.Context) GetRepositoriesResultOutput { + return o +} + +// A list of full names of found repositories (e.g. `hashicorp/terraform`) +func (o GetRepositoriesResultOutput) FullNames() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetRepositoriesResult) []string { return v.FullNames }).(pulumi.StringArrayOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetRepositoriesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoriesResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetRepositoriesResultOutput) IncludeRepoId() pulumi.BoolPtrOutput { + return o.ApplyT(func(v GetRepositoriesResult) *bool { return v.IncludeRepoId }).(pulumi.BoolPtrOutput) +} + +// A list of found repository names (e.g. `terraform`) +func (o GetRepositoriesResultOutput) Names() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetRepositoriesResult) []string { return v.Names }).(pulumi.StringArrayOutput) +} + +func (o GetRepositoriesResultOutput) Query() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoriesResult) string { return v.Query }).(pulumi.StringOutput) +} + +// (Optional) A list of found repository IDs (e.g. `449898861`) +func (o GetRepositoriesResultOutput) RepoIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v GetRepositoriesResult) []int { return v.RepoIds }).(pulumi.IntArrayOutput) +} + +func (o GetRepositoriesResultOutput) ResultsPerPage() pulumi.IntPtrOutput { + return o.ApplyT(func(v GetRepositoriesResult) *int { return v.ResultsPerPage }).(pulumi.IntPtrOutput) +} + +func (o GetRepositoriesResultOutput) Sort() pulumi.StringPtrOutput { + return o.ApplyT(func(v GetRepositoriesResult) *string { return v.Sort }).(pulumi.StringPtrOutput) +} + +func init() { + pulumi.RegisterOutputType(GetRepositoriesResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepository.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepository.go new file mode 100644 index 000000000..067566ff1 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepository.go @@ -0,0 +1,384 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a GitHub repository. +// +// ## Example Usage +// +// ```go +// 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.GetRepository(ctx, &github.LookupRepositoryArgs{ +// FullName: pulumi.StringRef("hashicorp/terraform"), +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupRepository(ctx *pulumi.Context, args *LookupRepositoryArgs, opts ...pulumi.InvokeOption) (*LookupRepositoryResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupRepositoryResult + err := ctx.Invoke("github:index/getRepository:getRepository", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRepository. +type LookupRepositoryArgs struct { + // A description of the license. + Description *string `pulumi:"description"` + // Full name of the repository (in `org/name` format). + FullName *string `pulumi:"fullName"` + // URL of a page describing the project. + HomepageUrl *string `pulumi:"homepageUrl"` + // The name of the repository. + Name *string `pulumi:"name"` +} + +// A collection of values returned by getRepository. +type LookupRepositoryResult struct { + // Whether the repository allows auto-merging pull requests. + AllowAutoMerge bool `pulumi:"allowAutoMerge"` + // Whether the repository allows private forking; this is only relevant if the repository is owned by an organization and is private or internal. + AllowForking bool `pulumi:"allowForking"` + // Whether the repository allows merge commits. + AllowMergeCommit bool `pulumi:"allowMergeCommit"` + // Whether the repository allows rebase merges. + AllowRebaseMerge bool `pulumi:"allowRebaseMerge"` + // Whether the repository allows squash merges. + AllowSquashMerge bool `pulumi:"allowSquashMerge"` + AllowUpdateBranch bool `pulumi:"allowUpdateBranch"` + // Whether the repository is archived. + Archived bool `pulumi:"archived"` + // The name of the default branch of the repository. + DefaultBranch string `pulumi:"defaultBranch"` + DeleteBranchOnMerge bool `pulumi:"deleteBranchOnMerge"` + // A description of the license. + Description *string `pulumi:"description"` + // Whether the repository is a fork. + Fork bool `pulumi:"fork"` + FullName string `pulumi:"fullName"` + // URL that can be provided to `git clone` to clone the repository anonymously via the git protocol. + GitCloneUrl string `pulumi:"gitCloneUrl"` + // Whether the repository has GitHub Discussions enabled. + HasDiscussions bool `pulumi:"hasDiscussions"` + // (**DEPRECATED**) Whether the repository has Downloads feature enabled. This attribute is no longer in use, but it hasn't been removed yet. It will be removed in a future version. See [this discussion](https://github.com/orgs/community/discussions/102145#discussioncomment-8351756). + // + // Deprecated: This attribute is no longer in use, but it hasn't been removed yet. It will be removed in a future version. See https://github.com/orgs/community/discussions/102145#discussioncomment-8351756 + HasDownloads bool `pulumi:"hasDownloads"` + // Whether the repository has GitHub Issues enabled. + HasIssues bool `pulumi:"hasIssues"` + // Whether the repository has the GitHub Projects enabled. + HasProjects bool `pulumi:"hasProjects"` + // Whether the repository has the GitHub Wiki enabled. + HasWiki bool `pulumi:"hasWiki"` + // URL of a page describing the project. + HomepageUrl *string `pulumi:"homepageUrl"` + // The URL to view the license details on GitHub. + HtmlUrl string `pulumi:"htmlUrl"` + // URL that can be provided to `git clone` to clone the repository via HTTPS. + HttpCloneUrl string `pulumi:"httpCloneUrl"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Whether the repository is a template repository. + IsTemplate bool `pulumi:"isTemplate"` + // The default value for a merge commit message. + MergeCommitMessage string `pulumi:"mergeCommitMessage"` + // The default value for a merge commit title. + MergeCommitTitle string `pulumi:"mergeCommitTitle"` + // The name of the license (e.g., "Apache License 2.0"). + Name string `pulumi:"name"` + // GraphQL global node id for use with v4 API + NodeId string `pulumi:"nodeId"` + // (**DEPRECATED**) The repository's GitHub Pages configuration. Use the `RepositoryPages` data source instead. This field will be removed in a future version. + // + // Deprecated: Use the RepositoryPages data source instead. This field will be removed in a future version. + Pages []GetRepositoryPage `pulumi:"pages"` + // The primary language used in the repository. + PrimaryLanguage string `pulumi:"primaryLanguage"` + // Whether the repository is private. + Private bool `pulumi:"private"` + // GitHub ID for the repository + RepoId int `pulumi:"repoId"` + // An Array of GitHub repository licenses. Each `repositoryLicense` block consists of the fields documented below. + RepositoryLicenses []GetRepositoryRepositoryLicense `pulumi:"repositoryLicenses"` + // The default value for a squash merge commit message. + SquashMergeCommitMessage string `pulumi:"squashMergeCommitMessage"` + // The default value for a squash merge commit title. + SquashMergeCommitTitle string `pulumi:"squashMergeCommitTitle"` + // URL that can be provided to `git clone` to clone the repository via SSH. + SshCloneUrl string `pulumi:"sshCloneUrl"` + // URL that can be provided to `svn checkout` to check out the repository via GitHub's Subversion protocol emulation. + SvnUrl string `pulumi:"svnUrl"` + // The repository source template configuration. + Templates []GetRepositoryTemplate `pulumi:"templates"` + // The list of topics of the repository. + Topics []string `pulumi:"topics"` + // Whether the repository is public, private or internal. + Visibility string `pulumi:"visibility"` +} + +func LookupRepositoryOutput(ctx *pulumi.Context, args LookupRepositoryOutputArgs, opts ...pulumi.InvokeOption) LookupRepositoryResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupRepositoryResultOutput, error) { + args := v.(LookupRepositoryArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRepository:getRepository", args, LookupRepositoryResultOutput{}, options).(LookupRepositoryResultOutput), nil + }).(LookupRepositoryResultOutput) +} + +// A collection of arguments for invoking getRepository. +type LookupRepositoryOutputArgs struct { + // A description of the license. + Description pulumi.StringPtrInput `pulumi:"description"` + // Full name of the repository (in `org/name` format). + FullName pulumi.StringPtrInput `pulumi:"fullName"` + // URL of a page describing the project. + HomepageUrl pulumi.StringPtrInput `pulumi:"homepageUrl"` + // The name of the repository. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (LookupRepositoryOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRepositoryArgs)(nil)).Elem() +} + +// A collection of values returned by getRepository. +type LookupRepositoryResultOutput struct{ *pulumi.OutputState } + +func (LookupRepositoryResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRepositoryResult)(nil)).Elem() +} + +func (o LookupRepositoryResultOutput) ToLookupRepositoryResultOutput() LookupRepositoryResultOutput { + return o +} + +func (o LookupRepositoryResultOutput) ToLookupRepositoryResultOutputWithContext(ctx context.Context) LookupRepositoryResultOutput { + return o +} + +// Whether the repository allows auto-merging pull requests. +func (o LookupRepositoryResultOutput) AllowAutoMerge() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryResult) bool { return v.AllowAutoMerge }).(pulumi.BoolOutput) +} + +// Whether the repository allows private forking; this is only relevant if the repository is owned by an organization and is private or internal. +func (o LookupRepositoryResultOutput) AllowForking() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryResult) bool { return v.AllowForking }).(pulumi.BoolOutput) +} + +// Whether the repository allows merge commits. +func (o LookupRepositoryResultOutput) AllowMergeCommit() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryResult) bool { return v.AllowMergeCommit }).(pulumi.BoolOutput) +} + +// Whether the repository allows rebase merges. +func (o LookupRepositoryResultOutput) AllowRebaseMerge() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryResult) bool { return v.AllowRebaseMerge }).(pulumi.BoolOutput) +} + +// Whether the repository allows squash merges. +func (o LookupRepositoryResultOutput) AllowSquashMerge() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryResult) bool { return v.AllowSquashMerge }).(pulumi.BoolOutput) +} + +func (o LookupRepositoryResultOutput) AllowUpdateBranch() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryResult) bool { return v.AllowUpdateBranch }).(pulumi.BoolOutput) +} + +// Whether the repository is archived. +func (o LookupRepositoryResultOutput) Archived() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryResult) bool { return v.Archived }).(pulumi.BoolOutput) +} + +// The name of the default branch of the repository. +func (o LookupRepositoryResultOutput) DefaultBranch() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryResult) string { return v.DefaultBranch }).(pulumi.StringOutput) +} + +func (o LookupRepositoryResultOutput) DeleteBranchOnMerge() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryResult) bool { return v.DeleteBranchOnMerge }).(pulumi.BoolOutput) +} + +// A description of the license. +func (o LookupRepositoryResultOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupRepositoryResult) *string { return v.Description }).(pulumi.StringPtrOutput) +} + +// Whether the repository is a fork. +func (o LookupRepositoryResultOutput) Fork() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryResult) bool { return v.Fork }).(pulumi.BoolOutput) +} + +func (o LookupRepositoryResultOutput) FullName() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryResult) string { return v.FullName }).(pulumi.StringOutput) +} + +// URL that can be provided to `git clone` to clone the repository anonymously via the git protocol. +func (o LookupRepositoryResultOutput) GitCloneUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryResult) string { return v.GitCloneUrl }).(pulumi.StringOutput) +} + +// Whether the repository has GitHub Discussions enabled. +func (o LookupRepositoryResultOutput) HasDiscussions() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryResult) bool { return v.HasDiscussions }).(pulumi.BoolOutput) +} + +// (**DEPRECATED**) Whether the repository has Downloads feature enabled. This attribute is no longer in use, but it hasn't been removed yet. It will be removed in a future version. See [this discussion](https://github.com/orgs/community/discussions/102145#discussioncomment-8351756). +// +// Deprecated: This attribute is no longer in use, but it hasn't been removed yet. It will be removed in a future version. See https://github.com/orgs/community/discussions/102145#discussioncomment-8351756 +func (o LookupRepositoryResultOutput) HasDownloads() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryResult) bool { return v.HasDownloads }).(pulumi.BoolOutput) +} + +// Whether the repository has GitHub Issues enabled. +func (o LookupRepositoryResultOutput) HasIssues() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryResult) bool { return v.HasIssues }).(pulumi.BoolOutput) +} + +// Whether the repository has the GitHub Projects enabled. +func (o LookupRepositoryResultOutput) HasProjects() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryResult) bool { return v.HasProjects }).(pulumi.BoolOutput) +} + +// Whether the repository has the GitHub Wiki enabled. +func (o LookupRepositoryResultOutput) HasWiki() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryResult) bool { return v.HasWiki }).(pulumi.BoolOutput) +} + +// URL of a page describing the project. +func (o LookupRepositoryResultOutput) HomepageUrl() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupRepositoryResult) *string { return v.HomepageUrl }).(pulumi.StringPtrOutput) +} + +// The URL to view the license details on GitHub. +func (o LookupRepositoryResultOutput) HtmlUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryResult) string { return v.HtmlUrl }).(pulumi.StringOutput) +} + +// URL that can be provided to `git clone` to clone the repository via HTTPS. +func (o LookupRepositoryResultOutput) HttpCloneUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryResult) string { return v.HttpCloneUrl }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupRepositoryResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Whether the repository is a template repository. +func (o LookupRepositoryResultOutput) IsTemplate() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryResult) bool { return v.IsTemplate }).(pulumi.BoolOutput) +} + +// The default value for a merge commit message. +func (o LookupRepositoryResultOutput) MergeCommitMessage() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryResult) string { return v.MergeCommitMessage }).(pulumi.StringOutput) +} + +// The default value for a merge commit title. +func (o LookupRepositoryResultOutput) MergeCommitTitle() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryResult) string { return v.MergeCommitTitle }).(pulumi.StringOutput) +} + +// The name of the license (e.g., "Apache License 2.0"). +func (o LookupRepositoryResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryResult) string { return v.Name }).(pulumi.StringOutput) +} + +// GraphQL global node id for use with v4 API +func (o LookupRepositoryResultOutput) NodeId() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryResult) string { return v.NodeId }).(pulumi.StringOutput) +} + +// (**DEPRECATED**) The repository's GitHub Pages configuration. Use the `RepositoryPages` data source instead. This field will be removed in a future version. +// +// Deprecated: Use the RepositoryPages data source instead. This field will be removed in a future version. +func (o LookupRepositoryResultOutput) Pages() GetRepositoryPageArrayOutput { + return o.ApplyT(func(v LookupRepositoryResult) []GetRepositoryPage { return v.Pages }).(GetRepositoryPageArrayOutput) +} + +// The primary language used in the repository. +func (o LookupRepositoryResultOutput) PrimaryLanguage() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryResult) string { return v.PrimaryLanguage }).(pulumi.StringOutput) +} + +// Whether the repository is private. +func (o LookupRepositoryResultOutput) Private() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryResult) bool { return v.Private }).(pulumi.BoolOutput) +} + +// GitHub ID for the repository +func (o LookupRepositoryResultOutput) RepoId() pulumi.IntOutput { + return o.ApplyT(func(v LookupRepositoryResult) int { return v.RepoId }).(pulumi.IntOutput) +} + +// An Array of GitHub repository licenses. Each `repositoryLicense` block consists of the fields documented below. +func (o LookupRepositoryResultOutput) RepositoryLicenses() GetRepositoryRepositoryLicenseArrayOutput { + return o.ApplyT(func(v LookupRepositoryResult) []GetRepositoryRepositoryLicense { return v.RepositoryLicenses }).(GetRepositoryRepositoryLicenseArrayOutput) +} + +// The default value for a squash merge commit message. +func (o LookupRepositoryResultOutput) SquashMergeCommitMessage() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryResult) string { return v.SquashMergeCommitMessage }).(pulumi.StringOutput) +} + +// The default value for a squash merge commit title. +func (o LookupRepositoryResultOutput) SquashMergeCommitTitle() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryResult) string { return v.SquashMergeCommitTitle }).(pulumi.StringOutput) +} + +// URL that can be provided to `git clone` to clone the repository via SSH. +func (o LookupRepositoryResultOutput) SshCloneUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryResult) string { return v.SshCloneUrl }).(pulumi.StringOutput) +} + +// URL that can be provided to `svn checkout` to check out the repository via GitHub's Subversion protocol emulation. +func (o LookupRepositoryResultOutput) SvnUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryResult) string { return v.SvnUrl }).(pulumi.StringOutput) +} + +// The repository source template configuration. +func (o LookupRepositoryResultOutput) Templates() GetRepositoryTemplateArrayOutput { + return o.ApplyT(func(v LookupRepositoryResult) []GetRepositoryTemplate { return v.Templates }).(GetRepositoryTemplateArrayOutput) +} + +// The list of topics of the repository. +func (o LookupRepositoryResultOutput) Topics() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupRepositoryResult) []string { return v.Topics }).(pulumi.StringArrayOutput) +} + +// Whether the repository is public, private or internal. +func (o LookupRepositoryResultOutput) Visibility() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryResult) string { return v.Visibility }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupRepositoryResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryAutolinkReferences.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryAutolinkReferences.go new file mode 100644 index 000000000..fb13cba64 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryAutolinkReferences.go @@ -0,0 +1,118 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve autolink references for a repository. +// +// ## Example Usage +// +// ```go +// 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.GetRepositoryAutolinkReferences(ctx, &github.GetRepositoryAutolinkReferencesArgs{ +// Repository: "example-repository", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetRepositoryAutolinkReferences(ctx *pulumi.Context, args *GetRepositoryAutolinkReferencesArgs, opts ...pulumi.InvokeOption) (*GetRepositoryAutolinkReferencesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetRepositoryAutolinkReferencesResult + err := ctx.Invoke("github:index/getRepositoryAutolinkReferences:getRepositoryAutolinkReferences", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRepositoryAutolinkReferences. +type GetRepositoryAutolinkReferencesArgs struct { + // Name of the repository to retrieve the autolink references from. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getRepositoryAutolinkReferences. +type GetRepositoryAutolinkReferencesResult struct { + // The list of this repository's autolink references. Each element of `autolinkReferences` has the following attributes: + AutolinkReferences []GetRepositoryAutolinkReferencesAutolinkReference `pulumi:"autolinkReferences"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Repository string `pulumi:"repository"` +} + +func GetRepositoryAutolinkReferencesOutput(ctx *pulumi.Context, args GetRepositoryAutolinkReferencesOutputArgs, opts ...pulumi.InvokeOption) GetRepositoryAutolinkReferencesResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetRepositoryAutolinkReferencesResultOutput, error) { + args := v.(GetRepositoryAutolinkReferencesArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRepositoryAutolinkReferences:getRepositoryAutolinkReferences", args, GetRepositoryAutolinkReferencesResultOutput{}, options).(GetRepositoryAutolinkReferencesResultOutput), nil + }).(GetRepositoryAutolinkReferencesResultOutput) +} + +// A collection of arguments for invoking getRepositoryAutolinkReferences. +type GetRepositoryAutolinkReferencesOutputArgs struct { + // Name of the repository to retrieve the autolink references from. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetRepositoryAutolinkReferencesOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryAutolinkReferencesArgs)(nil)).Elem() +} + +// A collection of values returned by getRepositoryAutolinkReferences. +type GetRepositoryAutolinkReferencesResultOutput struct{ *pulumi.OutputState } + +func (GetRepositoryAutolinkReferencesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryAutolinkReferencesResult)(nil)).Elem() +} + +func (o GetRepositoryAutolinkReferencesResultOutput) ToGetRepositoryAutolinkReferencesResultOutput() GetRepositoryAutolinkReferencesResultOutput { + return o +} + +func (o GetRepositoryAutolinkReferencesResultOutput) ToGetRepositoryAutolinkReferencesResultOutputWithContext(ctx context.Context) GetRepositoryAutolinkReferencesResultOutput { + return o +} + +// The list of this repository's autolink references. Each element of `autolinkReferences` has the following attributes: +func (o GetRepositoryAutolinkReferencesResultOutput) AutolinkReferences() GetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput { + return o.ApplyT(func(v GetRepositoryAutolinkReferencesResult) []GetRepositoryAutolinkReferencesAutolinkReference { + return v.AutolinkReferences + }).(GetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetRepositoryAutolinkReferencesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryAutolinkReferencesResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetRepositoryAutolinkReferencesResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryAutolinkReferencesResult) string { return v.Repository }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetRepositoryAutolinkReferencesResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryBranches.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryBranches.go new file mode 100644 index 000000000..84a447122 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryBranches.go @@ -0,0 +1,134 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about branches in a repository. +// +// ## Example Usage +// +// ```go +// 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.GetRepositoryBranches(ctx, &github.GetRepositoryBranchesArgs{ +// Repository: "example-repository", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetRepositoryBranches(ctx *pulumi.Context, args *GetRepositoryBranchesArgs, opts ...pulumi.InvokeOption) (*GetRepositoryBranchesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetRepositoryBranchesResult + err := ctx.Invoke("github:index/getRepositoryBranches:getRepositoryBranches", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRepositoryBranches. +type GetRepositoryBranchesArgs struct { + // . If true, the `branches` attributes will be populated only with non protected branches. Default: `false`. + OnlyNonProtectedBranches *bool `pulumi:"onlyNonProtectedBranches"` + // . If true, the `branches` attributes will be populated only with protected branches. Default: `false`. + OnlyProtectedBranches *bool `pulumi:"onlyProtectedBranches"` + // Name of the repository to retrieve the branches from. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getRepositoryBranches. +type GetRepositoryBranchesResult struct { + // The list of this repository's branches. Each element of `branches` has the following attributes: + Branches []GetRepositoryBranchesBranch `pulumi:"branches"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + OnlyNonProtectedBranches *bool `pulumi:"onlyNonProtectedBranches"` + OnlyProtectedBranches *bool `pulumi:"onlyProtectedBranches"` + Repository string `pulumi:"repository"` +} + +func GetRepositoryBranchesOutput(ctx *pulumi.Context, args GetRepositoryBranchesOutputArgs, opts ...pulumi.InvokeOption) GetRepositoryBranchesResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetRepositoryBranchesResultOutput, error) { + args := v.(GetRepositoryBranchesArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRepositoryBranches:getRepositoryBranches", args, GetRepositoryBranchesResultOutput{}, options).(GetRepositoryBranchesResultOutput), nil + }).(GetRepositoryBranchesResultOutput) +} + +// A collection of arguments for invoking getRepositoryBranches. +type GetRepositoryBranchesOutputArgs struct { + // . If true, the `branches` attributes will be populated only with non protected branches. Default: `false`. + OnlyNonProtectedBranches pulumi.BoolPtrInput `pulumi:"onlyNonProtectedBranches"` + // . If true, the `branches` attributes will be populated only with protected branches. Default: `false`. + OnlyProtectedBranches pulumi.BoolPtrInput `pulumi:"onlyProtectedBranches"` + // Name of the repository to retrieve the branches from. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetRepositoryBranchesOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryBranchesArgs)(nil)).Elem() +} + +// A collection of values returned by getRepositoryBranches. +type GetRepositoryBranchesResultOutput struct{ *pulumi.OutputState } + +func (GetRepositoryBranchesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryBranchesResult)(nil)).Elem() +} + +func (o GetRepositoryBranchesResultOutput) ToGetRepositoryBranchesResultOutput() GetRepositoryBranchesResultOutput { + return o +} + +func (o GetRepositoryBranchesResultOutput) ToGetRepositoryBranchesResultOutputWithContext(ctx context.Context) GetRepositoryBranchesResultOutput { + return o +} + +// The list of this repository's branches. Each element of `branches` has the following attributes: +func (o GetRepositoryBranchesResultOutput) Branches() GetRepositoryBranchesBranchArrayOutput { + return o.ApplyT(func(v GetRepositoryBranchesResult) []GetRepositoryBranchesBranch { return v.Branches }).(GetRepositoryBranchesBranchArrayOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetRepositoryBranchesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryBranchesResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetRepositoryBranchesResultOutput) OnlyNonProtectedBranches() pulumi.BoolPtrOutput { + return o.ApplyT(func(v GetRepositoryBranchesResult) *bool { return v.OnlyNonProtectedBranches }).(pulumi.BoolPtrOutput) +} + +func (o GetRepositoryBranchesResultOutput) OnlyProtectedBranches() pulumi.BoolPtrOutput { + return o.ApplyT(func(v GetRepositoryBranchesResult) *bool { return v.OnlyProtectedBranches }).(pulumi.BoolPtrOutput) +} + +func (o GetRepositoryBranchesResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryBranchesResult) string { return v.Repository }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetRepositoryBranchesResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryCustomProperties.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryCustomProperties.go new file mode 100644 index 000000000..d50eba4d1 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryCustomProperties.go @@ -0,0 +1,118 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve all custom properties of a repository. +// +// ## Example Usage +// +// ```go +// 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.GetRepositoryCustomProperties(ctx, &github.GetRepositoryCustomPropertiesArgs{ +// Repository: "example-repository", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetRepositoryCustomProperties(ctx *pulumi.Context, args *GetRepositoryCustomPropertiesArgs, opts ...pulumi.InvokeOption) (*GetRepositoryCustomPropertiesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetRepositoryCustomPropertiesResult + err := ctx.Invoke("github:index/getRepositoryCustomProperties:getRepositoryCustomProperties", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRepositoryCustomProperties. +type GetRepositoryCustomPropertiesArgs struct { + // Name of the repository to retrieve the custom properties from. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getRepositoryCustomProperties. +type GetRepositoryCustomPropertiesResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The list of this repository's custom properties. Each element of `property` has the following attributes: + Properties []GetRepositoryCustomPropertiesProperty `pulumi:"properties"` + Repository string `pulumi:"repository"` +} + +func GetRepositoryCustomPropertiesOutput(ctx *pulumi.Context, args GetRepositoryCustomPropertiesOutputArgs, opts ...pulumi.InvokeOption) GetRepositoryCustomPropertiesResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetRepositoryCustomPropertiesResultOutput, error) { + args := v.(GetRepositoryCustomPropertiesArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRepositoryCustomProperties:getRepositoryCustomProperties", args, GetRepositoryCustomPropertiesResultOutput{}, options).(GetRepositoryCustomPropertiesResultOutput), nil + }).(GetRepositoryCustomPropertiesResultOutput) +} + +// A collection of arguments for invoking getRepositoryCustomProperties. +type GetRepositoryCustomPropertiesOutputArgs struct { + // Name of the repository to retrieve the custom properties from. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetRepositoryCustomPropertiesOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryCustomPropertiesArgs)(nil)).Elem() +} + +// A collection of values returned by getRepositoryCustomProperties. +type GetRepositoryCustomPropertiesResultOutput struct{ *pulumi.OutputState } + +func (GetRepositoryCustomPropertiesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryCustomPropertiesResult)(nil)).Elem() +} + +func (o GetRepositoryCustomPropertiesResultOutput) ToGetRepositoryCustomPropertiesResultOutput() GetRepositoryCustomPropertiesResultOutput { + return o +} + +func (o GetRepositoryCustomPropertiesResultOutput) ToGetRepositoryCustomPropertiesResultOutputWithContext(ctx context.Context) GetRepositoryCustomPropertiesResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetRepositoryCustomPropertiesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryCustomPropertiesResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The list of this repository's custom properties. Each element of `property` has the following attributes: +func (o GetRepositoryCustomPropertiesResultOutput) Properties() GetRepositoryCustomPropertiesPropertyArrayOutput { + return o.ApplyT(func(v GetRepositoryCustomPropertiesResult) []GetRepositoryCustomPropertiesProperty { + return v.Properties + }).(GetRepositoryCustomPropertiesPropertyArrayOutput) +} + +func (o GetRepositoryCustomPropertiesResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryCustomPropertiesResult) string { return v.Repository }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetRepositoryCustomPropertiesResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryDeployKeys.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryDeployKeys.go new file mode 100644 index 000000000..224b2aac5 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryDeployKeys.go @@ -0,0 +1,116 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve all deploy keys of a repository. +// +// ## Example Usage +// +// ```go +// 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.GetRepositoryDeployKeys(ctx, &github.GetRepositoryDeployKeysArgs{ +// Repository: "example-repository", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetRepositoryDeployKeys(ctx *pulumi.Context, args *GetRepositoryDeployKeysArgs, opts ...pulumi.InvokeOption) (*GetRepositoryDeployKeysResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetRepositoryDeployKeysResult + err := ctx.Invoke("github:index/getRepositoryDeployKeys:getRepositoryDeployKeys", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRepositoryDeployKeys. +type GetRepositoryDeployKeysArgs struct { + // Name of the repository to retrieve the branches from. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getRepositoryDeployKeys. +type GetRepositoryDeployKeysResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The list of this repository's deploy keys. Each element of `keys` has the following attributes: + Keys []GetRepositoryDeployKeysKey `pulumi:"keys"` + Repository string `pulumi:"repository"` +} + +func GetRepositoryDeployKeysOutput(ctx *pulumi.Context, args GetRepositoryDeployKeysOutputArgs, opts ...pulumi.InvokeOption) GetRepositoryDeployKeysResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetRepositoryDeployKeysResultOutput, error) { + args := v.(GetRepositoryDeployKeysArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRepositoryDeployKeys:getRepositoryDeployKeys", args, GetRepositoryDeployKeysResultOutput{}, options).(GetRepositoryDeployKeysResultOutput), nil + }).(GetRepositoryDeployKeysResultOutput) +} + +// A collection of arguments for invoking getRepositoryDeployKeys. +type GetRepositoryDeployKeysOutputArgs struct { + // Name of the repository to retrieve the branches from. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetRepositoryDeployKeysOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryDeployKeysArgs)(nil)).Elem() +} + +// A collection of values returned by getRepositoryDeployKeys. +type GetRepositoryDeployKeysResultOutput struct{ *pulumi.OutputState } + +func (GetRepositoryDeployKeysResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryDeployKeysResult)(nil)).Elem() +} + +func (o GetRepositoryDeployKeysResultOutput) ToGetRepositoryDeployKeysResultOutput() GetRepositoryDeployKeysResultOutput { + return o +} + +func (o GetRepositoryDeployKeysResultOutput) ToGetRepositoryDeployKeysResultOutputWithContext(ctx context.Context) GetRepositoryDeployKeysResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetRepositoryDeployKeysResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryDeployKeysResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The list of this repository's deploy keys. Each element of `keys` has the following attributes: +func (o GetRepositoryDeployKeysResultOutput) Keys() GetRepositoryDeployKeysKeyArrayOutput { + return o.ApplyT(func(v GetRepositoryDeployKeysResult) []GetRepositoryDeployKeysKey { return v.Keys }).(GetRepositoryDeployKeysKeyArrayOutput) +} + +func (o GetRepositoryDeployKeysResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryDeployKeysResult) string { return v.Repository }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetRepositoryDeployKeysResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryDeploymentBranchPolicies.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryDeploymentBranchPolicies.go new file mode 100644 index 000000000..0c971d312 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryDeploymentBranchPolicies.go @@ -0,0 +1,130 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// > **Note:** This data source is deprecated, please use the `getRepositoryEnvironmentDeploymentPolicies` data source instead. +// +// Use this data source to retrieve deployment branch policies for a repository / environment. +// +// ## Example Usage +// +// ```go +// 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.GetRepositoryDeploymentBranchPolicies(ctx, &github.GetRepositoryDeploymentBranchPoliciesArgs{ +// Repository: "example-repository", +// EnvironmentName: "env_name", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetRepositoryDeploymentBranchPolicies(ctx *pulumi.Context, args *GetRepositoryDeploymentBranchPoliciesArgs, opts ...pulumi.InvokeOption) (*GetRepositoryDeploymentBranchPoliciesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetRepositoryDeploymentBranchPoliciesResult + err := ctx.Invoke("github:index/getRepositoryDeploymentBranchPolicies:getRepositoryDeploymentBranchPolicies", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRepositoryDeploymentBranchPolicies. +type GetRepositoryDeploymentBranchPoliciesArgs struct { + // Name of the environment to retrieve the deployment branch policies from. + EnvironmentName string `pulumi:"environmentName"` + // Name of the repository to retrieve the deployment branch policies from. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getRepositoryDeploymentBranchPolicies. +type GetRepositoryDeploymentBranchPoliciesResult struct { + // The list of this repository / environment deployment policies. Each element of `deploymentBranchPolicies` has the following attributes: + DeploymentBranchPolicies []GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicy `pulumi:"deploymentBranchPolicies"` + EnvironmentName string `pulumi:"environmentName"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Repository string `pulumi:"repository"` +} + +func GetRepositoryDeploymentBranchPoliciesOutput(ctx *pulumi.Context, args GetRepositoryDeploymentBranchPoliciesOutputArgs, opts ...pulumi.InvokeOption) GetRepositoryDeploymentBranchPoliciesResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetRepositoryDeploymentBranchPoliciesResultOutput, error) { + args := v.(GetRepositoryDeploymentBranchPoliciesArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRepositoryDeploymentBranchPolicies:getRepositoryDeploymentBranchPolicies", args, GetRepositoryDeploymentBranchPoliciesResultOutput{}, options).(GetRepositoryDeploymentBranchPoliciesResultOutput), nil + }).(GetRepositoryDeploymentBranchPoliciesResultOutput) +} + +// A collection of arguments for invoking getRepositoryDeploymentBranchPolicies. +type GetRepositoryDeploymentBranchPoliciesOutputArgs struct { + // Name of the environment to retrieve the deployment branch policies from. + EnvironmentName pulumi.StringInput `pulumi:"environmentName"` + // Name of the repository to retrieve the deployment branch policies from. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetRepositoryDeploymentBranchPoliciesOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryDeploymentBranchPoliciesArgs)(nil)).Elem() +} + +// A collection of values returned by getRepositoryDeploymentBranchPolicies. +type GetRepositoryDeploymentBranchPoliciesResultOutput struct{ *pulumi.OutputState } + +func (GetRepositoryDeploymentBranchPoliciesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryDeploymentBranchPoliciesResult)(nil)).Elem() +} + +func (o GetRepositoryDeploymentBranchPoliciesResultOutput) ToGetRepositoryDeploymentBranchPoliciesResultOutput() GetRepositoryDeploymentBranchPoliciesResultOutput { + return o +} + +func (o GetRepositoryDeploymentBranchPoliciesResultOutput) ToGetRepositoryDeploymentBranchPoliciesResultOutputWithContext(ctx context.Context) GetRepositoryDeploymentBranchPoliciesResultOutput { + return o +} + +// The list of this repository / environment deployment policies. Each element of `deploymentBranchPolicies` has the following attributes: +func (o GetRepositoryDeploymentBranchPoliciesResultOutput) DeploymentBranchPolicies() GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput { + return o.ApplyT(func(v GetRepositoryDeploymentBranchPoliciesResult) []GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicy { + return v.DeploymentBranchPolicies + }).(GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput) +} + +func (o GetRepositoryDeploymentBranchPoliciesResultOutput) EnvironmentName() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryDeploymentBranchPoliciesResult) string { return v.EnvironmentName }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetRepositoryDeploymentBranchPoliciesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryDeploymentBranchPoliciesResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetRepositoryDeploymentBranchPoliciesResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryDeploymentBranchPoliciesResult) string { return v.Repository }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetRepositoryDeploymentBranchPoliciesResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryEnvironmentDeploymentPolicies.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryEnvironmentDeploymentPolicies.go new file mode 100644 index 000000000..26c5579b5 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryEnvironmentDeploymentPolicies.go @@ -0,0 +1,128 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve deployment branch policies for a repository environment. +// +// ## Example Usage +// +// ```go +// 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.GetRepositoryEnvironmentDeploymentPolicies(ctx, &github.GetRepositoryEnvironmentDeploymentPoliciesArgs{ +// Repository: "example-repository", +// Environment: "env-name", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetRepositoryEnvironmentDeploymentPolicies(ctx *pulumi.Context, args *GetRepositoryEnvironmentDeploymentPoliciesArgs, opts ...pulumi.InvokeOption) (*GetRepositoryEnvironmentDeploymentPoliciesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetRepositoryEnvironmentDeploymentPoliciesResult + err := ctx.Invoke("github:index/getRepositoryEnvironmentDeploymentPolicies:getRepositoryEnvironmentDeploymentPolicies", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRepositoryEnvironmentDeploymentPolicies. +type GetRepositoryEnvironmentDeploymentPoliciesArgs struct { + // Name of the environment to retrieve the deployment branch policies from. + Environment string `pulumi:"environment"` + // Name of the repository to retrieve the deployment branch policies from. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getRepositoryEnvironmentDeploymentPolicies. +type GetRepositoryEnvironmentDeploymentPoliciesResult struct { + Environment string `pulumi:"environment"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The list of deployment policies for the repository environment. Each element of `policies` has the following attributes: + Policies []GetRepositoryEnvironmentDeploymentPoliciesPolicy `pulumi:"policies"` + Repository string `pulumi:"repository"` +} + +func GetRepositoryEnvironmentDeploymentPoliciesOutput(ctx *pulumi.Context, args GetRepositoryEnvironmentDeploymentPoliciesOutputArgs, opts ...pulumi.InvokeOption) GetRepositoryEnvironmentDeploymentPoliciesResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetRepositoryEnvironmentDeploymentPoliciesResultOutput, error) { + args := v.(GetRepositoryEnvironmentDeploymentPoliciesArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRepositoryEnvironmentDeploymentPolicies:getRepositoryEnvironmentDeploymentPolicies", args, GetRepositoryEnvironmentDeploymentPoliciesResultOutput{}, options).(GetRepositoryEnvironmentDeploymentPoliciesResultOutput), nil + }).(GetRepositoryEnvironmentDeploymentPoliciesResultOutput) +} + +// A collection of arguments for invoking getRepositoryEnvironmentDeploymentPolicies. +type GetRepositoryEnvironmentDeploymentPoliciesOutputArgs struct { + // Name of the environment to retrieve the deployment branch policies from. + Environment pulumi.StringInput `pulumi:"environment"` + // Name of the repository to retrieve the deployment branch policies from. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetRepositoryEnvironmentDeploymentPoliciesOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryEnvironmentDeploymentPoliciesArgs)(nil)).Elem() +} + +// A collection of values returned by getRepositoryEnvironmentDeploymentPolicies. +type GetRepositoryEnvironmentDeploymentPoliciesResultOutput struct{ *pulumi.OutputState } + +func (GetRepositoryEnvironmentDeploymentPoliciesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryEnvironmentDeploymentPoliciesResult)(nil)).Elem() +} + +func (o GetRepositoryEnvironmentDeploymentPoliciesResultOutput) ToGetRepositoryEnvironmentDeploymentPoliciesResultOutput() GetRepositoryEnvironmentDeploymentPoliciesResultOutput { + return o +} + +func (o GetRepositoryEnvironmentDeploymentPoliciesResultOutput) ToGetRepositoryEnvironmentDeploymentPoliciesResultOutputWithContext(ctx context.Context) GetRepositoryEnvironmentDeploymentPoliciesResultOutput { + return o +} + +func (o GetRepositoryEnvironmentDeploymentPoliciesResultOutput) Environment() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryEnvironmentDeploymentPoliciesResult) string { return v.Environment }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetRepositoryEnvironmentDeploymentPoliciesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryEnvironmentDeploymentPoliciesResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The list of deployment policies for the repository environment. Each element of `policies` has the following attributes: +func (o GetRepositoryEnvironmentDeploymentPoliciesResultOutput) Policies() GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput { + return o.ApplyT(func(v GetRepositoryEnvironmentDeploymentPoliciesResult) []GetRepositoryEnvironmentDeploymentPoliciesPolicy { + return v.Policies + }).(GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput) +} + +func (o GetRepositoryEnvironmentDeploymentPoliciesResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryEnvironmentDeploymentPoliciesResult) string { return v.Repository }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetRepositoryEnvironmentDeploymentPoliciesResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryEnvironments.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryEnvironments.go new file mode 100644 index 000000000..d1fdcab9b --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryEnvironments.go @@ -0,0 +1,116 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about environments for a repository. +// +// ## Example Usage +// +// ```go +// 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.GetRepositoryEnvironments(ctx, &github.GetRepositoryEnvironmentsArgs{ +// Repository: "example-repository", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetRepositoryEnvironments(ctx *pulumi.Context, args *GetRepositoryEnvironmentsArgs, opts ...pulumi.InvokeOption) (*GetRepositoryEnvironmentsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetRepositoryEnvironmentsResult + err := ctx.Invoke("github:index/getRepositoryEnvironments:getRepositoryEnvironments", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRepositoryEnvironments. +type GetRepositoryEnvironmentsArgs struct { + // Name of the repository to retrieve the environments from. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getRepositoryEnvironments. +type GetRepositoryEnvironmentsResult struct { + // The list of this repository's environments. Each element of `environments` has the following attributes: + Environments []GetRepositoryEnvironmentsEnvironment `pulumi:"environments"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Repository string `pulumi:"repository"` +} + +func GetRepositoryEnvironmentsOutput(ctx *pulumi.Context, args GetRepositoryEnvironmentsOutputArgs, opts ...pulumi.InvokeOption) GetRepositoryEnvironmentsResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetRepositoryEnvironmentsResultOutput, error) { + args := v.(GetRepositoryEnvironmentsArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRepositoryEnvironments:getRepositoryEnvironments", args, GetRepositoryEnvironmentsResultOutput{}, options).(GetRepositoryEnvironmentsResultOutput), nil + }).(GetRepositoryEnvironmentsResultOutput) +} + +// A collection of arguments for invoking getRepositoryEnvironments. +type GetRepositoryEnvironmentsOutputArgs struct { + // Name of the repository to retrieve the environments from. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetRepositoryEnvironmentsOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryEnvironmentsArgs)(nil)).Elem() +} + +// A collection of values returned by getRepositoryEnvironments. +type GetRepositoryEnvironmentsResultOutput struct{ *pulumi.OutputState } + +func (GetRepositoryEnvironmentsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryEnvironmentsResult)(nil)).Elem() +} + +func (o GetRepositoryEnvironmentsResultOutput) ToGetRepositoryEnvironmentsResultOutput() GetRepositoryEnvironmentsResultOutput { + return o +} + +func (o GetRepositoryEnvironmentsResultOutput) ToGetRepositoryEnvironmentsResultOutputWithContext(ctx context.Context) GetRepositoryEnvironmentsResultOutput { + return o +} + +// The list of this repository's environments. Each element of `environments` has the following attributes: +func (o GetRepositoryEnvironmentsResultOutput) Environments() GetRepositoryEnvironmentsEnvironmentArrayOutput { + return o.ApplyT(func(v GetRepositoryEnvironmentsResult) []GetRepositoryEnvironmentsEnvironment { return v.Environments }).(GetRepositoryEnvironmentsEnvironmentArrayOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetRepositoryEnvironmentsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryEnvironmentsResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetRepositoryEnvironmentsResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryEnvironmentsResult) string { return v.Repository }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetRepositoryEnvironmentsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryFile.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryFile.go new file mode 100644 index 000000000..cdbf0178e --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryFile.go @@ -0,0 +1,179 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This data source allows you to read files within a +// GitHub repository. +// +// ## Example Usage +// +// ```go +// 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.GetRepositoryFile(ctx, &github.LookupRepositoryFileArgs{ +// Repository: fooGithubRepository.Name, +// Branch: pulumi.StringRef("main"), +// File: ".gitignore", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupRepositoryFile(ctx *pulumi.Context, args *LookupRepositoryFileArgs, opts ...pulumi.InvokeOption) (*LookupRepositoryFileResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupRepositoryFileResult + err := ctx.Invoke("github:index/getRepositoryFile:getRepositoryFile", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRepositoryFile. +type LookupRepositoryFileArgs struct { + // Git branch. Defaults to the repository's default branch. + Branch *string `pulumi:"branch"` + // The path of the file to read. + File string `pulumi:"file"` + // The repository to read the file from. If an unqualified repo name (without an owner) is passed, the owner will be inferred from the owner of the token used to execute the plan. If a name of the type "owner/repo" (with a slash in the middle) is passed, the owner will be as specified and not the owner of the token. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getRepositoryFile. +type LookupRepositoryFileResult struct { + Branch *string `pulumi:"branch"` + // Committer author name. + CommitAuthor string `pulumi:"commitAuthor"` + // Committer email address. + CommitEmail string `pulumi:"commitEmail"` + // Commit message when file was last updated. + CommitMessage string `pulumi:"commitMessage"` + // The SHA of the commit that modified the file. + CommitSha string `pulumi:"commitSha"` + // The file content. + Content string `pulumi:"content"` + File string `pulumi:"file"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The name of the commit/branch/tag. + Ref string `pulumi:"ref"` + Repository string `pulumi:"repository"` + // The SHA blob of the file. + Sha string `pulumi:"sha"` +} + +func LookupRepositoryFileOutput(ctx *pulumi.Context, args LookupRepositoryFileOutputArgs, opts ...pulumi.InvokeOption) LookupRepositoryFileResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupRepositoryFileResultOutput, error) { + args := v.(LookupRepositoryFileArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRepositoryFile:getRepositoryFile", args, LookupRepositoryFileResultOutput{}, options).(LookupRepositoryFileResultOutput), nil + }).(LookupRepositoryFileResultOutput) +} + +// A collection of arguments for invoking getRepositoryFile. +type LookupRepositoryFileOutputArgs struct { + // Git branch. Defaults to the repository's default branch. + Branch pulumi.StringPtrInput `pulumi:"branch"` + // The path of the file to read. + File pulumi.StringInput `pulumi:"file"` + // The repository to read the file from. If an unqualified repo name (without an owner) is passed, the owner will be inferred from the owner of the token used to execute the plan. If a name of the type "owner/repo" (with a slash in the middle) is passed, the owner will be as specified and not the owner of the token. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (LookupRepositoryFileOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRepositoryFileArgs)(nil)).Elem() +} + +// A collection of values returned by getRepositoryFile. +type LookupRepositoryFileResultOutput struct{ *pulumi.OutputState } + +func (LookupRepositoryFileResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRepositoryFileResult)(nil)).Elem() +} + +func (o LookupRepositoryFileResultOutput) ToLookupRepositoryFileResultOutput() LookupRepositoryFileResultOutput { + return o +} + +func (o LookupRepositoryFileResultOutput) ToLookupRepositoryFileResultOutputWithContext(ctx context.Context) LookupRepositoryFileResultOutput { + return o +} + +func (o LookupRepositoryFileResultOutput) Branch() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupRepositoryFileResult) *string { return v.Branch }).(pulumi.StringPtrOutput) +} + +// Committer author name. +func (o LookupRepositoryFileResultOutput) CommitAuthor() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryFileResult) string { return v.CommitAuthor }).(pulumi.StringOutput) +} + +// Committer email address. +func (o LookupRepositoryFileResultOutput) CommitEmail() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryFileResult) string { return v.CommitEmail }).(pulumi.StringOutput) +} + +// Commit message when file was last updated. +func (o LookupRepositoryFileResultOutput) CommitMessage() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryFileResult) string { return v.CommitMessage }).(pulumi.StringOutput) +} + +// The SHA of the commit that modified the file. +func (o LookupRepositoryFileResultOutput) CommitSha() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryFileResult) string { return v.CommitSha }).(pulumi.StringOutput) +} + +// The file content. +func (o LookupRepositoryFileResultOutput) Content() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryFileResult) string { return v.Content }).(pulumi.StringOutput) +} + +func (o LookupRepositoryFileResultOutput) File() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryFileResult) string { return v.File }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupRepositoryFileResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryFileResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The name of the commit/branch/tag. +func (o LookupRepositoryFileResultOutput) Ref() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryFileResult) string { return v.Ref }).(pulumi.StringOutput) +} + +func (o LookupRepositoryFileResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryFileResult) string { return v.Repository }).(pulumi.StringOutput) +} + +// The SHA blob of the file. +func (o LookupRepositoryFileResultOutput) Sha() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryFileResult) string { return v.Sha }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupRepositoryFileResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryMilestone.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryMilestone.go new file mode 100644 index 000000000..eb92dbf02 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryMilestone.go @@ -0,0 +1,157 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a specific GitHub milestone in a repository. +// +// ## Example Usage +// +// ```go +// 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.GetRepositoryMilestone(ctx, &github.LookupRepositoryMilestoneArgs{ +// Owner: "example-owner", +// Repository: "example-repository", +// Number: 1, +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupRepositoryMilestone(ctx *pulumi.Context, args *LookupRepositoryMilestoneArgs, opts ...pulumi.InvokeOption) (*LookupRepositoryMilestoneResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupRepositoryMilestoneResult + err := ctx.Invoke("github:index/getRepositoryMilestone:getRepositoryMilestone", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRepositoryMilestone. +type LookupRepositoryMilestoneArgs struct { + // The number of the milestone. + Number int `pulumi:"number"` + // Owner of the repository. + Owner string `pulumi:"owner"` + // Name of the repository to retrieve the milestone from. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getRepositoryMilestone. +type LookupRepositoryMilestoneResult struct { + // Description of the milestone. + Description string `pulumi:"description"` + // The milestone due date (in ISO-8601 `yyyy-mm-dd` format). + DueDate string `pulumi:"dueDate"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Number int `pulumi:"number"` + Owner string `pulumi:"owner"` + Repository string `pulumi:"repository"` + // State of the milestone. + State string `pulumi:"state"` + // Title of the milestone. + Title string `pulumi:"title"` +} + +func LookupRepositoryMilestoneOutput(ctx *pulumi.Context, args LookupRepositoryMilestoneOutputArgs, opts ...pulumi.InvokeOption) LookupRepositoryMilestoneResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupRepositoryMilestoneResultOutput, error) { + args := v.(LookupRepositoryMilestoneArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRepositoryMilestone:getRepositoryMilestone", args, LookupRepositoryMilestoneResultOutput{}, options).(LookupRepositoryMilestoneResultOutput), nil + }).(LookupRepositoryMilestoneResultOutput) +} + +// A collection of arguments for invoking getRepositoryMilestone. +type LookupRepositoryMilestoneOutputArgs struct { + // The number of the milestone. + Number pulumi.IntInput `pulumi:"number"` + // Owner of the repository. + Owner pulumi.StringInput `pulumi:"owner"` + // Name of the repository to retrieve the milestone from. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (LookupRepositoryMilestoneOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRepositoryMilestoneArgs)(nil)).Elem() +} + +// A collection of values returned by getRepositoryMilestone. +type LookupRepositoryMilestoneResultOutput struct{ *pulumi.OutputState } + +func (LookupRepositoryMilestoneResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRepositoryMilestoneResult)(nil)).Elem() +} + +func (o LookupRepositoryMilestoneResultOutput) ToLookupRepositoryMilestoneResultOutput() LookupRepositoryMilestoneResultOutput { + return o +} + +func (o LookupRepositoryMilestoneResultOutput) ToLookupRepositoryMilestoneResultOutputWithContext(ctx context.Context) LookupRepositoryMilestoneResultOutput { + return o +} + +// Description of the milestone. +func (o LookupRepositoryMilestoneResultOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryMilestoneResult) string { return v.Description }).(pulumi.StringOutput) +} + +// The milestone due date (in ISO-8601 `yyyy-mm-dd` format). +func (o LookupRepositoryMilestoneResultOutput) DueDate() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryMilestoneResult) string { return v.DueDate }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupRepositoryMilestoneResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryMilestoneResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o LookupRepositoryMilestoneResultOutput) Number() pulumi.IntOutput { + return o.ApplyT(func(v LookupRepositoryMilestoneResult) int { return v.Number }).(pulumi.IntOutput) +} + +func (o LookupRepositoryMilestoneResultOutput) Owner() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryMilestoneResult) string { return v.Owner }).(pulumi.StringOutput) +} + +func (o LookupRepositoryMilestoneResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryMilestoneResult) string { return v.Repository }).(pulumi.StringOutput) +} + +// State of the milestone. +func (o LookupRepositoryMilestoneResultOutput) State() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryMilestoneResult) string { return v.State }).(pulumi.StringOutput) +} + +// Title of the milestone. +func (o LookupRepositoryMilestoneResultOutput) Title() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryMilestoneResult) string { return v.Title }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupRepositoryMilestoneResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryPages.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryPages.go new file mode 100644 index 000000000..2d8dc60c0 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryPages.go @@ -0,0 +1,172 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve GitHub Pages configuration for a repository. +// +// ## Example Usage +// +// ```go +// 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.GetRepositoryPages(ctx, &github.LookupRepositoryPagesArgs{ +// Repository: "my-repo", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupRepositoryPages(ctx *pulumi.Context, args *LookupRepositoryPagesArgs, opts ...pulumi.InvokeOption) (*LookupRepositoryPagesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupRepositoryPagesResult + err := ctx.Invoke("github:index/getRepositoryPages:getRepositoryPages", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRepositoryPages. +type LookupRepositoryPagesArgs struct { + // The repository name to get GitHub Pages information for. + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getRepositoryPages. +type LookupRepositoryPagesResult struct { + // The API URL of the GitHub Pages resource. + ApiUrl string `pulumi:"apiUrl"` + // The GitHub Pages site's build status (e.g., `building` or `built`). + BuildStatus string `pulumi:"buildStatus"` + // The type of GitHub Pages site. Can be `legacy` or `workflow`. + BuildType string `pulumi:"buildType"` + // The custom domain for the repository. + Cname string `pulumi:"cname"` + // Whether the rendered GitHub Pages site has a custom 404 page. + Custom404 bool `pulumi:"custom404"` + // The absolute URL (with scheme) to the rendered GitHub Pages site. + HtmlUrl string `pulumi:"htmlUrl"` + // Whether HTTPS is enforced for the GitHub Pages site. This setting only applies when a custom domain is configured. + HttpsEnforced bool `pulumi:"httpsEnforced"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Whether the GitHub Pages site is public. + Public bool `pulumi:"public"` + Repository string `pulumi:"repository"` + // The source branch and directory for the rendered Pages site. See Source below for details. + Sources []GetRepositoryPagesSource `pulumi:"sources"` +} + +func LookupRepositoryPagesOutput(ctx *pulumi.Context, args LookupRepositoryPagesOutputArgs, opts ...pulumi.InvokeOption) LookupRepositoryPagesResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupRepositoryPagesResultOutput, error) { + args := v.(LookupRepositoryPagesArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRepositoryPages:getRepositoryPages", args, LookupRepositoryPagesResultOutput{}, options).(LookupRepositoryPagesResultOutput), nil + }).(LookupRepositoryPagesResultOutput) +} + +// A collection of arguments for invoking getRepositoryPages. +type LookupRepositoryPagesOutputArgs struct { + // The repository name to get GitHub Pages information for. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (LookupRepositoryPagesOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRepositoryPagesArgs)(nil)).Elem() +} + +// A collection of values returned by getRepositoryPages. +type LookupRepositoryPagesResultOutput struct{ *pulumi.OutputState } + +func (LookupRepositoryPagesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRepositoryPagesResult)(nil)).Elem() +} + +func (o LookupRepositoryPagesResultOutput) ToLookupRepositoryPagesResultOutput() LookupRepositoryPagesResultOutput { + return o +} + +func (o LookupRepositoryPagesResultOutput) ToLookupRepositoryPagesResultOutputWithContext(ctx context.Context) LookupRepositoryPagesResultOutput { + return o +} + +// The API URL of the GitHub Pages resource. +func (o LookupRepositoryPagesResultOutput) ApiUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPagesResult) string { return v.ApiUrl }).(pulumi.StringOutput) +} + +// The GitHub Pages site's build status (e.g., `building` or `built`). +func (o LookupRepositoryPagesResultOutput) BuildStatus() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPagesResult) string { return v.BuildStatus }).(pulumi.StringOutput) +} + +// The type of GitHub Pages site. Can be `legacy` or `workflow`. +func (o LookupRepositoryPagesResultOutput) BuildType() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPagesResult) string { return v.BuildType }).(pulumi.StringOutput) +} + +// The custom domain for the repository. +func (o LookupRepositoryPagesResultOutput) Cname() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPagesResult) string { return v.Cname }).(pulumi.StringOutput) +} + +// Whether the rendered GitHub Pages site has a custom 404 page. +func (o LookupRepositoryPagesResultOutput) Custom404() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryPagesResult) bool { return v.Custom404 }).(pulumi.BoolOutput) +} + +// The absolute URL (with scheme) to the rendered GitHub Pages site. +func (o LookupRepositoryPagesResultOutput) HtmlUrl() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPagesResult) string { return v.HtmlUrl }).(pulumi.StringOutput) +} + +// Whether HTTPS is enforced for the GitHub Pages site. This setting only applies when a custom domain is configured. +func (o LookupRepositoryPagesResultOutput) HttpsEnforced() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryPagesResult) bool { return v.HttpsEnforced }).(pulumi.BoolOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupRepositoryPagesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPagesResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Whether the GitHub Pages site is public. +func (o LookupRepositoryPagesResultOutput) Public() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryPagesResult) bool { return v.Public }).(pulumi.BoolOutput) +} + +func (o LookupRepositoryPagesResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPagesResult) string { return v.Repository }).(pulumi.StringOutput) +} + +// The source branch and directory for the rendered Pages site. See Source below for details. +func (o LookupRepositoryPagesResultOutput) Sources() GetRepositoryPagesSourceArrayOutput { + return o.ApplyT(func(v LookupRepositoryPagesResult) []GetRepositoryPagesSource { return v.Sources }).(GetRepositoryPagesSourceArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupRepositoryPagesResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryPullRequest.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryPullRequest.go new file mode 100644 index 000000000..a68855628 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryPullRequest.go @@ -0,0 +1,231 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a specific GitHub Pull Request in a repository. +// +// ## Example Usage +// +// ```go +// 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.GetRepositoryPullRequest(ctx, &github.LookupRepositoryPullRequestArgs{ +// BaseRepository: "example_repository", +// Number: 1, +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupRepositoryPullRequest(ctx *pulumi.Context, args *LookupRepositoryPullRequestArgs, opts ...pulumi.InvokeOption) (*LookupRepositoryPullRequestResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupRepositoryPullRequestResult + err := ctx.Invoke("github:index/getRepositoryPullRequest:getRepositoryPullRequest", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRepositoryPullRequest. +type LookupRepositoryPullRequestArgs struct { + // Name of the base repository to retrieve the Pull Request from. + BaseRepository string `pulumi:"baseRepository"` + // The number of the Pull Request within the repository. + Number int `pulumi:"number"` + // Owner of the repository. If not provided, the provider's default owner is used. + Owner *string `pulumi:"owner"` +} + +// A collection of values returned by getRepositoryPullRequest. +type LookupRepositoryPullRequestResult struct { + // Name of the ref (branch) of the Pull Request base. + BaseRef string `pulumi:"baseRef"` + BaseRepository string `pulumi:"baseRepository"` + // Head commit SHA of the Pull Request base. + BaseSha string `pulumi:"baseSha"` + // Body of the Pull Request. + Body string `pulumi:"body"` + // Indicates Whether this Pull Request is a draft. + Draft bool `pulumi:"draft"` + // Owner of the Pull Request head repository. + HeadOwner string `pulumi:"headOwner"` + HeadRef string `pulumi:"headRef"` + // Name of the Pull Request head repository. + HeadRepository string `pulumi:"headRepository"` + // Head commit SHA of the Pull Request head. + HeadSha string `pulumi:"headSha"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // List of label names set on the Pull Request. + Labels []string `pulumi:"labels"` + // Indicates whether the base repository maintainers can modify the Pull Request. + MaintainerCanModify bool `pulumi:"maintainerCanModify"` + Number int `pulumi:"number"` + // Unix timestamp indicating the Pull Request creation time. + OpenedAt int `pulumi:"openedAt"` + // GitHub login of the user who opened the Pull Request. + OpenedBy string `pulumi:"openedBy"` + Owner *string `pulumi:"owner"` + // the current Pull Request state - can be "open", "closed" or "merged". + State string `pulumi:"state"` + // The title of the Pull Request. + Title string `pulumi:"title"` + // The timestamp of the last Pull Request update. + UpdatedAt int `pulumi:"updatedAt"` +} + +func LookupRepositoryPullRequestOutput(ctx *pulumi.Context, args LookupRepositoryPullRequestOutputArgs, opts ...pulumi.InvokeOption) LookupRepositoryPullRequestResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupRepositoryPullRequestResultOutput, error) { + args := v.(LookupRepositoryPullRequestArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRepositoryPullRequest:getRepositoryPullRequest", args, LookupRepositoryPullRequestResultOutput{}, options).(LookupRepositoryPullRequestResultOutput), nil + }).(LookupRepositoryPullRequestResultOutput) +} + +// A collection of arguments for invoking getRepositoryPullRequest. +type LookupRepositoryPullRequestOutputArgs struct { + // Name of the base repository to retrieve the Pull Request from. + BaseRepository pulumi.StringInput `pulumi:"baseRepository"` + // The number of the Pull Request within the repository. + Number pulumi.IntInput `pulumi:"number"` + // Owner of the repository. If not provided, the provider's default owner is used. + Owner pulumi.StringPtrInput `pulumi:"owner"` +} + +func (LookupRepositoryPullRequestOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRepositoryPullRequestArgs)(nil)).Elem() +} + +// A collection of values returned by getRepositoryPullRequest. +type LookupRepositoryPullRequestResultOutput struct{ *pulumi.OutputState } + +func (LookupRepositoryPullRequestResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRepositoryPullRequestResult)(nil)).Elem() +} + +func (o LookupRepositoryPullRequestResultOutput) ToLookupRepositoryPullRequestResultOutput() LookupRepositoryPullRequestResultOutput { + return o +} + +func (o LookupRepositoryPullRequestResultOutput) ToLookupRepositoryPullRequestResultOutputWithContext(ctx context.Context) LookupRepositoryPullRequestResultOutput { + return o +} + +// Name of the ref (branch) of the Pull Request base. +func (o LookupRepositoryPullRequestResultOutput) BaseRef() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) string { return v.BaseRef }).(pulumi.StringOutput) +} + +func (o LookupRepositoryPullRequestResultOutput) BaseRepository() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) string { return v.BaseRepository }).(pulumi.StringOutput) +} + +// Head commit SHA of the Pull Request base. +func (o LookupRepositoryPullRequestResultOutput) BaseSha() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) string { return v.BaseSha }).(pulumi.StringOutput) +} + +// Body of the Pull Request. +func (o LookupRepositoryPullRequestResultOutput) Body() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) string { return v.Body }).(pulumi.StringOutput) +} + +// Indicates Whether this Pull Request is a draft. +func (o LookupRepositoryPullRequestResultOutput) Draft() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) bool { return v.Draft }).(pulumi.BoolOutput) +} + +// Owner of the Pull Request head repository. +func (o LookupRepositoryPullRequestResultOutput) HeadOwner() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) string { return v.HeadOwner }).(pulumi.StringOutput) +} + +func (o LookupRepositoryPullRequestResultOutput) HeadRef() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) string { return v.HeadRef }).(pulumi.StringOutput) +} + +// Name of the Pull Request head repository. +func (o LookupRepositoryPullRequestResultOutput) HeadRepository() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) string { return v.HeadRepository }).(pulumi.StringOutput) +} + +// Head commit SHA of the Pull Request head. +func (o LookupRepositoryPullRequestResultOutput) HeadSha() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) string { return v.HeadSha }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupRepositoryPullRequestResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) string { return v.Id }).(pulumi.StringOutput) +} + +// List of label names set on the Pull Request. +func (o LookupRepositoryPullRequestResultOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) []string { return v.Labels }).(pulumi.StringArrayOutput) +} + +// Indicates whether the base repository maintainers can modify the Pull Request. +func (o LookupRepositoryPullRequestResultOutput) MaintainerCanModify() pulumi.BoolOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) bool { return v.MaintainerCanModify }).(pulumi.BoolOutput) +} + +func (o LookupRepositoryPullRequestResultOutput) Number() pulumi.IntOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) int { return v.Number }).(pulumi.IntOutput) +} + +// Unix timestamp indicating the Pull Request creation time. +func (o LookupRepositoryPullRequestResultOutput) OpenedAt() pulumi.IntOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) int { return v.OpenedAt }).(pulumi.IntOutput) +} + +// GitHub login of the user who opened the Pull Request. +func (o LookupRepositoryPullRequestResultOutput) OpenedBy() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) string { return v.OpenedBy }).(pulumi.StringOutput) +} + +func (o LookupRepositoryPullRequestResultOutput) Owner() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) *string { return v.Owner }).(pulumi.StringPtrOutput) +} + +// the current Pull Request state - can be "open", "closed" or "merged". +func (o LookupRepositoryPullRequestResultOutput) State() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) string { return v.State }).(pulumi.StringOutput) +} + +// The title of the Pull Request. +func (o LookupRepositoryPullRequestResultOutput) Title() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) string { return v.Title }).(pulumi.StringOutput) +} + +// The timestamp of the last Pull Request update. +func (o LookupRepositoryPullRequestResultOutput) UpdatedAt() pulumi.IntOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestResult) int { return v.UpdatedAt }).(pulumi.IntOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupRepositoryPullRequestResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryPullRequests.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryPullRequests.go new file mode 100644 index 000000000..f47cc5e94 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryPullRequests.go @@ -0,0 +1,180 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about multiple GitHub Pull Requests in a repository. +// +// ## Example Usage +// +// ```go +// 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.GetRepositoryPullRequests(ctx, &github.LookupRepositoryPullRequestsArgs{ +// BaseRepository: "example-repository", +// BaseRef: pulumi.StringRef("main"), +// SortBy: pulumi.StringRef("updated"), +// SortDirection: pulumi.StringRef("desc"), +// State: pulumi.StringRef("open"), +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupRepositoryPullRequests(ctx *pulumi.Context, args *LookupRepositoryPullRequestsArgs, opts ...pulumi.InvokeOption) (*LookupRepositoryPullRequestsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupRepositoryPullRequestsResult + err := ctx.Invoke("github:index/getRepositoryPullRequests:getRepositoryPullRequests", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRepositoryPullRequests. +type LookupRepositoryPullRequestsArgs struct { + // If set, filters Pull Requests by base branch name. + BaseRef *string `pulumi:"baseRef"` + // Name of the base repository to retrieve the Pull Requests from. + BaseRepository string `pulumi:"baseRepository"` + // If set, filters Pull Requests by head user or head organization and branch name in the format of "user:ref-name" or "organization:ref-name". For example: "github:new-script-format" or "octocat:test-branch". + HeadRef *string `pulumi:"headRef"` + // Owner of the repository. If not provided, the provider's default owner is used. + Owner *string `pulumi:"owner"` + // If set, indicates what to sort results by. Can be either "created", "updated", "popularity" (comment count) or "long-running" (age, filtering by pulls updated in the last month). Default: "created". + SortBy *string `pulumi:"sortBy"` + // If set, controls the direction of the sort. Can be either "asc" or "desc". Default: "asc". + SortDirection *string `pulumi:"sortDirection"` + // If set, filters Pull Requests by state. Can be "open", "closed", or "all". Default: "open". + State *string `pulumi:"state"` +} + +// A collection of values returned by getRepositoryPullRequests. +type LookupRepositoryPullRequestsResult struct { + // Name of the ref (branch) of the Pull Request base. + BaseRef *string `pulumi:"baseRef"` + BaseRepository string `pulumi:"baseRepository"` + // Value of the Pull Request `HEAD` reference. + HeadRef *string `pulumi:"headRef"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Owner *string `pulumi:"owner"` + // Collection of Pull Requests matching the filters. Each of the results conforms to the following scheme: + Results []GetRepositoryPullRequestsResult `pulumi:"results"` + SortBy *string `pulumi:"sortBy"` + SortDirection *string `pulumi:"sortDirection"` + // the current Pull Request state - can be "open", "closed" or "merged". + State *string `pulumi:"state"` +} + +func LookupRepositoryPullRequestsOutput(ctx *pulumi.Context, args LookupRepositoryPullRequestsOutputArgs, opts ...pulumi.InvokeOption) LookupRepositoryPullRequestsResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupRepositoryPullRequestsResultOutput, error) { + args := v.(LookupRepositoryPullRequestsArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRepositoryPullRequests:getRepositoryPullRequests", args, LookupRepositoryPullRequestsResultOutput{}, options).(LookupRepositoryPullRequestsResultOutput), nil + }).(LookupRepositoryPullRequestsResultOutput) +} + +// A collection of arguments for invoking getRepositoryPullRequests. +type LookupRepositoryPullRequestsOutputArgs struct { + // If set, filters Pull Requests by base branch name. + BaseRef pulumi.StringPtrInput `pulumi:"baseRef"` + // Name of the base repository to retrieve the Pull Requests from. + BaseRepository pulumi.StringInput `pulumi:"baseRepository"` + // If set, filters Pull Requests by head user or head organization and branch name in the format of "user:ref-name" or "organization:ref-name". For example: "github:new-script-format" or "octocat:test-branch". + HeadRef pulumi.StringPtrInput `pulumi:"headRef"` + // Owner of the repository. If not provided, the provider's default owner is used. + Owner pulumi.StringPtrInput `pulumi:"owner"` + // If set, indicates what to sort results by. Can be either "created", "updated", "popularity" (comment count) or "long-running" (age, filtering by pulls updated in the last month). Default: "created". + SortBy pulumi.StringPtrInput `pulumi:"sortBy"` + // If set, controls the direction of the sort. Can be either "asc" or "desc". Default: "asc". + SortDirection pulumi.StringPtrInput `pulumi:"sortDirection"` + // If set, filters Pull Requests by state. Can be "open", "closed", or "all". Default: "open". + State pulumi.StringPtrInput `pulumi:"state"` +} + +func (LookupRepositoryPullRequestsOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRepositoryPullRequestsArgs)(nil)).Elem() +} + +// A collection of values returned by getRepositoryPullRequests. +type LookupRepositoryPullRequestsResultOutput struct{ *pulumi.OutputState } + +func (LookupRepositoryPullRequestsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupRepositoryPullRequestsResult)(nil)).Elem() +} + +func (o LookupRepositoryPullRequestsResultOutput) ToLookupRepositoryPullRequestsResultOutput() LookupRepositoryPullRequestsResultOutput { + return o +} + +func (o LookupRepositoryPullRequestsResultOutput) ToLookupRepositoryPullRequestsResultOutputWithContext(ctx context.Context) LookupRepositoryPullRequestsResultOutput { + return o +} + +// Name of the ref (branch) of the Pull Request base. +func (o LookupRepositoryPullRequestsResultOutput) BaseRef() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestsResult) *string { return v.BaseRef }).(pulumi.StringPtrOutput) +} + +func (o LookupRepositoryPullRequestsResultOutput) BaseRepository() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestsResult) string { return v.BaseRepository }).(pulumi.StringOutput) +} + +// Value of the Pull Request `HEAD` reference. +func (o LookupRepositoryPullRequestsResultOutput) HeadRef() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestsResult) *string { return v.HeadRef }).(pulumi.StringPtrOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupRepositoryPullRequestsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestsResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o LookupRepositoryPullRequestsResultOutput) Owner() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestsResult) *string { return v.Owner }).(pulumi.StringPtrOutput) +} + +// Collection of Pull Requests matching the filters. Each of the results conforms to the following scheme: +func (o LookupRepositoryPullRequestsResultOutput) Results() GetRepositoryPullRequestsResultArrayOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestsResult) []GetRepositoryPullRequestsResult { return v.Results }).(GetRepositoryPullRequestsResultArrayOutput) +} + +func (o LookupRepositoryPullRequestsResultOutput) SortBy() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestsResult) *string { return v.SortBy }).(pulumi.StringPtrOutput) +} + +func (o LookupRepositoryPullRequestsResultOutput) SortDirection() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestsResult) *string { return v.SortDirection }).(pulumi.StringPtrOutput) +} + +// the current Pull Request state - can be "open", "closed" or "merged". +func (o LookupRepositoryPullRequestsResultOutput) State() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupRepositoryPullRequestsResult) *string { return v.State }).(pulumi.StringPtrOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupRepositoryPullRequestsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryTeams.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryTeams.go new file mode 100644 index 000000000..b72de532c --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryTeams.go @@ -0,0 +1,127 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve the list of teams which have access to a GitHub repository. +// +// ## Example Usage +// +// ```go +// 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.GetRepositoryTeams(ctx, &github.GetRepositoryTeamsArgs{ +// Name: pulumi.StringRef("example"), +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetRepositoryTeams(ctx *pulumi.Context, args *GetRepositoryTeamsArgs, opts ...pulumi.InvokeOption) (*GetRepositoryTeamsResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetRepositoryTeamsResult + err := ctx.Invoke("github:index/getRepositoryTeams:getRepositoryTeams", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRepositoryTeams. +type GetRepositoryTeamsArgs struct { + // Full name of the repository (in `org/name` format). + FullName *string `pulumi:"fullName"` + // The name of the repository. + Name *string `pulumi:"name"` +} + +// A collection of values returned by getRepositoryTeams. +type GetRepositoryTeamsResult struct { + FullName string `pulumi:"fullName"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // Team name + Name string `pulumi:"name"` + // List of teams which have access to the repository + Teams []GetRepositoryTeamsTeam `pulumi:"teams"` +} + +func GetRepositoryTeamsOutput(ctx *pulumi.Context, args GetRepositoryTeamsOutputArgs, opts ...pulumi.InvokeOption) GetRepositoryTeamsResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetRepositoryTeamsResultOutput, error) { + args := v.(GetRepositoryTeamsArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRepositoryTeams:getRepositoryTeams", args, GetRepositoryTeamsResultOutput{}, options).(GetRepositoryTeamsResultOutput), nil + }).(GetRepositoryTeamsResultOutput) +} + +// A collection of arguments for invoking getRepositoryTeams. +type GetRepositoryTeamsOutputArgs struct { + // Full name of the repository (in `org/name` format). + FullName pulumi.StringPtrInput `pulumi:"fullName"` + // The name of the repository. + Name pulumi.StringPtrInput `pulumi:"name"` +} + +func (GetRepositoryTeamsOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryTeamsArgs)(nil)).Elem() +} + +// A collection of values returned by getRepositoryTeams. +type GetRepositoryTeamsResultOutput struct{ *pulumi.OutputState } + +func (GetRepositoryTeamsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryTeamsResult)(nil)).Elem() +} + +func (o GetRepositoryTeamsResultOutput) ToGetRepositoryTeamsResultOutput() GetRepositoryTeamsResultOutput { + return o +} + +func (o GetRepositoryTeamsResultOutput) ToGetRepositoryTeamsResultOutputWithContext(ctx context.Context) GetRepositoryTeamsResultOutput { + return o +} + +func (o GetRepositoryTeamsResultOutput) FullName() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryTeamsResult) string { return v.FullName }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetRepositoryTeamsResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryTeamsResult) string { return v.Id }).(pulumi.StringOutput) +} + +// Team name +func (o GetRepositoryTeamsResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryTeamsResult) string { return v.Name }).(pulumi.StringOutput) +} + +// List of teams which have access to the repository +func (o GetRepositoryTeamsResultOutput) Teams() GetRepositoryTeamsTeamArrayOutput { + return o.ApplyT(func(v GetRepositoryTeamsResult) []GetRepositoryTeamsTeam { return v.Teams }).(GetRepositoryTeamsTeamArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetRepositoryTeamsResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryWebhooks.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryWebhooks.go new file mode 100644 index 000000000..121768f8e --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRepositoryWebhooks.go @@ -0,0 +1,118 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve webhooks for a given repository. +// +// ## Example Usage +// +// To retrieve webhooks of a repository: +// +// ```go +// 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.GetRepositoryWebhooks(ctx, &github.GetRepositoryWebhooksArgs{ +// Repository: "foo", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetRepositoryWebhooks(ctx *pulumi.Context, args *GetRepositoryWebhooksArgs, opts ...pulumi.InvokeOption) (*GetRepositoryWebhooksResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetRepositoryWebhooksResult + err := ctx.Invoke("github:index/getRepositoryWebhooks:getRepositoryWebhooks", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRepositoryWebhooks. +type GetRepositoryWebhooksArgs struct { + Repository string `pulumi:"repository"` +} + +// A collection of values returned by getRepositoryWebhooks. +type GetRepositoryWebhooksResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Repository string `pulumi:"repository"` + // An Array of GitHub Webhooks. Each `webhook` block consists of the fields documented below. + // *** + Webhooks []GetRepositoryWebhooksWebhook `pulumi:"webhooks"` +} + +func GetRepositoryWebhooksOutput(ctx *pulumi.Context, args GetRepositoryWebhooksOutputArgs, opts ...pulumi.InvokeOption) GetRepositoryWebhooksResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetRepositoryWebhooksResultOutput, error) { + args := v.(GetRepositoryWebhooksArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRepositoryWebhooks:getRepositoryWebhooks", args, GetRepositoryWebhooksResultOutput{}, options).(GetRepositoryWebhooksResultOutput), nil + }).(GetRepositoryWebhooksResultOutput) +} + +// A collection of arguments for invoking getRepositoryWebhooks. +type GetRepositoryWebhooksOutputArgs struct { + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetRepositoryWebhooksOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryWebhooksArgs)(nil)).Elem() +} + +// A collection of values returned by getRepositoryWebhooks. +type GetRepositoryWebhooksResultOutput struct{ *pulumi.OutputState } + +func (GetRepositoryWebhooksResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryWebhooksResult)(nil)).Elem() +} + +func (o GetRepositoryWebhooksResultOutput) ToGetRepositoryWebhooksResultOutput() GetRepositoryWebhooksResultOutput { + return o +} + +func (o GetRepositoryWebhooksResultOutput) ToGetRepositoryWebhooksResultOutputWithContext(ctx context.Context) GetRepositoryWebhooksResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetRepositoryWebhooksResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryWebhooksResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetRepositoryWebhooksResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryWebhooksResult) string { return v.Repository }).(pulumi.StringOutput) +} + +// An Array of GitHub Webhooks. Each `webhook` block consists of the fields documented below. +// *** +func (o GetRepositoryWebhooksResultOutput) Webhooks() GetRepositoryWebhooksWebhookArrayOutput { + return o.ApplyT(func(v GetRepositoryWebhooksResult) []GetRepositoryWebhooksWebhook { return v.Webhooks }).(GetRepositoryWebhooksWebhookArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetRepositoryWebhooksResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRestApi.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRestApi.go new file mode 100644 index 000000000..5c2a6bcdf --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getRestApi.go @@ -0,0 +1,137 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a GitHub resource through REST API. +// +// ## Example Usage +// +// ```go +// 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.GetRestApi(ctx, &github.GetRestApiArgs{ +// Endpoint: "repos/example_repo/git/refs/heads/main", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetRestApi(ctx *pulumi.Context, args *GetRestApiArgs, opts ...pulumi.InvokeOption) (*GetRestApiResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetRestApiResult + err := ctx.Invoke("github:index/getRestApi:getRestApi", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getRestApi. +type GetRestApiArgs struct { + // REST API endpoint to send the GET request to. + Endpoint string `pulumi:"endpoint"` +} + +// A collection of values returned by getRestApi. +type GetRestApiResult struct { + // A JSON string containing response body. + Body string `pulumi:"body"` + // A response status code. + Code int `pulumi:"code"` + Endpoint string `pulumi:"endpoint"` + // A JSON string containing response headers. + Headers string `pulumi:"headers"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // A response status string. + Status string `pulumi:"status"` +} + +func GetRestApiOutput(ctx *pulumi.Context, args GetRestApiOutputArgs, opts ...pulumi.InvokeOption) GetRestApiResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetRestApiResultOutput, error) { + args := v.(GetRestApiArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getRestApi:getRestApi", args, GetRestApiResultOutput{}, options).(GetRestApiResultOutput), nil + }).(GetRestApiResultOutput) +} + +// A collection of arguments for invoking getRestApi. +type GetRestApiOutputArgs struct { + // REST API endpoint to send the GET request to. + Endpoint pulumi.StringInput `pulumi:"endpoint"` +} + +func (GetRestApiOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRestApiArgs)(nil)).Elem() +} + +// A collection of values returned by getRestApi. +type GetRestApiResultOutput struct{ *pulumi.OutputState } + +func (GetRestApiResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRestApiResult)(nil)).Elem() +} + +func (o GetRestApiResultOutput) ToGetRestApiResultOutput() GetRestApiResultOutput { + return o +} + +func (o GetRestApiResultOutput) ToGetRestApiResultOutputWithContext(ctx context.Context) GetRestApiResultOutput { + return o +} + +// A JSON string containing response body. +func (o GetRestApiResultOutput) Body() pulumi.StringOutput { + return o.ApplyT(func(v GetRestApiResult) string { return v.Body }).(pulumi.StringOutput) +} + +// A response status code. +func (o GetRestApiResultOutput) Code() pulumi.IntOutput { + return o.ApplyT(func(v GetRestApiResult) int { return v.Code }).(pulumi.IntOutput) +} + +func (o GetRestApiResultOutput) Endpoint() pulumi.StringOutput { + return o.ApplyT(func(v GetRestApiResult) string { return v.Endpoint }).(pulumi.StringOutput) +} + +// A JSON string containing response headers. +func (o GetRestApiResultOutput) Headers() pulumi.StringOutput { + return o.ApplyT(func(v GetRestApiResult) string { return v.Headers }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetRestApiResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetRestApiResult) string { return v.Id }).(pulumi.StringOutput) +} + +// A response status string. +func (o GetRestApiResultOutput) Status() pulumi.StringOutput { + return o.ApplyT(func(v GetRestApiResult) string { return v.Status }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetRestApiResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getSshKeys.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getSshKeys.go new file mode 100644 index 000000000..f075338b2 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getSshKeys.go @@ -0,0 +1,91 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about GitHub's SSH keys. +// +// ## Example Usage +// +// ```go +// 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.GetSshKeys(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetSshKeys(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetSshKeysResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetSshKeysResult + err := ctx.Invoke("github:index/getSshKeys:getSshKeys", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getSshKeys. +type GetSshKeysResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // An array of GitHub's SSH public keys. + Keys []string `pulumi:"keys"` +} + +func GetSshKeysOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetSshKeysResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetSshKeysResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getSshKeys:getSshKeys", nil, GetSshKeysResultOutput{}, options).(GetSshKeysResultOutput), nil + }).(GetSshKeysResultOutput) +} + +// A collection of values returned by getSshKeys. +type GetSshKeysResultOutput struct{ *pulumi.OutputState } + +func (GetSshKeysResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetSshKeysResult)(nil)).Elem() +} + +func (o GetSshKeysResultOutput) ToGetSshKeysResultOutput() GetSshKeysResultOutput { + return o +} + +func (o GetSshKeysResultOutput) ToGetSshKeysResultOutputWithContext(ctx context.Context) GetSshKeysResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetSshKeysResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetSshKeysResult) string { return v.Id }).(pulumi.StringOutput) +} + +// An array of GitHub's SSH public keys. +func (o GetSshKeysResultOutput) Keys() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetSshKeysResult) []string { return v.Keys }).(pulumi.StringArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetSshKeysResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getTeam.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getTeam.go new file mode 100644 index 000000000..08890a1e2 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getTeam.go @@ -0,0 +1,213 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a GitHub team. +// +// ## Example Usage +// +// ```go +// 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.GetTeam(ctx, &github.LookupTeamArgs{ +// Slug: "example", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func LookupTeam(ctx *pulumi.Context, args *LookupTeamArgs, opts ...pulumi.InvokeOption) (*LookupTeamResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv LookupTeamResult + err := ctx.Invoke("github:index/getTeam:getTeam", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getTeam. +type LookupTeamArgs struct { + // Type of membership to be requested to fill the list of members. Can be either `all` _(default)_ or `immediate`. + MembershipType *string `pulumi:"membershipType"` + // (Optional) Set the number of results per REST API query. Accepts a value between 0 - 100 _(defaults to `100`)_. + // + // Deprecated: This is deprecated and will be removed in a future release. + ResultsPerPage *int `pulumi:"resultsPerPage"` + // The team slug. + Slug string `pulumi:"slug"` + // Exclude the members and repositories of the team from the returned result. Defaults to `false`. + SummaryOnly *bool `pulumi:"summaryOnly"` +} + +// A collection of values returned by getTeam. +type LookupTeamResult struct { + // Team's description. + Description string `pulumi:"description"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // List of team members (list of GitHub usernames). Not returned if `summaryOnly = true`. + Members []string `pulumi:"members"` + MembershipType *string `pulumi:"membershipType"` + // Team's full name. + Name string `pulumi:"name"` + // Node ID of the team. + NodeId string `pulumi:"nodeId"` + // Teams's notification setting. Can be either `notificationsEnabled` or `notificationsDisabled`. + NotificationSetting string `pulumi:"notificationSetting"` + // (**DEPRECATED**) The permission that new repositories will be added to the team with when none is specified. + // + // Deprecated: Closing down notice. + Permission string `pulumi:"permission"` + // Team's privacy type. Can either be `closed` or `secret`. + Privacy string `pulumi:"privacy"` + // (**DEPRECATED**) List of team repositories (list of repo names). Not returned if `summaryOnly = true`. + // + // Deprecated: Use repositoriesDetailed instead. + Repositories []string `pulumi:"repositories"` + // List of team repositories (each item comprises of `repoId`, `repoName` & `roleName`). Not returned if `summaryOnly = true`. + RepositoriesDetaileds []GetTeamRepositoriesDetailed `pulumi:"repositoriesDetaileds"` + // Deprecated: This is deprecated and will be removed in a future release. + ResultsPerPage *int `pulumi:"resultsPerPage"` + Slug string `pulumi:"slug"` + SummaryOnly *bool `pulumi:"summaryOnly"` +} + +func LookupTeamOutput(ctx *pulumi.Context, args LookupTeamOutputArgs, opts ...pulumi.InvokeOption) LookupTeamResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (LookupTeamResultOutput, error) { + args := v.(LookupTeamArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getTeam:getTeam", args, LookupTeamResultOutput{}, options).(LookupTeamResultOutput), nil + }).(LookupTeamResultOutput) +} + +// A collection of arguments for invoking getTeam. +type LookupTeamOutputArgs struct { + // Type of membership to be requested to fill the list of members. Can be either `all` _(default)_ or `immediate`. + MembershipType pulumi.StringPtrInput `pulumi:"membershipType"` + // (Optional) Set the number of results per REST API query. Accepts a value between 0 - 100 _(defaults to `100`)_. + // + // Deprecated: This is deprecated and will be removed in a future release. + ResultsPerPage pulumi.IntPtrInput `pulumi:"resultsPerPage"` + // The team slug. + Slug pulumi.StringInput `pulumi:"slug"` + // Exclude the members and repositories of the team from the returned result. Defaults to `false`. + SummaryOnly pulumi.BoolPtrInput `pulumi:"summaryOnly"` +} + +func (LookupTeamOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*LookupTeamArgs)(nil)).Elem() +} + +// A collection of values returned by getTeam. +type LookupTeamResultOutput struct{ *pulumi.OutputState } + +func (LookupTeamResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*LookupTeamResult)(nil)).Elem() +} + +func (o LookupTeamResultOutput) ToLookupTeamResultOutput() LookupTeamResultOutput { + return o +} + +func (o LookupTeamResultOutput) ToLookupTeamResultOutputWithContext(ctx context.Context) LookupTeamResultOutput { + return o +} + +// Team's description. +func (o LookupTeamResultOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v LookupTeamResult) string { return v.Description }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o LookupTeamResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v LookupTeamResult) string { return v.Id }).(pulumi.StringOutput) +} + +// List of team members (list of GitHub usernames). Not returned if `summaryOnly = true`. +func (o LookupTeamResultOutput) Members() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupTeamResult) []string { return v.Members }).(pulumi.StringArrayOutput) +} + +func (o LookupTeamResultOutput) MembershipType() pulumi.StringPtrOutput { + return o.ApplyT(func(v LookupTeamResult) *string { return v.MembershipType }).(pulumi.StringPtrOutput) +} + +// Team's full name. +func (o LookupTeamResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v LookupTeamResult) string { return v.Name }).(pulumi.StringOutput) +} + +// Node ID of the team. +func (o LookupTeamResultOutput) NodeId() pulumi.StringOutput { + return o.ApplyT(func(v LookupTeamResult) string { return v.NodeId }).(pulumi.StringOutput) +} + +// Teams's notification setting. Can be either `notificationsEnabled` or `notificationsDisabled`. +func (o LookupTeamResultOutput) NotificationSetting() pulumi.StringOutput { + return o.ApplyT(func(v LookupTeamResult) string { return v.NotificationSetting }).(pulumi.StringOutput) +} + +// (**DEPRECATED**) The permission that new repositories will be added to the team with when none is specified. +// +// Deprecated: Closing down notice. +func (o LookupTeamResultOutput) Permission() pulumi.StringOutput { + return o.ApplyT(func(v LookupTeamResult) string { return v.Permission }).(pulumi.StringOutput) +} + +// Team's privacy type. Can either be `closed` or `secret`. +func (o LookupTeamResultOutput) Privacy() pulumi.StringOutput { + return o.ApplyT(func(v LookupTeamResult) string { return v.Privacy }).(pulumi.StringOutput) +} + +// (**DEPRECATED**) List of team repositories (list of repo names). Not returned if `summaryOnly = true`. +// +// Deprecated: Use repositoriesDetailed instead. +func (o LookupTeamResultOutput) Repositories() pulumi.StringArrayOutput { + return o.ApplyT(func(v LookupTeamResult) []string { return v.Repositories }).(pulumi.StringArrayOutput) +} + +// List of team repositories (each item comprises of `repoId`, `repoName` & `roleName`). Not returned if `summaryOnly = true`. +func (o LookupTeamResultOutput) RepositoriesDetaileds() GetTeamRepositoriesDetailedArrayOutput { + return o.ApplyT(func(v LookupTeamResult) []GetTeamRepositoriesDetailed { return v.RepositoriesDetaileds }).(GetTeamRepositoriesDetailedArrayOutput) +} + +// Deprecated: This is deprecated and will be removed in a future release. +func (o LookupTeamResultOutput) ResultsPerPage() pulumi.IntPtrOutput { + return o.ApplyT(func(v LookupTeamResult) *int { return v.ResultsPerPage }).(pulumi.IntPtrOutput) +} + +func (o LookupTeamResultOutput) Slug() pulumi.StringOutput { + return o.ApplyT(func(v LookupTeamResult) string { return v.Slug }).(pulumi.StringOutput) +} + +func (o LookupTeamResultOutput) SummaryOnly() pulumi.BoolPtrOutput { + return o.ApplyT(func(v LookupTeamResult) *bool { return v.SummaryOnly }).(pulumi.BoolPtrOutput) +} + +func init() { + pulumi.RegisterOutputType(LookupTeamResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getTree.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getTree.go new file mode 100644 index 000000000..9caf7c2e0 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getTree.go @@ -0,0 +1,150 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a single tree. +// +// ## Example Usage +// +// ```go +// 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 { +// this, err := github.GetRepository(ctx, &github.LookupRepositoryArgs{ +// Name: pulumi.StringRef("example"), +// }, nil) +// if err != nil { +// return err +// } +// thisGetBranch, err := github.GetBranch(ctx, &github.LookupBranchArgs{ +// Branch: this.DefaultBranch, +// Repository: this.Name, +// }, nil) +// if err != nil { +// return err +// } +// thisGetTree, err := github.GetTree(ctx, &github.GetTreeArgs{ +// Recursive: pulumi.BoolRef(false), +// Repository: this.Name, +// TreeSha: thisGetBranch.Sha, +// }, nil) +// if err != nil { +// return err +// } +// ctx.Export("entries", thisGetTree.Entries) +// return nil +// }) +// } +// +// ``` +func GetTree(ctx *pulumi.Context, args *GetTreeArgs, opts ...pulumi.InvokeOption) (*GetTreeResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetTreeResult + err := ctx.Invoke("github:index/getTree:getTree", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getTree. +type GetTreeArgs struct { + // Setting this parameter to `true` returns the objects or subtrees referenced by the tree specified in `treeSha`. + Recursive *bool `pulumi:"recursive"` + // The name of the repository. + Repository string `pulumi:"repository"` + // The SHA1 value for the tree. + TreeSha string `pulumi:"treeSha"` +} + +// A collection of values returned by getTree. +type GetTreeResult struct { + // Objects (of `path`, `mode`, `type`, `size`, and `sha`) specifying a tree structure. + Entries []GetTreeEntry `pulumi:"entries"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Recursive *bool `pulumi:"recursive"` + Repository string `pulumi:"repository"` + TreeSha string `pulumi:"treeSha"` +} + +func GetTreeOutput(ctx *pulumi.Context, args GetTreeOutputArgs, opts ...pulumi.InvokeOption) GetTreeResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetTreeResultOutput, error) { + args := v.(GetTreeArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getTree:getTree", args, GetTreeResultOutput{}, options).(GetTreeResultOutput), nil + }).(GetTreeResultOutput) +} + +// A collection of arguments for invoking getTree. +type GetTreeOutputArgs struct { + // Setting this parameter to `true` returns the objects or subtrees referenced by the tree specified in `treeSha`. + Recursive pulumi.BoolPtrInput `pulumi:"recursive"` + // The name of the repository. + Repository pulumi.StringInput `pulumi:"repository"` + // The SHA1 value for the tree. + TreeSha pulumi.StringInput `pulumi:"treeSha"` +} + +func (GetTreeOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetTreeArgs)(nil)).Elem() +} + +// A collection of values returned by getTree. +type GetTreeResultOutput struct{ *pulumi.OutputState } + +func (GetTreeResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetTreeResult)(nil)).Elem() +} + +func (o GetTreeResultOutput) ToGetTreeResultOutput() GetTreeResultOutput { + return o +} + +func (o GetTreeResultOutput) ToGetTreeResultOutputWithContext(ctx context.Context) GetTreeResultOutput { + return o +} + +// Objects (of `path`, `mode`, `type`, `size`, and `sha`) specifying a tree structure. +func (o GetTreeResultOutput) Entries() GetTreeEntryArrayOutput { + return o.ApplyT(func(v GetTreeResult) []GetTreeEntry { return v.Entries }).(GetTreeEntryArrayOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetTreeResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetTreeResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetTreeResultOutput) Recursive() pulumi.BoolPtrOutput { + return o.ApplyT(func(v GetTreeResult) *bool { return v.Recursive }).(pulumi.BoolPtrOutput) +} + +func (o GetTreeResultOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetTreeResult) string { return v.Repository }).(pulumi.StringOutput) +} + +func (o GetTreeResultOutput) TreeSha() pulumi.StringOutput { + return o.ApplyT(func(v GetTreeResult) string { return v.TreeSha }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetTreeResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getUser.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getUser.go new file mode 100644 index 000000000..e399016ba --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getUser.go @@ -0,0 +1,258 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about a GitHub user. +// +// ## Example Usage +// +// ```go +// 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 { +// // Retrieve information about a GitHub user. +// _, err := github.GetUser(ctx, &github.GetUserArgs{ +// Username: "example", +// }, nil) +// if err != nil { +// return err +// } +// // Retrieve information about the currently authenticated user. +// current, err := github.GetUser(ctx, &github.GetUserArgs{ +// Username: "", +// }, nil) +// if err != nil { +// return err +// } +// ctx.Export("currentGithubLogin", current.Login) +// return nil +// }) +// } +// +// ``` +func GetUser(ctx *pulumi.Context, args *GetUserArgs, opts ...pulumi.InvokeOption) (*GetUserResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetUserResult + err := ctx.Invoke("github:index/getUser:getUser", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getUser. +type GetUserArgs struct { + // The username. Use an empty string `""` to retrieve information about the currently authenticated user. + Username string `pulumi:"username"` +} + +// A collection of values returned by getUser. +type GetUserResult struct { + // the user's avatar URL. + AvatarUrl string `pulumi:"avatarUrl"` + // the user's bio. + Bio string `pulumi:"bio"` + // the user's blog location. + Blog string `pulumi:"blog"` + // the user's company name. + Company string `pulumi:"company"` + // the creation date. + CreatedAt string `pulumi:"createdAt"` + // the user's email. + Email string `pulumi:"email"` + // the number of followers. + Followers int `pulumi:"followers"` + // the number of following users. + Following int `pulumi:"following"` + // list of user's GPG keys. + GpgKeys []string `pulumi:"gpgKeys"` + // the user's gravatar ID. + GravatarId string `pulumi:"gravatarId"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // the user's location. + Location string `pulumi:"location"` + // the user's login. + Login string `pulumi:"login"` + // the user's full name. + Name string `pulumi:"name"` + // the Node ID of the user. + NodeId string `pulumi:"nodeId"` + // the number of public gists. + PublicGists int `pulumi:"publicGists"` + // the number of public repositories. + PublicRepos int `pulumi:"publicRepos"` + // whether the user is a GitHub admin. + SiteAdmin bool `pulumi:"siteAdmin"` + // list of user's SSH keys. + SshKeys []string `pulumi:"sshKeys"` + // the suspended date if the user is suspended. + SuspendedAt string `pulumi:"suspendedAt"` + // the update date. + UpdatedAt string `pulumi:"updatedAt"` + Username string `pulumi:"username"` +} + +func GetUserOutput(ctx *pulumi.Context, args GetUserOutputArgs, opts ...pulumi.InvokeOption) GetUserResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetUserResultOutput, error) { + args := v.(GetUserArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getUser:getUser", args, GetUserResultOutput{}, options).(GetUserResultOutput), nil + }).(GetUserResultOutput) +} + +// A collection of arguments for invoking getUser. +type GetUserOutputArgs struct { + // The username. Use an empty string `""` to retrieve information about the currently authenticated user. + Username pulumi.StringInput `pulumi:"username"` +} + +func (GetUserOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetUserArgs)(nil)).Elem() +} + +// A collection of values returned by getUser. +type GetUserResultOutput struct{ *pulumi.OutputState } + +func (GetUserResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetUserResult)(nil)).Elem() +} + +func (o GetUserResultOutput) ToGetUserResultOutput() GetUserResultOutput { + return o +} + +func (o GetUserResultOutput) ToGetUserResultOutputWithContext(ctx context.Context) GetUserResultOutput { + return o +} + +// the user's avatar URL. +func (o GetUserResultOutput) AvatarUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetUserResult) string { return v.AvatarUrl }).(pulumi.StringOutput) +} + +// the user's bio. +func (o GetUserResultOutput) Bio() pulumi.StringOutput { + return o.ApplyT(func(v GetUserResult) string { return v.Bio }).(pulumi.StringOutput) +} + +// the user's blog location. +func (o GetUserResultOutput) Blog() pulumi.StringOutput { + return o.ApplyT(func(v GetUserResult) string { return v.Blog }).(pulumi.StringOutput) +} + +// the user's company name. +func (o GetUserResultOutput) Company() pulumi.StringOutput { + return o.ApplyT(func(v GetUserResult) string { return v.Company }).(pulumi.StringOutput) +} + +// the creation date. +func (o GetUserResultOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetUserResult) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// the user's email. +func (o GetUserResultOutput) Email() pulumi.StringOutput { + return o.ApplyT(func(v GetUserResult) string { return v.Email }).(pulumi.StringOutput) +} + +// the number of followers. +func (o GetUserResultOutput) Followers() pulumi.IntOutput { + return o.ApplyT(func(v GetUserResult) int { return v.Followers }).(pulumi.IntOutput) +} + +// the number of following users. +func (o GetUserResultOutput) Following() pulumi.IntOutput { + return o.ApplyT(func(v GetUserResult) int { return v.Following }).(pulumi.IntOutput) +} + +// list of user's GPG keys. +func (o GetUserResultOutput) GpgKeys() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetUserResult) []string { return v.GpgKeys }).(pulumi.StringArrayOutput) +} + +// the user's gravatar ID. +func (o GetUserResultOutput) GravatarId() pulumi.StringOutput { + return o.ApplyT(func(v GetUserResult) string { return v.GravatarId }).(pulumi.StringOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetUserResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetUserResult) string { return v.Id }).(pulumi.StringOutput) +} + +// the user's location. +func (o GetUserResultOutput) Location() pulumi.StringOutput { + return o.ApplyT(func(v GetUserResult) string { return v.Location }).(pulumi.StringOutput) +} + +// the user's login. +func (o GetUserResultOutput) Login() pulumi.StringOutput { + return o.ApplyT(func(v GetUserResult) string { return v.Login }).(pulumi.StringOutput) +} + +// the user's full name. +func (o GetUserResultOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetUserResult) string { return v.Name }).(pulumi.StringOutput) +} + +// the Node ID of the user. +func (o GetUserResultOutput) NodeId() pulumi.StringOutput { + return o.ApplyT(func(v GetUserResult) string { return v.NodeId }).(pulumi.StringOutput) +} + +// the number of public gists. +func (o GetUserResultOutput) PublicGists() pulumi.IntOutput { + return o.ApplyT(func(v GetUserResult) int { return v.PublicGists }).(pulumi.IntOutput) +} + +// the number of public repositories. +func (o GetUserResultOutput) PublicRepos() pulumi.IntOutput { + return o.ApplyT(func(v GetUserResult) int { return v.PublicRepos }).(pulumi.IntOutput) +} + +// whether the user is a GitHub admin. +func (o GetUserResultOutput) SiteAdmin() pulumi.BoolOutput { + return o.ApplyT(func(v GetUserResult) bool { return v.SiteAdmin }).(pulumi.BoolOutput) +} + +// list of user's SSH keys. +func (o GetUserResultOutput) SshKeys() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetUserResult) []string { return v.SshKeys }).(pulumi.StringArrayOutput) +} + +// the suspended date if the user is suspended. +func (o GetUserResultOutput) SuspendedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetUserResult) string { return v.SuspendedAt }).(pulumi.StringOutput) +} + +// the update date. +func (o GetUserResultOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetUserResult) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +func (o GetUserResultOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v GetUserResult) string { return v.Username }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetUserResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getUserExternalIdentity.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getUserExternalIdentity.go new file mode 100644 index 000000000..0aa7e1065 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getUserExternalIdentity.go @@ -0,0 +1,137 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve a specific organization member's SAML or SCIM user +// attributes. +// +// ## Example Usage +// +// ```go +// 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.GetUserExternalIdentity(ctx, &github.GetUserExternalIdentityArgs{ +// Username: "example-user", +// }, nil) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +func GetUserExternalIdentity(ctx *pulumi.Context, args *GetUserExternalIdentityArgs, opts ...pulumi.InvokeOption) (*GetUserExternalIdentityResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetUserExternalIdentityResult + err := ctx.Invoke("github:index/getUserExternalIdentity:getUserExternalIdentity", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getUserExternalIdentity. +type GetUserExternalIdentityArgs struct { + // The username of the member to fetch external identity for. + Username string `pulumi:"username"` +} + +// A collection of values returned by getUserExternalIdentity. +type GetUserExternalIdentityResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // The username of the GitHub user + Login string `pulumi:"login"` + // An Object containing the user's SAML data. This object will + // be empty if the user is not managed by SAML. + SamlIdentity map[string]string `pulumi:"samlIdentity"` + // An Object contining the user's SCIM data. This object will + // be empty if the user is not managed by SCIM. + ScimIdentity map[string]string `pulumi:"scimIdentity"` + // The member's SAML Username + Username string `pulumi:"username"` +} + +func GetUserExternalIdentityOutput(ctx *pulumi.Context, args GetUserExternalIdentityOutputArgs, opts ...pulumi.InvokeOption) GetUserExternalIdentityResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetUserExternalIdentityResultOutput, error) { + args := v.(GetUserExternalIdentityArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getUserExternalIdentity:getUserExternalIdentity", args, GetUserExternalIdentityResultOutput{}, options).(GetUserExternalIdentityResultOutput), nil + }).(GetUserExternalIdentityResultOutput) +} + +// A collection of arguments for invoking getUserExternalIdentity. +type GetUserExternalIdentityOutputArgs struct { + // The username of the member to fetch external identity for. + Username pulumi.StringInput `pulumi:"username"` +} + +func (GetUserExternalIdentityOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetUserExternalIdentityArgs)(nil)).Elem() +} + +// A collection of values returned by getUserExternalIdentity. +type GetUserExternalIdentityResultOutput struct{ *pulumi.OutputState } + +func (GetUserExternalIdentityResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetUserExternalIdentityResult)(nil)).Elem() +} + +func (o GetUserExternalIdentityResultOutput) ToGetUserExternalIdentityResultOutput() GetUserExternalIdentityResultOutput { + return o +} + +func (o GetUserExternalIdentityResultOutput) ToGetUserExternalIdentityResultOutputWithContext(ctx context.Context) GetUserExternalIdentityResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetUserExternalIdentityResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetUserExternalIdentityResult) string { return v.Id }).(pulumi.StringOutput) +} + +// The username of the GitHub user +func (o GetUserExternalIdentityResultOutput) Login() pulumi.StringOutput { + return o.ApplyT(func(v GetUserExternalIdentityResult) string { return v.Login }).(pulumi.StringOutput) +} + +// An Object containing the user's SAML data. This object will +// be empty if the user is not managed by SAML. +func (o GetUserExternalIdentityResultOutput) SamlIdentity() pulumi.StringMapOutput { + return o.ApplyT(func(v GetUserExternalIdentityResult) map[string]string { return v.SamlIdentity }).(pulumi.StringMapOutput) +} + +// An Object contining the user's SCIM data. This object will +// be empty if the user is not managed by SCIM. +func (o GetUserExternalIdentityResultOutput) ScimIdentity() pulumi.StringMapOutput { + return o.ApplyT(func(v GetUserExternalIdentityResult) map[string]string { return v.ScimIdentity }).(pulumi.StringMapOutput) +} + +// The member's SAML Username +func (o GetUserExternalIdentityResultOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v GetUserExternalIdentityResult) string { return v.Username }).(pulumi.StringOutput) +} + +func init() { + pulumi.RegisterOutputType(GetUserExternalIdentityResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getUsers.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getUsers.go new file mode 100644 index 000000000..4fbbcb110 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/getUsers.go @@ -0,0 +1,144 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Use this data source to retrieve information about multiple GitHub users at once. +// +// ## Example Usage +// +// ```go +// 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 { +// // Retrieve information about multiple GitHub users. +// example, err := github.GetUsers(ctx, &github.GetUsersArgs{ +// Usernames: []string{ +// "example1", +// "example2", +// "example3", +// }, +// }, nil) +// if err != nil { +// return err +// } +// ctx.Export("validUsers", example.Logins) +// ctx.Export("invalidUsers", example.UnknownLogins) +// return nil +// }) +// } +// +// ``` +func GetUsers(ctx *pulumi.Context, args *GetUsersArgs, opts ...pulumi.InvokeOption) (*GetUsersResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetUsersResult + err := ctx.Invoke("github:index/getUsers:getUsers", args, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of arguments for invoking getUsers. +type GetUsersArgs struct { + // List of usernames. + Usernames []string `pulumi:"usernames"` +} + +// A collection of values returned by getUsers. +type GetUsersResult struct { + // list of the user's publicly visible profile email (will be empty string in case if user decided not to show it). + Emails []string `pulumi:"emails"` + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + // list of logins of users that could be found. + Logins []string `pulumi:"logins"` + // list of Node IDs of users that could be found. + NodeIds []string `pulumi:"nodeIds"` + // list of logins without matching user. + UnknownLogins []string `pulumi:"unknownLogins"` + Usernames []string `pulumi:"usernames"` +} + +func GetUsersOutput(ctx *pulumi.Context, args GetUsersOutputArgs, opts ...pulumi.InvokeOption) GetUsersResultOutput { + return pulumi.ToOutputWithContext(ctx.Context(), args). + ApplyT(func(v interface{}) (GetUsersResultOutput, error) { + args := v.(GetUsersArgs) + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("github:index/getUsers:getUsers", args, GetUsersResultOutput{}, options).(GetUsersResultOutput), nil + }).(GetUsersResultOutput) +} + +// A collection of arguments for invoking getUsers. +type GetUsersOutputArgs struct { + // List of usernames. + Usernames pulumi.StringArrayInput `pulumi:"usernames"` +} + +func (GetUsersOutputArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetUsersArgs)(nil)).Elem() +} + +// A collection of values returned by getUsers. +type GetUsersResultOutput struct{ *pulumi.OutputState } + +func (GetUsersResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetUsersResult)(nil)).Elem() +} + +func (o GetUsersResultOutput) ToGetUsersResultOutput() GetUsersResultOutput { + return o +} + +func (o GetUsersResultOutput) ToGetUsersResultOutputWithContext(ctx context.Context) GetUsersResultOutput { + return o +} + +// list of the user's publicly visible profile email (will be empty string in case if user decided not to show it). +func (o GetUsersResultOutput) Emails() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetUsersResult) []string { return v.Emails }).(pulumi.StringArrayOutput) +} + +// The provider-assigned unique ID for this managed resource. +func (o GetUsersResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetUsersResult) string { return v.Id }).(pulumi.StringOutput) +} + +// list of logins of users that could be found. +func (o GetUsersResultOutput) Logins() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetUsersResult) []string { return v.Logins }).(pulumi.StringArrayOutput) +} + +// list of Node IDs of users that could be found. +func (o GetUsersResultOutput) NodeIds() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetUsersResult) []string { return v.NodeIds }).(pulumi.StringArrayOutput) +} + +// list of logins without matching user. +func (o GetUsersResultOutput) UnknownLogins() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetUsersResult) []string { return v.UnknownLogins }).(pulumi.StringArrayOutput) +} + +func (o GetUsersResultOutput) Usernames() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetUsersResult) []string { return v.Usernames }).(pulumi.StringArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetUsersResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/init.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/init.go new file mode 100644 index 000000000..4e32c0134 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/init.go @@ -0,0 +1,675 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "fmt" + + "github.com/blang/semver" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +type module struct { + version semver.Version +} + +func (m *module) Version() semver.Version { + return m.version +} + +func (m *module) Construct(ctx *pulumi.Context, name, typ, urn string) (r pulumi.Resource, err error) { + switch typ { + case "github:index/actionsEnvironmentSecret:ActionsEnvironmentSecret": + r = &ActionsEnvironmentSecret{} + case "github:index/actionsEnvironmentVariable:ActionsEnvironmentVariable": + r = &ActionsEnvironmentVariable{} + case "github:index/actionsHostedRunner:ActionsHostedRunner": + r = &ActionsHostedRunner{} + case "github:index/actionsOrganizationOidcSubjectClaimCustomizationTemplate:ActionsOrganizationOidcSubjectClaimCustomizationTemplate": + r = &ActionsOrganizationOidcSubjectClaimCustomizationTemplate{} + case "github:index/actionsOrganizationPermissions:ActionsOrganizationPermissions": + r = &ActionsOrganizationPermissions{} + case "github:index/actionsOrganizationSecret:ActionsOrganizationSecret": + r = &ActionsOrganizationSecret{} + case "github:index/actionsOrganizationSecretRepositories:ActionsOrganizationSecretRepositories": + r = &ActionsOrganizationSecretRepositories{} + case "github:index/actionsOrganizationSecretRepository:ActionsOrganizationSecretRepository": + r = &ActionsOrganizationSecretRepository{} + case "github:index/actionsOrganizationVariable:ActionsOrganizationVariable": + r = &ActionsOrganizationVariable{} + case "github:index/actionsOrganizationVariableRepositories:ActionsOrganizationVariableRepositories": + r = &ActionsOrganizationVariableRepositories{} + case "github:index/actionsOrganizationVariableRepository:ActionsOrganizationVariableRepository": + r = &ActionsOrganizationVariableRepository{} + case "github:index/actionsOrganizationWorkflowPermissions:ActionsOrganizationWorkflowPermissions": + r = &ActionsOrganizationWorkflowPermissions{} + case "github:index/actionsRepositoryAccessLevel:ActionsRepositoryAccessLevel": + r = &ActionsRepositoryAccessLevel{} + case "github:index/actionsRepositoryOidcSubjectClaimCustomizationTemplate:ActionsRepositoryOidcSubjectClaimCustomizationTemplate": + r = &ActionsRepositoryOidcSubjectClaimCustomizationTemplate{} + case "github:index/actionsRepositoryPermissions:ActionsRepositoryPermissions": + r = &ActionsRepositoryPermissions{} + case "github:index/actionsRunnerGroup:ActionsRunnerGroup": + r = &ActionsRunnerGroup{} + case "github:index/actionsSecret:ActionsSecret": + r = &ActionsSecret{} + case "github:index/actionsVariable:ActionsVariable": + r = &ActionsVariable{} + case "github:index/appInstallationRepositories:AppInstallationRepositories": + r = &AppInstallationRepositories{} + case "github:index/appInstallationRepository:AppInstallationRepository": + r = &AppInstallationRepository{} + case "github:index/branch:Branch": + r = &Branch{} + case "github:index/branchDefault:BranchDefault": + r = &BranchDefault{} + case "github:index/branchProtection:BranchProtection": + r = &BranchProtection{} + case "github:index/branchProtectionV3:BranchProtectionV3": + r = &BranchProtectionV3{} + case "github:index/codespacesOrganizationSecret:CodespacesOrganizationSecret": + r = &CodespacesOrganizationSecret{} + case "github:index/codespacesOrganizationSecretRepositories:CodespacesOrganizationSecretRepositories": + r = &CodespacesOrganizationSecretRepositories{} + case "github:index/codespacesSecret:CodespacesSecret": + r = &CodespacesSecret{} + case "github:index/codespacesUserSecret:CodespacesUserSecret": + r = &CodespacesUserSecret{} + case "github:index/dependabotOrganizationSecret:DependabotOrganizationSecret": + r = &DependabotOrganizationSecret{} + case "github:index/dependabotOrganizationSecretRepositories:DependabotOrganizationSecretRepositories": + r = &DependabotOrganizationSecretRepositories{} + case "github:index/dependabotOrganizationSecretRepository:DependabotOrganizationSecretRepository": + r = &DependabotOrganizationSecretRepository{} + case "github:index/dependabotSecret:DependabotSecret": + r = &DependabotSecret{} + case "github:index/emuGroupMapping:EmuGroupMapping": + r = &EmuGroupMapping{} + case "github:index/enterpriseActionsPermissions:EnterpriseActionsPermissions": + r = &EnterpriseActionsPermissions{} + case "github:index/enterpriseActionsRunnerGroup:EnterpriseActionsRunnerGroup": + r = &EnterpriseActionsRunnerGroup{} + case "github:index/enterpriseActionsWorkflowPermissions:EnterpriseActionsWorkflowPermissions": + r = &EnterpriseActionsWorkflowPermissions{} + case "github:index/enterpriseIpAllowListEntry:EnterpriseIpAllowListEntry": + r = &EnterpriseIpAllowListEntry{} + case "github:index/enterpriseOrganization:EnterpriseOrganization": + r = &EnterpriseOrganization{} + case "github:index/enterpriseSecurityAnalysisSettings:EnterpriseSecurityAnalysisSettings": + r = &EnterpriseSecurityAnalysisSettings{} + case "github:index/issue:Issue": + r = &Issue{} + case "github:index/issueLabel:IssueLabel": + r = &IssueLabel{} + case "github:index/issueLabels:IssueLabels": + r = &IssueLabels{} + case "github:index/membership:Membership": + r = &Membership{} + case "github:index/organizationBlock:OrganizationBlock": + r = &OrganizationBlock{} + case "github:index/organizationCustomProperties:OrganizationCustomProperties": + r = &OrganizationCustomProperties{} + case "github:index/organizationCustomRole:OrganizationCustomRole": + r = &OrganizationCustomRole{} + case "github:index/organizationProject:OrganizationProject": + r = &OrganizationProject{} + case "github:index/organizationRepositoryRole:OrganizationRepositoryRole": + r = &OrganizationRepositoryRole{} + case "github:index/organizationRole:OrganizationRole": + r = &OrganizationRole{} + case "github:index/organizationRoleTeam:OrganizationRoleTeam": + r = &OrganizationRoleTeam{} + case "github:index/organizationRoleTeamAssignment:OrganizationRoleTeamAssignment": + r = &OrganizationRoleTeamAssignment{} + case "github:index/organizationRoleUser:OrganizationRoleUser": + r = &OrganizationRoleUser{} + case "github:index/organizationRuleset:OrganizationRuleset": + r = &OrganizationRuleset{} + case "github:index/organizationSecurityManager:OrganizationSecurityManager": + r = &OrganizationSecurityManager{} + case "github:index/organizationSettings:OrganizationSettings": + r = &OrganizationSettings{} + case "github:index/organizationWebhook:OrganizationWebhook": + r = &OrganizationWebhook{} + case "github:index/projectCard:ProjectCard": + r = &ProjectCard{} + case "github:index/projectColumn:ProjectColumn": + r = &ProjectColumn{} + case "github:index/release:Release": + r = &Release{} + case "github:index/repository:Repository": + r = &Repository{} + case "github:index/repositoryAutolinkReference:RepositoryAutolinkReference": + r = &RepositoryAutolinkReference{} + case "github:index/repositoryCollaborator:RepositoryCollaborator": + r = &RepositoryCollaborator{} + case "github:index/repositoryCollaborators:RepositoryCollaborators": + r = &RepositoryCollaborators{} + case "github:index/repositoryCustomProperty:RepositoryCustomProperty": + r = &RepositoryCustomProperty{} + case "github:index/repositoryDependabotSecurityUpdates:RepositoryDependabotSecurityUpdates": + r = &RepositoryDependabotSecurityUpdates{} + case "github:index/repositoryDeployKey:RepositoryDeployKey": + r = &RepositoryDeployKey{} + case "github:index/repositoryDeploymentBranchPolicy:RepositoryDeploymentBranchPolicy": + r = &RepositoryDeploymentBranchPolicy{} + case "github:index/repositoryEnvironment:RepositoryEnvironment": + r = &RepositoryEnvironment{} + case "github:index/repositoryEnvironmentDeploymentPolicy:RepositoryEnvironmentDeploymentPolicy": + r = &RepositoryEnvironmentDeploymentPolicy{} + case "github:index/repositoryFile:RepositoryFile": + r = &RepositoryFile{} + case "github:index/repositoryMilestone:RepositoryMilestone": + r = &RepositoryMilestone{} + case "github:index/repositoryPages:RepositoryPages": + r = &RepositoryPages{} + case "github:index/repositoryProject:RepositoryProject": + r = &RepositoryProject{} + case "github:index/repositoryPullRequest:RepositoryPullRequest": + r = &RepositoryPullRequest{} + case "github:index/repositoryRuleset:RepositoryRuleset": + r = &RepositoryRuleset{} + case "github:index/repositoryTopics:RepositoryTopics": + r = &RepositoryTopics{} + case "github:index/repositoryVulnerabilityAlerts:RepositoryVulnerabilityAlerts": + r = &RepositoryVulnerabilityAlerts{} + case "github:index/repositoryWebhook:RepositoryWebhook": + r = &RepositoryWebhook{} + case "github:index/team:Team": + r = &Team{} + case "github:index/teamMembers:TeamMembers": + r = &TeamMembers{} + case "github:index/teamMembership:TeamMembership": + r = &TeamMembership{} + case "github:index/teamRepository:TeamRepository": + r = &TeamRepository{} + case "github:index/teamSettings:TeamSettings": + r = &TeamSettings{} + case "github:index/teamSyncGroupMapping:TeamSyncGroupMapping": + r = &TeamSyncGroupMapping{} + case "github:index/userGpgKey:UserGpgKey": + r = &UserGpgKey{} + case "github:index/userInvitationAccepter:UserInvitationAccepter": + r = &UserInvitationAccepter{} + case "github:index/userSshKey:UserSshKey": + r = &UserSshKey{} + case "github:index/workflowRepositoryPermissions:WorkflowRepositoryPermissions": + r = &WorkflowRepositoryPermissions{} + default: + return nil, fmt.Errorf("unknown resource type: %s", typ) + } + + err = ctx.RegisterResource(typ, name, nil, r, pulumi.URN_(urn)) + return +} + +type pkg struct { + version semver.Version +} + +func (p *pkg) Version() semver.Version { + return p.version +} + +func (p *pkg) ConstructProvider(ctx *pulumi.Context, name, typ, urn string) (pulumi.ProviderResource, error) { + if typ != "pulumi:providers:github" { + return nil, fmt.Errorf("unknown provider type: %s", typ) + } + + r := &Provider{} + err := ctx.RegisterResource(typ, name, nil, r, pulumi.URN_(urn)) + return r, err +} + +func init() { + version, err := internal.PkgVersion() + if err != nil { + version = semver.Version{Major: 1} + } + pulumi.RegisterResourceModule( + "github", + "index/actionsEnvironmentSecret", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsEnvironmentVariable", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsHostedRunner", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsOrganizationOidcSubjectClaimCustomizationTemplate", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsOrganizationPermissions", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsOrganizationSecret", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsOrganizationSecretRepositories", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsOrganizationSecretRepository", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsOrganizationVariable", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsOrganizationVariableRepositories", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsOrganizationVariableRepository", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsOrganizationWorkflowPermissions", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsRepositoryAccessLevel", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsRepositoryOidcSubjectClaimCustomizationTemplate", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsRepositoryPermissions", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsRunnerGroup", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsSecret", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/actionsVariable", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/appInstallationRepositories", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/appInstallationRepository", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/branch", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/branchDefault", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/branchProtection", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/branchProtectionV3", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/codespacesOrganizationSecret", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/codespacesOrganizationSecretRepositories", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/codespacesSecret", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/codespacesUserSecret", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/dependabotOrganizationSecret", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/dependabotOrganizationSecretRepositories", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/dependabotOrganizationSecretRepository", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/dependabotSecret", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/emuGroupMapping", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/enterpriseActionsPermissions", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/enterpriseActionsRunnerGroup", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/enterpriseActionsWorkflowPermissions", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/enterpriseIpAllowListEntry", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/enterpriseOrganization", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/enterpriseSecurityAnalysisSettings", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/issue", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/issueLabel", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/issueLabels", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/membership", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/organizationBlock", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/organizationCustomProperties", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/organizationCustomRole", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/organizationProject", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/organizationRepositoryRole", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/organizationRole", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/organizationRoleTeam", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/organizationRoleTeamAssignment", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/organizationRoleUser", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/organizationRuleset", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/organizationSecurityManager", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/organizationSettings", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/organizationWebhook", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/projectCard", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/projectColumn", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/release", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repository", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryAutolinkReference", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryCollaborator", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryCollaborators", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryCustomProperty", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryDependabotSecurityUpdates", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryDeployKey", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryDeploymentBranchPolicy", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryEnvironment", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryEnvironmentDeploymentPolicy", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryFile", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryMilestone", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryPages", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryProject", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryPullRequest", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryRuleset", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryTopics", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryVulnerabilityAlerts", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/repositoryWebhook", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/team", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/teamMembers", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/teamMembership", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/teamRepository", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/teamSettings", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/teamSyncGroupMapping", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/userGpgKey", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/userInvitationAccepter", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/userSshKey", + &module{version}, + ) + pulumi.RegisterResourceModule( + "github", + "index/workflowRepositoryPermissions", + &module{version}, + ) + pulumi.RegisterResourcePackage( + "github", + &pkg{version}, + ) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/internal/pulumiUtilities.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/internal/pulumiUtilities.go new file mode 100644 index 000000000..e41a5e6ee --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/internal/pulumiUtilities.go @@ -0,0 +1,184 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package internal + +import ( + "fmt" + "os" + "reflect" + "regexp" + "strconv" + "strings" + + "github.com/blang/semver" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +import ( + "github.com/pulumi/pulumi/sdk/v3/go/pulumi/internals" +) + +type envParser func(v string) interface{} + +func ParseEnvBool(v string) interface{} { + b, err := strconv.ParseBool(v) + if err != nil { + return nil + } + return b +} + +func ParseEnvInt(v string) interface{} { + i, err := strconv.ParseInt(v, 0, 0) + if err != nil { + return nil + } + return int(i) +} + +func ParseEnvFloat(v string) interface{} { + f, err := strconv.ParseFloat(v, 64) + if err != nil { + return nil + } + return f +} + +func ParseEnvStringArray(v string) interface{} { + var result pulumi.StringArray + for _, item := range strings.Split(v, ";") { + result = append(result, pulumi.String(item)) + } + return result +} + +func GetEnvOrDefault(def interface{}, parser envParser, vars ...string) interface{} { + for _, v := range vars { + if value, ok := os.LookupEnv(v); ok { + if parser != nil { + return parser(value) + } + return value + } + } + return def +} + +// PkgVersion uses reflection to determine the version of the current package. +// If a version cannot be determined, v1 will be assumed. The second return +// value is always nil. +func PkgVersion() (semver.Version, error) { + // emptyVersion defaults to v0.0.0 + if !SdkVersion.Equals(semver.Version{}) { + return SdkVersion, nil + } + type sentinal struct{} + pkgPath := reflect.TypeOf(sentinal{}).PkgPath() + re := regexp.MustCompile("^.*/pulumi-github/sdk(/v\\d+)?") + if match := re.FindStringSubmatch(pkgPath); match != nil { + vStr := match[1] + if len(vStr) == 0 { // If the version capture group was empty, default to v1. + return semver.Version{Major: 1}, nil + } + return semver.MustParse(fmt.Sprintf("%s.0.0", vStr[2:])), nil + } + return semver.Version{Major: 1}, nil +} + +// isZero is a null safe check for if a value is it's types zero value. +func IsZero(v interface{}) bool { + if v == nil { + return true + } + return reflect.ValueOf(v).IsZero() +} + +func CallPlain( + ctx *pulumi.Context, + tok string, + args pulumi.Input, + output pulumi.Output, + self pulumi.Resource, + property string, + resultPtr reflect.Value, + errorPtr *error, + opts ...pulumi.InvokeOption, +) { + res, err := callPlainInner(ctx, tok, args, output, self, opts...) + if err != nil { + *errorPtr = err + return + } + + v := reflect.ValueOf(res) + + // extract res.property field if asked to do so + if property != "" { + v = v.FieldByName("Res") + } + + // return by setting the result pointer; this style of returns shortens the generated code without generics + resultPtr.Elem().Set(v) +} + +func callPlainInner( + ctx *pulumi.Context, + tok string, + args pulumi.Input, + output pulumi.Output, + self pulumi.Resource, + opts ...pulumi.InvokeOption, +) (any, error) { + o, err := ctx.Call(tok, args, output, self, opts...) + if err != nil { + return nil, err + } + + outputData, err := internals.UnsafeAwaitOutput(ctx.Context(), o) + if err != nil { + return nil, err + } + + // Ingoring deps silently. They are typically non-empty, r.f() calls include r as a dependency. + known := outputData.Known + value := outputData.Value + secret := outputData.Secret + + problem := "" + if !known { + problem = "an unknown value" + } else if secret { + problem = "a secret value" + } + + if problem != "" { + return nil, fmt.Errorf("Plain resource method %q incorrectly returned %s. "+ + "This is an error in the provider, please report this to the provider developer.", + tok, problem) + } + + return value, nil +} + +// PkgResourceDefaultOpts provides package level defaults to pulumi.OptionResource. +func PkgResourceDefaultOpts(opts []pulumi.ResourceOption) []pulumi.ResourceOption { + defaults := []pulumi.ResourceOption{} + + version := semver.MustParse("6.14.0") + if !version.Equals(semver.Version{}) { + defaults = append(defaults, pulumi.Version(version.String())) + } + return append(defaults, opts...) +} + +// PkgInvokeDefaultOpts provides package level defaults to pulumi.OptionInvoke. +func PkgInvokeDefaultOpts(opts []pulumi.InvokeOption) []pulumi.InvokeOption { + defaults := []pulumi.InvokeOption{} + + version := semver.MustParse("6.14.0") + if !version.Equals(semver.Version{}) { + defaults = append(defaults, pulumi.Version(version.String())) + } + return append(defaults, opts...) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/internal/pulumiVersion.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/internal/pulumiVersion.go new file mode 100644 index 000000000..4ad7cb873 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/internal/pulumiVersion.go @@ -0,0 +1,11 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package internal + +import ( + "github.com/blang/semver" +) + +var SdkVersion semver.Version = semver.Version{} +var pluginDownloadURL string = "" diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/issue.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/issue.go new file mode 100644 index 000000000..555adbb4a --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/issue.go @@ -0,0 +1,437 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Provides a GitHub issue resource. +// +// This resource allows you to create and manage issue within your +// GitHub repository. +// +// ## Example Usage +// +// ```go +// 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 { +// // Create a simple issue +// test, err := github.NewRepository(ctx, "test", &github.RepositoryArgs{ +// Name: pulumi.String("tf-acc-test-%s"), +// AutoInit: pulumi.Bool(true), +// HasIssues: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewIssue(ctx, "test", &github.IssueArgs{ +// Repository: test.Name, +// Title: pulumi.String("My issue title"), +// Body: pulumi.String("The body of my issue"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ### With Milestone And Project Assignment +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi-github/sdk/v6/go/github" +// "github.com/pulumi/pulumi-std/sdk/go/std" +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// // Create an issue with milestone and project assignment +// test, err := github.NewRepository(ctx, "test", &github.RepositoryArgs{ +// Name: pulumi.String("tf-acc-test-%s"), +// AutoInit: pulumi.Bool(true), +// HasIssues: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// testRepositoryMilestone, err := github.NewRepositoryMilestone(ctx, "test", &github.RepositoryMilestoneArgs{ +// Owner: pulumi.String(std.SplitOutput(ctx, std.SplitOutputArgs{ +// Separator: pulumi.String("/"), +// Text: test.FullName, +// }, nil).ApplyT(func(invoke std.SplitResult) (*string, error) { +// val := invoke.Result[0] +// return &val, nil +// }).(pulumi.StringPtrOutput)), +// Repository: test.Name, +// Title: pulumi.String("v1.0.0"), +// Description: pulumi.String("General Availability"), +// DueDate: pulumi.String("2022-11-22"), +// State: pulumi.String("open"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewIssue(ctx, "test", &github.IssueArgs{ +// Repository: test.Name, +// Title: pulumi.String("My issue"), +// Body: pulumi.String("My issue body"), +// Labels: pulumi.StringArray{ +// pulumi.String("bug"), +// pulumi.String("documentation"), +// }, +// Assignees: pulumi.StringArray{ +// pulumi.String("bob-github"), +// }, +// MilestoneNumber: testRepositoryMilestone.Number, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Issues can be imported using an ID made up of `repository:number`, e.g. +// +// ```sh +// $ pulumi import github:index/issue:Issue issue_15 myrepo:15 +// ``` +type Issue struct { + pulumi.CustomResourceState + + // List of Logins to assign the to the issue + Assignees pulumi.StringArrayOutput `pulumi:"assignees"` + // Body of the issue + Body pulumi.StringPtrOutput `pulumi:"body"` + Etag pulumi.StringOutput `pulumi:"etag"` + // (Computed) - The issue id + IssueId pulumi.IntOutput `pulumi:"issueId"` + // List of labels to attach to the issue + Labels pulumi.StringArrayOutput `pulumi:"labels"` + // Milestone number to assign to the issue + MilestoneNumber pulumi.IntPtrOutput `pulumi:"milestoneNumber"` + // (Computed) - The issue number + Number pulumi.IntOutput `pulumi:"number"` + // The GitHub repository name + Repository pulumi.StringOutput `pulumi:"repository"` + // Title of the issue + Title pulumi.StringOutput `pulumi:"title"` +} + +// NewIssue registers a new resource with the given unique name, arguments, and options. +func NewIssue(ctx *pulumi.Context, + name string, args *IssueArgs, opts ...pulumi.ResourceOption) (*Issue, 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.Title == nil { + return nil, errors.New("invalid value for required argument 'Title'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource Issue + err := ctx.RegisterResource("github:index/issue:Issue", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetIssue gets an existing Issue 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 GetIssue(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *IssueState, opts ...pulumi.ResourceOption) (*Issue, error) { + var resource Issue + err := ctx.ReadResource("github:index/issue:Issue", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering Issue resources. +type issueState struct { + // List of Logins to assign the to the issue + Assignees []string `pulumi:"assignees"` + // Body of the issue + Body *string `pulumi:"body"` + Etag *string `pulumi:"etag"` + // (Computed) - The issue id + IssueId *int `pulumi:"issueId"` + // List of labels to attach to the issue + Labels []string `pulumi:"labels"` + // Milestone number to assign to the issue + MilestoneNumber *int `pulumi:"milestoneNumber"` + // (Computed) - The issue number + Number *int `pulumi:"number"` + // The GitHub repository name + Repository *string `pulumi:"repository"` + // Title of the issue + Title *string `pulumi:"title"` +} + +type IssueState struct { + // List of Logins to assign the to the issue + Assignees pulumi.StringArrayInput + // Body of the issue + Body pulumi.StringPtrInput + Etag pulumi.StringPtrInput + // (Computed) - The issue id + IssueId pulumi.IntPtrInput + // List of labels to attach to the issue + Labels pulumi.StringArrayInput + // Milestone number to assign to the issue + MilestoneNumber pulumi.IntPtrInput + // (Computed) - The issue number + Number pulumi.IntPtrInput + // The GitHub repository name + Repository pulumi.StringPtrInput + // Title of the issue + Title pulumi.StringPtrInput +} + +func (IssueState) ElementType() reflect.Type { + return reflect.TypeOf((*issueState)(nil)).Elem() +} + +type issueArgs struct { + // List of Logins to assign the to the issue + Assignees []string `pulumi:"assignees"` + // Body of the issue + Body *string `pulumi:"body"` + // List of labels to attach to the issue + Labels []string `pulumi:"labels"` + // Milestone number to assign to the issue + MilestoneNumber *int `pulumi:"milestoneNumber"` + // The GitHub repository name + Repository string `pulumi:"repository"` + // Title of the issue + Title string `pulumi:"title"` +} + +// The set of arguments for constructing a Issue resource. +type IssueArgs struct { + // List of Logins to assign the to the issue + Assignees pulumi.StringArrayInput + // Body of the issue + Body pulumi.StringPtrInput + // List of labels to attach to the issue + Labels pulumi.StringArrayInput + // Milestone number to assign to the issue + MilestoneNumber pulumi.IntPtrInput + // The GitHub repository name + Repository pulumi.StringInput + // Title of the issue + Title pulumi.StringInput +} + +func (IssueArgs) ElementType() reflect.Type { + return reflect.TypeOf((*issueArgs)(nil)).Elem() +} + +type IssueInput interface { + pulumi.Input + + ToIssueOutput() IssueOutput + ToIssueOutputWithContext(ctx context.Context) IssueOutput +} + +func (*Issue) ElementType() reflect.Type { + return reflect.TypeOf((**Issue)(nil)).Elem() +} + +func (i *Issue) ToIssueOutput() IssueOutput { + return i.ToIssueOutputWithContext(context.Background()) +} + +func (i *Issue) ToIssueOutputWithContext(ctx context.Context) IssueOutput { + return pulumi.ToOutputWithContext(ctx, i).(IssueOutput) +} + +// IssueArrayInput is an input type that accepts IssueArray and IssueArrayOutput values. +// You can construct a concrete instance of `IssueArrayInput` via: +// +// IssueArray{ IssueArgs{...} } +type IssueArrayInput interface { + pulumi.Input + + ToIssueArrayOutput() IssueArrayOutput + ToIssueArrayOutputWithContext(context.Context) IssueArrayOutput +} + +type IssueArray []IssueInput + +func (IssueArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Issue)(nil)).Elem() +} + +func (i IssueArray) ToIssueArrayOutput() IssueArrayOutput { + return i.ToIssueArrayOutputWithContext(context.Background()) +} + +func (i IssueArray) ToIssueArrayOutputWithContext(ctx context.Context) IssueArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(IssueArrayOutput) +} + +// IssueMapInput is an input type that accepts IssueMap and IssueMapOutput values. +// You can construct a concrete instance of `IssueMapInput` via: +// +// IssueMap{ "key": IssueArgs{...} } +type IssueMapInput interface { + pulumi.Input + + ToIssueMapOutput() IssueMapOutput + ToIssueMapOutputWithContext(context.Context) IssueMapOutput +} + +type IssueMap map[string]IssueInput + +func (IssueMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Issue)(nil)).Elem() +} + +func (i IssueMap) ToIssueMapOutput() IssueMapOutput { + return i.ToIssueMapOutputWithContext(context.Background()) +} + +func (i IssueMap) ToIssueMapOutputWithContext(ctx context.Context) IssueMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(IssueMapOutput) +} + +type IssueOutput struct{ *pulumi.OutputState } + +func (IssueOutput) ElementType() reflect.Type { + return reflect.TypeOf((**Issue)(nil)).Elem() +} + +func (o IssueOutput) ToIssueOutput() IssueOutput { + return o +} + +func (o IssueOutput) ToIssueOutputWithContext(ctx context.Context) IssueOutput { + return o +} + +// List of Logins to assign the to the issue +func (o IssueOutput) Assignees() pulumi.StringArrayOutput { + return o.ApplyT(func(v *Issue) pulumi.StringArrayOutput { return v.Assignees }).(pulumi.StringArrayOutput) +} + +// Body of the issue +func (o IssueOutput) Body() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Issue) pulumi.StringPtrOutput { return v.Body }).(pulumi.StringPtrOutput) +} + +func (o IssueOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *Issue) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// (Computed) - The issue id +func (o IssueOutput) IssueId() pulumi.IntOutput { + return o.ApplyT(func(v *Issue) pulumi.IntOutput { return v.IssueId }).(pulumi.IntOutput) +} + +// List of labels to attach to the issue +func (o IssueOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v *Issue) pulumi.StringArrayOutput { return v.Labels }).(pulumi.StringArrayOutput) +} + +// Milestone number to assign to the issue +func (o IssueOutput) MilestoneNumber() pulumi.IntPtrOutput { + return o.ApplyT(func(v *Issue) pulumi.IntPtrOutput { return v.MilestoneNumber }).(pulumi.IntPtrOutput) +} + +// (Computed) - The issue number +func (o IssueOutput) Number() pulumi.IntOutput { + return o.ApplyT(func(v *Issue) pulumi.IntOutput { return v.Number }).(pulumi.IntOutput) +} + +// The GitHub repository name +func (o IssueOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *Issue) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// Title of the issue +func (o IssueOutput) Title() pulumi.StringOutput { + return o.ApplyT(func(v *Issue) pulumi.StringOutput { return v.Title }).(pulumi.StringOutput) +} + +type IssueArrayOutput struct{ *pulumi.OutputState } + +func (IssueArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Issue)(nil)).Elem() +} + +func (o IssueArrayOutput) ToIssueArrayOutput() IssueArrayOutput { + return o +} + +func (o IssueArrayOutput) ToIssueArrayOutputWithContext(ctx context.Context) IssueArrayOutput { + return o +} + +func (o IssueArrayOutput) Index(i pulumi.IntInput) IssueOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Issue { + return vs[0].([]*Issue)[vs[1].(int)] + }).(IssueOutput) +} + +type IssueMapOutput struct{ *pulumi.OutputState } + +func (IssueMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Issue)(nil)).Elem() +} + +func (o IssueMapOutput) ToIssueMapOutput() IssueMapOutput { + return o +} + +func (o IssueMapOutput) ToIssueMapOutputWithContext(ctx context.Context) IssueMapOutput { + return o +} + +func (o IssueMapOutput) MapIndex(k pulumi.StringInput) IssueOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Issue { + return vs[0].(map[string]*Issue)[vs[1].(string)] + }).(IssueOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*IssueInput)(nil)).Elem(), &Issue{}) + pulumi.RegisterInputType(reflect.TypeOf((*IssueArrayInput)(nil)).Elem(), IssueArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*IssueMapInput)(nil)).Elem(), IssueMap{}) + pulumi.RegisterOutputType(IssueOutput{}) + pulumi.RegisterOutputType(IssueArrayOutput{}) + pulumi.RegisterOutputType(IssueMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/issueLabel.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/issueLabel.go new file mode 100644 index 000000000..7b36b7ff4 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/issueLabel.go @@ -0,0 +1,337 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Provides a GitHub issue label resource. +// +// This resource allows you to create and manage issue labels within your +// GitHub organization. +// +// Issue labels are keyed off of their "name", so pre-existing issue labels result +// in a 422 HTTP error if they exist outside of Pulumi. Normally this would not +// be an issue, except new repositories are created with a "default" set of labels, +// and those labels easily conflict with custom ones. +// +// This resource will first check if the label exists, and then issue an update, +// otherwise it will create. +// +// > **Note:** When a repository is archived, Pulumi will skip deletion of issue labels to avoid API errors, as archived repositories are read-only. The labels will be removed from Pulumi state without attempting to delete them from GitHub. +// +// ## Example Usage +// +// ```go +// 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 { +// // Create a new, red colored label +// _, err := github.NewIssueLabel(ctx, "test_repo", &github.IssueLabelArgs{ +// Repository: pulumi.String("test-repo"), +// Name: pulumi.String("Urgent"), +// Color: pulumi.String("FF0000"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Issue Labels can be imported using an ID made up of `repository:name`, e.g. +// +// ```sh +// $ pulumi import github:index/issueLabel:IssueLabel panic_label terraform:panic +// ``` +type IssueLabel struct { + pulumi.CustomResourceState + + // A 6 character hex code, **without the leading #**, identifying the color of the label. + Color pulumi.StringOutput `pulumi:"color"` + // A short description of the label. + Description pulumi.StringPtrOutput `pulumi:"description"` + Etag pulumi.StringOutput `pulumi:"etag"` + // The name of the label. + Name pulumi.StringOutput `pulumi:"name"` + // The GitHub repository + Repository pulumi.StringOutput `pulumi:"repository"` + // The URL to the issue label + Url pulumi.StringOutput `pulumi:"url"` +} + +// NewIssueLabel registers a new resource with the given unique name, arguments, and options. +func NewIssueLabel(ctx *pulumi.Context, + name string, args *IssueLabelArgs, opts ...pulumi.ResourceOption) (*IssueLabel, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Color == nil { + return nil, errors.New("invalid value for required argument 'Color'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource IssueLabel + err := ctx.RegisterResource("github:index/issueLabel:IssueLabel", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetIssueLabel gets an existing IssueLabel 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 GetIssueLabel(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *IssueLabelState, opts ...pulumi.ResourceOption) (*IssueLabel, error) { + var resource IssueLabel + err := ctx.ReadResource("github:index/issueLabel:IssueLabel", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering IssueLabel resources. +type issueLabelState struct { + // A 6 character hex code, **without the leading #**, identifying the color of the label. + Color *string `pulumi:"color"` + // A short description of the label. + Description *string `pulumi:"description"` + Etag *string `pulumi:"etag"` + // The name of the label. + Name *string `pulumi:"name"` + // The GitHub repository + Repository *string `pulumi:"repository"` + // The URL to the issue label + Url *string `pulumi:"url"` +} + +type IssueLabelState struct { + // A 6 character hex code, **without the leading #**, identifying the color of the label. + Color pulumi.StringPtrInput + // A short description of the label. + Description pulumi.StringPtrInput + Etag pulumi.StringPtrInput + // The name of the label. + Name pulumi.StringPtrInput + // The GitHub repository + Repository pulumi.StringPtrInput + // The URL to the issue label + Url pulumi.StringPtrInput +} + +func (IssueLabelState) ElementType() reflect.Type { + return reflect.TypeOf((*issueLabelState)(nil)).Elem() +} + +type issueLabelArgs struct { + // A 6 character hex code, **without the leading #**, identifying the color of the label. + Color string `pulumi:"color"` + // A short description of the label. + Description *string `pulumi:"description"` + Etag *string `pulumi:"etag"` + // The name of the label. + Name *string `pulumi:"name"` + // The GitHub repository + Repository string `pulumi:"repository"` +} + +// The set of arguments for constructing a IssueLabel resource. +type IssueLabelArgs struct { + // A 6 character hex code, **without the leading #**, identifying the color of the label. + Color pulumi.StringInput + // A short description of the label. + Description pulumi.StringPtrInput + Etag pulumi.StringPtrInput + // The name of the label. + Name pulumi.StringPtrInput + // The GitHub repository + Repository pulumi.StringInput +} + +func (IssueLabelArgs) ElementType() reflect.Type { + return reflect.TypeOf((*issueLabelArgs)(nil)).Elem() +} + +type IssueLabelInput interface { + pulumi.Input + + ToIssueLabelOutput() IssueLabelOutput + ToIssueLabelOutputWithContext(ctx context.Context) IssueLabelOutput +} + +func (*IssueLabel) ElementType() reflect.Type { + return reflect.TypeOf((**IssueLabel)(nil)).Elem() +} + +func (i *IssueLabel) ToIssueLabelOutput() IssueLabelOutput { + return i.ToIssueLabelOutputWithContext(context.Background()) +} + +func (i *IssueLabel) ToIssueLabelOutputWithContext(ctx context.Context) IssueLabelOutput { + return pulumi.ToOutputWithContext(ctx, i).(IssueLabelOutput) +} + +// IssueLabelArrayInput is an input type that accepts IssueLabelArray and IssueLabelArrayOutput values. +// You can construct a concrete instance of `IssueLabelArrayInput` via: +// +// IssueLabelArray{ IssueLabelArgs{...} } +type IssueLabelArrayInput interface { + pulumi.Input + + ToIssueLabelArrayOutput() IssueLabelArrayOutput + ToIssueLabelArrayOutputWithContext(context.Context) IssueLabelArrayOutput +} + +type IssueLabelArray []IssueLabelInput + +func (IssueLabelArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*IssueLabel)(nil)).Elem() +} + +func (i IssueLabelArray) ToIssueLabelArrayOutput() IssueLabelArrayOutput { + return i.ToIssueLabelArrayOutputWithContext(context.Background()) +} + +func (i IssueLabelArray) ToIssueLabelArrayOutputWithContext(ctx context.Context) IssueLabelArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(IssueLabelArrayOutput) +} + +// IssueLabelMapInput is an input type that accepts IssueLabelMap and IssueLabelMapOutput values. +// You can construct a concrete instance of `IssueLabelMapInput` via: +// +// IssueLabelMap{ "key": IssueLabelArgs{...} } +type IssueLabelMapInput interface { + pulumi.Input + + ToIssueLabelMapOutput() IssueLabelMapOutput + ToIssueLabelMapOutputWithContext(context.Context) IssueLabelMapOutput +} + +type IssueLabelMap map[string]IssueLabelInput + +func (IssueLabelMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*IssueLabel)(nil)).Elem() +} + +func (i IssueLabelMap) ToIssueLabelMapOutput() IssueLabelMapOutput { + return i.ToIssueLabelMapOutputWithContext(context.Background()) +} + +func (i IssueLabelMap) ToIssueLabelMapOutputWithContext(ctx context.Context) IssueLabelMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(IssueLabelMapOutput) +} + +type IssueLabelOutput struct{ *pulumi.OutputState } + +func (IssueLabelOutput) ElementType() reflect.Type { + return reflect.TypeOf((**IssueLabel)(nil)).Elem() +} + +func (o IssueLabelOutput) ToIssueLabelOutput() IssueLabelOutput { + return o +} + +func (o IssueLabelOutput) ToIssueLabelOutputWithContext(ctx context.Context) IssueLabelOutput { + return o +} + +// A 6 character hex code, **without the leading #**, identifying the color of the label. +func (o IssueLabelOutput) Color() pulumi.StringOutput { + return o.ApplyT(func(v *IssueLabel) pulumi.StringOutput { return v.Color }).(pulumi.StringOutput) +} + +// A short description of the label. +func (o IssueLabelOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *IssueLabel) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) +} + +func (o IssueLabelOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *IssueLabel) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// The name of the label. +func (o IssueLabelOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *IssueLabel) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// The GitHub repository +func (o IssueLabelOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *IssueLabel) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// The URL to the issue label +func (o IssueLabelOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v *IssueLabel) pulumi.StringOutput { return v.Url }).(pulumi.StringOutput) +} + +type IssueLabelArrayOutput struct{ *pulumi.OutputState } + +func (IssueLabelArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*IssueLabel)(nil)).Elem() +} + +func (o IssueLabelArrayOutput) ToIssueLabelArrayOutput() IssueLabelArrayOutput { + return o +} + +func (o IssueLabelArrayOutput) ToIssueLabelArrayOutputWithContext(ctx context.Context) IssueLabelArrayOutput { + return o +} + +func (o IssueLabelArrayOutput) Index(i pulumi.IntInput) IssueLabelOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IssueLabel { + return vs[0].([]*IssueLabel)[vs[1].(int)] + }).(IssueLabelOutput) +} + +type IssueLabelMapOutput struct{ *pulumi.OutputState } + +func (IssueLabelMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*IssueLabel)(nil)).Elem() +} + +func (o IssueLabelMapOutput) ToIssueLabelMapOutput() IssueLabelMapOutput { + return o +} + +func (o IssueLabelMapOutput) ToIssueLabelMapOutputWithContext(ctx context.Context) IssueLabelMapOutput { + return o +} + +func (o IssueLabelMapOutput) MapIndex(k pulumi.StringInput) IssueLabelOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IssueLabel { + return vs[0].(map[string]*IssueLabel)[vs[1].(string)] + }).(IssueLabelOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*IssueLabelInput)(nil)).Elem(), &IssueLabel{}) + pulumi.RegisterInputType(reflect.TypeOf((*IssueLabelArrayInput)(nil)).Elem(), IssueLabelArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*IssueLabelMapInput)(nil)).Elem(), IssueLabelMap{}) + pulumi.RegisterOutputType(IssueLabelOutput{}) + pulumi.RegisterOutputType(IssueLabelArrayOutput{}) + pulumi.RegisterOutputType(IssueLabelMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/issueLabels.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/issueLabels.go new file mode 100644 index 000000000..a9679d8b5 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/issueLabels.go @@ -0,0 +1,290 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Provides GitHub issue labels resource. +// +// This resource allows you to create and manage issue labels within your +// GitHub organization. +// +// > Note: IssueLabels cannot be used in conjunction with IssueLabel or they will fight over what your policy should be. +// +// This resource is authoritative. For adding a label to a repo in a non-authoritative manner, use IssueLabel instead. +// +// If you change the case of a label's name, its' color, or description, this resource will edit the existing label to match the new values. However, if you change the name of a label, this resource will create a new label with the new name and delete the old label. Beware that this will remove the label from any issues it was previously attached to. +// +// > **Note:** When a repository is archived, Terraform will skip deletion of issue labels to avoid API errors, as archived repositories are read-only. The labels will be removed from Terraform state without attempting to delete them from GitHub. +// +// ## Example Usage +// +// ```go +// 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 { +// // Create a new, red colored label +// _, err := github.NewIssueLabels(ctx, "test_repo", &github.IssueLabelsArgs{ +// Repository: pulumi.String("test-repo"), +// Labels: github.IssueLabelsLabelArray{ +// &github.IssueLabelsLabelArgs{ +// Name: pulumi.String("Urgent"), +// Color: pulumi.String("FF0000"), +// }, +// &github.IssueLabelsLabelArgs{ +// Name: pulumi.String("Critical"), +// Color: pulumi.String("FF0000"), +// }, +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Issue Labels can be imported using the repository `name`, e.g. +// +// ```sh +// $ pulumi import github:index/issueLabels:IssueLabels test_repo test_repo +// ``` +type IssueLabels struct { + pulumi.CustomResourceState + + // List of labels + Labels IssueLabelsLabelArrayOutput `pulumi:"labels"` + // The GitHub repository + Repository pulumi.StringOutput `pulumi:"repository"` +} + +// NewIssueLabels registers a new resource with the given unique name, arguments, and options. +func NewIssueLabels(ctx *pulumi.Context, + name string, args *IssueLabelsArgs, opts ...pulumi.ResourceOption) (*IssueLabels, 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'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource IssueLabels + err := ctx.RegisterResource("github:index/issueLabels:IssueLabels", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetIssueLabels gets an existing IssueLabels 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 GetIssueLabels(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *IssueLabelsState, opts ...pulumi.ResourceOption) (*IssueLabels, error) { + var resource IssueLabels + err := ctx.ReadResource("github:index/issueLabels:IssueLabels", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering IssueLabels resources. +type issueLabelsState struct { + // List of labels + Labels []IssueLabelsLabel `pulumi:"labels"` + // The GitHub repository + Repository *string `pulumi:"repository"` +} + +type IssueLabelsState struct { + // List of labels + Labels IssueLabelsLabelArrayInput + // The GitHub repository + Repository pulumi.StringPtrInput +} + +func (IssueLabelsState) ElementType() reflect.Type { + return reflect.TypeOf((*issueLabelsState)(nil)).Elem() +} + +type issueLabelsArgs struct { + // List of labels + Labels []IssueLabelsLabel `pulumi:"labels"` + // The GitHub repository + Repository string `pulumi:"repository"` +} + +// The set of arguments for constructing a IssueLabels resource. +type IssueLabelsArgs struct { + // List of labels + Labels IssueLabelsLabelArrayInput + // The GitHub repository + Repository pulumi.StringInput +} + +func (IssueLabelsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*issueLabelsArgs)(nil)).Elem() +} + +type IssueLabelsInput interface { + pulumi.Input + + ToIssueLabelsOutput() IssueLabelsOutput + ToIssueLabelsOutputWithContext(ctx context.Context) IssueLabelsOutput +} + +func (*IssueLabels) ElementType() reflect.Type { + return reflect.TypeOf((**IssueLabels)(nil)).Elem() +} + +func (i *IssueLabels) ToIssueLabelsOutput() IssueLabelsOutput { + return i.ToIssueLabelsOutputWithContext(context.Background()) +} + +func (i *IssueLabels) ToIssueLabelsOutputWithContext(ctx context.Context) IssueLabelsOutput { + return pulumi.ToOutputWithContext(ctx, i).(IssueLabelsOutput) +} + +// IssueLabelsArrayInput is an input type that accepts IssueLabelsArray and IssueLabelsArrayOutput values. +// You can construct a concrete instance of `IssueLabelsArrayInput` via: +// +// IssueLabelsArray{ IssueLabelsArgs{...} } +type IssueLabelsArrayInput interface { + pulumi.Input + + ToIssueLabelsArrayOutput() IssueLabelsArrayOutput + ToIssueLabelsArrayOutputWithContext(context.Context) IssueLabelsArrayOutput +} + +type IssueLabelsArray []IssueLabelsInput + +func (IssueLabelsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*IssueLabels)(nil)).Elem() +} + +func (i IssueLabelsArray) ToIssueLabelsArrayOutput() IssueLabelsArrayOutput { + return i.ToIssueLabelsArrayOutputWithContext(context.Background()) +} + +func (i IssueLabelsArray) ToIssueLabelsArrayOutputWithContext(ctx context.Context) IssueLabelsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(IssueLabelsArrayOutput) +} + +// IssueLabelsMapInput is an input type that accepts IssueLabelsMap and IssueLabelsMapOutput values. +// You can construct a concrete instance of `IssueLabelsMapInput` via: +// +// IssueLabelsMap{ "key": IssueLabelsArgs{...} } +type IssueLabelsMapInput interface { + pulumi.Input + + ToIssueLabelsMapOutput() IssueLabelsMapOutput + ToIssueLabelsMapOutputWithContext(context.Context) IssueLabelsMapOutput +} + +type IssueLabelsMap map[string]IssueLabelsInput + +func (IssueLabelsMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*IssueLabels)(nil)).Elem() +} + +func (i IssueLabelsMap) ToIssueLabelsMapOutput() IssueLabelsMapOutput { + return i.ToIssueLabelsMapOutputWithContext(context.Background()) +} + +func (i IssueLabelsMap) ToIssueLabelsMapOutputWithContext(ctx context.Context) IssueLabelsMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(IssueLabelsMapOutput) +} + +type IssueLabelsOutput struct{ *pulumi.OutputState } + +func (IssueLabelsOutput) ElementType() reflect.Type { + return reflect.TypeOf((**IssueLabels)(nil)).Elem() +} + +func (o IssueLabelsOutput) ToIssueLabelsOutput() IssueLabelsOutput { + return o +} + +func (o IssueLabelsOutput) ToIssueLabelsOutputWithContext(ctx context.Context) IssueLabelsOutput { + return o +} + +// List of labels +func (o IssueLabelsOutput) Labels() IssueLabelsLabelArrayOutput { + return o.ApplyT(func(v *IssueLabels) IssueLabelsLabelArrayOutput { return v.Labels }).(IssueLabelsLabelArrayOutput) +} + +// The GitHub repository +func (o IssueLabelsOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *IssueLabels) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +type IssueLabelsArrayOutput struct{ *pulumi.OutputState } + +func (IssueLabelsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*IssueLabels)(nil)).Elem() +} + +func (o IssueLabelsArrayOutput) ToIssueLabelsArrayOutput() IssueLabelsArrayOutput { + return o +} + +func (o IssueLabelsArrayOutput) ToIssueLabelsArrayOutputWithContext(ctx context.Context) IssueLabelsArrayOutput { + return o +} + +func (o IssueLabelsArrayOutput) Index(i pulumi.IntInput) IssueLabelsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *IssueLabels { + return vs[0].([]*IssueLabels)[vs[1].(int)] + }).(IssueLabelsOutput) +} + +type IssueLabelsMapOutput struct{ *pulumi.OutputState } + +func (IssueLabelsMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*IssueLabels)(nil)).Elem() +} + +func (o IssueLabelsMapOutput) ToIssueLabelsMapOutput() IssueLabelsMapOutput { + return o +} + +func (o IssueLabelsMapOutput) ToIssueLabelsMapOutputWithContext(ctx context.Context) IssueLabelsMapOutput { + return o +} + +func (o IssueLabelsMapOutput) MapIndex(k pulumi.StringInput) IssueLabelsOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *IssueLabels { + return vs[0].(map[string]*IssueLabels)[vs[1].(string)] + }).(IssueLabelsOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*IssueLabelsInput)(nil)).Elem(), &IssueLabels{}) + pulumi.RegisterInputType(reflect.TypeOf((*IssueLabelsArrayInput)(nil)).Elem(), IssueLabelsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*IssueLabelsMapInput)(nil)).Elem(), IssueLabelsMap{}) + pulumi.RegisterOutputType(IssueLabelsOutput{}) + pulumi.RegisterOutputType(IssueLabelsArrayOutput{}) + pulumi.RegisterOutputType(IssueLabelsMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/membership.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/membership.go new file mode 100644 index 000000000..61b1b2e37 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/membership.go @@ -0,0 +1,326 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Provides a GitHub membership resource. +// +// This resource allows you to add/remove users from your organization. When applied, +// an invitation will be sent to the user to become part of the organization. When +// destroyed, either the invitation will be cancelled or the user will be removed. +// +// ## Example Usage +// +// ```go +// 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 +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Membership can be imported using an ID made up of `organization:username`, e.g. +// +// ```sh +// $ pulumi import github:index/membership:Membership member hashicorp:someuser +// ``` +type Membership struct { + pulumi.CustomResourceState + + // Defaults to `false`. If set to true, + // when this resource is destroyed, the member will not be removed + // from the organization. Instead, the member's role will be + // downgraded to 'member'. + DowngradeOnDestroy pulumi.BoolPtrOutput `pulumi:"downgradeOnDestroy"` + Etag pulumi.StringOutput `pulumi:"etag"` + // The role of the user within the organization. + // Must be one of `member` or `admin`. Defaults to `member`. + // `admin` role represents the `owner` role available via GitHub UI. + Role pulumi.StringPtrOutput `pulumi:"role"` + // The user to add to the organization. + Username pulumi.StringOutput `pulumi:"username"` +} + +// NewMembership registers a new resource with the given unique name, arguments, and options. +func NewMembership(ctx *pulumi.Context, + name string, args *MembershipArgs, opts ...pulumi.ResourceOption) (*Membership, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Username == nil { + return nil, errors.New("invalid value for required argument 'Username'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource Membership + err := ctx.RegisterResource("github:index/membership:Membership", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetMembership gets an existing Membership 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 GetMembership(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *MembershipState, opts ...pulumi.ResourceOption) (*Membership, error) { + var resource Membership + err := ctx.ReadResource("github:index/membership:Membership", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering Membership resources. +type membershipState struct { + // Defaults to `false`. If set to true, + // when this resource is destroyed, the member will not be removed + // from the organization. Instead, the member's role will be + // downgraded to 'member'. + DowngradeOnDestroy *bool `pulumi:"downgradeOnDestroy"` + Etag *string `pulumi:"etag"` + // The role of the user within the organization. + // Must be one of `member` or `admin`. Defaults to `member`. + // `admin` role represents the `owner` role available via GitHub UI. + Role *string `pulumi:"role"` + // The user to add to the organization. + Username *string `pulumi:"username"` +} + +type MembershipState struct { + // Defaults to `false`. If set to true, + // when this resource is destroyed, the member will not be removed + // from the organization. Instead, the member's role will be + // downgraded to 'member'. + DowngradeOnDestroy pulumi.BoolPtrInput + Etag pulumi.StringPtrInput + // The role of the user within the organization. + // Must be one of `member` or `admin`. Defaults to `member`. + // `admin` role represents the `owner` role available via GitHub UI. + Role pulumi.StringPtrInput + // The user to add to the organization. + Username pulumi.StringPtrInput +} + +func (MembershipState) ElementType() reflect.Type { + return reflect.TypeOf((*membershipState)(nil)).Elem() +} + +type membershipArgs struct { + // Defaults to `false`. If set to true, + // when this resource is destroyed, the member will not be removed + // from the organization. Instead, the member's role will be + // downgraded to 'member'. + DowngradeOnDestroy *bool `pulumi:"downgradeOnDestroy"` + // The role of the user within the organization. + // Must be one of `member` or `admin`. Defaults to `member`. + // `admin` role represents the `owner` role available via GitHub UI. + Role *string `pulumi:"role"` + // The user to add to the organization. + Username string `pulumi:"username"` +} + +// The set of arguments for constructing a Membership resource. +type MembershipArgs struct { + // Defaults to `false`. If set to true, + // when this resource is destroyed, the member will not be removed + // from the organization. Instead, the member's role will be + // downgraded to 'member'. + DowngradeOnDestroy pulumi.BoolPtrInput + // The role of the user within the organization. + // Must be one of `member` or `admin`. Defaults to `member`. + // `admin` role represents the `owner` role available via GitHub UI. + Role pulumi.StringPtrInput + // The user to add to the organization. + Username pulumi.StringInput +} + +func (MembershipArgs) ElementType() reflect.Type { + return reflect.TypeOf((*membershipArgs)(nil)).Elem() +} + +type MembershipInput interface { + pulumi.Input + + ToMembershipOutput() MembershipOutput + ToMembershipOutputWithContext(ctx context.Context) MembershipOutput +} + +func (*Membership) ElementType() reflect.Type { + return reflect.TypeOf((**Membership)(nil)).Elem() +} + +func (i *Membership) ToMembershipOutput() MembershipOutput { + return i.ToMembershipOutputWithContext(context.Background()) +} + +func (i *Membership) ToMembershipOutputWithContext(ctx context.Context) MembershipOutput { + return pulumi.ToOutputWithContext(ctx, i).(MembershipOutput) +} + +// MembershipArrayInput is an input type that accepts MembershipArray and MembershipArrayOutput values. +// You can construct a concrete instance of `MembershipArrayInput` via: +// +// MembershipArray{ MembershipArgs{...} } +type MembershipArrayInput interface { + pulumi.Input + + ToMembershipArrayOutput() MembershipArrayOutput + ToMembershipArrayOutputWithContext(context.Context) MembershipArrayOutput +} + +type MembershipArray []MembershipInput + +func (MembershipArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Membership)(nil)).Elem() +} + +func (i MembershipArray) ToMembershipArrayOutput() MembershipArrayOutput { + return i.ToMembershipArrayOutputWithContext(context.Background()) +} + +func (i MembershipArray) ToMembershipArrayOutputWithContext(ctx context.Context) MembershipArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(MembershipArrayOutput) +} + +// MembershipMapInput is an input type that accepts MembershipMap and MembershipMapOutput values. +// You can construct a concrete instance of `MembershipMapInput` via: +// +// MembershipMap{ "key": MembershipArgs{...} } +type MembershipMapInput interface { + pulumi.Input + + ToMembershipMapOutput() MembershipMapOutput + ToMembershipMapOutputWithContext(context.Context) MembershipMapOutput +} + +type MembershipMap map[string]MembershipInput + +func (MembershipMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Membership)(nil)).Elem() +} + +func (i MembershipMap) ToMembershipMapOutput() MembershipMapOutput { + return i.ToMembershipMapOutputWithContext(context.Background()) +} + +func (i MembershipMap) ToMembershipMapOutputWithContext(ctx context.Context) MembershipMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(MembershipMapOutput) +} + +type MembershipOutput struct{ *pulumi.OutputState } + +func (MembershipOutput) ElementType() reflect.Type { + return reflect.TypeOf((**Membership)(nil)).Elem() +} + +func (o MembershipOutput) ToMembershipOutput() MembershipOutput { + return o +} + +func (o MembershipOutput) ToMembershipOutputWithContext(ctx context.Context) MembershipOutput { + return o +} + +// Defaults to `false`. If set to true, +// when this resource is destroyed, the member will not be removed +// from the organization. Instead, the member's role will be +// downgraded to 'member'. +func (o MembershipOutput) DowngradeOnDestroy() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Membership) pulumi.BoolPtrOutput { return v.DowngradeOnDestroy }).(pulumi.BoolPtrOutput) +} + +func (o MembershipOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *Membership) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// The role of the user within the organization. +// Must be one of `member` or `admin`. Defaults to `member`. +// `admin` role represents the `owner` role available via GitHub UI. +func (o MembershipOutput) Role() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Membership) pulumi.StringPtrOutput { return v.Role }).(pulumi.StringPtrOutput) +} + +// The user to add to the organization. +func (o MembershipOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v *Membership) pulumi.StringOutput { return v.Username }).(pulumi.StringOutput) +} + +type MembershipArrayOutput struct{ *pulumi.OutputState } + +func (MembershipArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Membership)(nil)).Elem() +} + +func (o MembershipArrayOutput) ToMembershipArrayOutput() MembershipArrayOutput { + return o +} + +func (o MembershipArrayOutput) ToMembershipArrayOutputWithContext(ctx context.Context) MembershipArrayOutput { + return o +} + +func (o MembershipArrayOutput) Index(i pulumi.IntInput) MembershipOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Membership { + return vs[0].([]*Membership)[vs[1].(int)] + }).(MembershipOutput) +} + +type MembershipMapOutput struct{ *pulumi.OutputState } + +func (MembershipMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Membership)(nil)).Elem() +} + +func (o MembershipMapOutput) ToMembershipMapOutput() MembershipMapOutput { + return o +} + +func (o MembershipMapOutput) ToMembershipMapOutputWithContext(ctx context.Context) MembershipMapOutput { + return o +} + +func (o MembershipMapOutput) MapIndex(k pulumi.StringInput) MembershipOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Membership { + return vs[0].(map[string]*Membership)[vs[1].(string)] + }).(MembershipOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*MembershipInput)(nil)).Elem(), &Membership{}) + pulumi.RegisterInputType(reflect.TypeOf((*MembershipArrayInput)(nil)).Elem(), MembershipArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*MembershipMapInput)(nil)).Elem(), MembershipMap{}) + pulumi.RegisterOutputType(MembershipOutput{}) + pulumi.RegisterOutputType(MembershipArrayOutput{}) + pulumi.RegisterOutputType(MembershipMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationBlock.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationBlock.go new file mode 100644 index 000000000..2c1060b17 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationBlock.go @@ -0,0 +1,260 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage blocks for GitHub organizations. +// +// ## Example Usage +// +// ```go +// 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.NewOrganizationBlock(ctx, "example", &github.OrganizationBlockArgs{ +// Username: pulumi.String("paultyng"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub organization block can be imported using a username, e.g. +// +// ```sh +// $ pulumi import github:index/organizationBlock:OrganizationBlock example someuser +// ``` +type OrganizationBlock struct { + pulumi.CustomResourceState + + Etag pulumi.StringOutput `pulumi:"etag"` + // The name of the user to block. + Username pulumi.StringOutput `pulumi:"username"` +} + +// NewOrganizationBlock registers a new resource with the given unique name, arguments, and options. +func NewOrganizationBlock(ctx *pulumi.Context, + name string, args *OrganizationBlockArgs, opts ...pulumi.ResourceOption) (*OrganizationBlock, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Username == nil { + return nil, errors.New("invalid value for required argument 'Username'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource OrganizationBlock + err := ctx.RegisterResource("github:index/organizationBlock:OrganizationBlock", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetOrganizationBlock gets an existing OrganizationBlock 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 GetOrganizationBlock(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *OrganizationBlockState, opts ...pulumi.ResourceOption) (*OrganizationBlock, error) { + var resource OrganizationBlock + err := ctx.ReadResource("github:index/organizationBlock:OrganizationBlock", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering OrganizationBlock resources. +type organizationBlockState struct { + Etag *string `pulumi:"etag"` + // The name of the user to block. + Username *string `pulumi:"username"` +} + +type OrganizationBlockState struct { + Etag pulumi.StringPtrInput + // The name of the user to block. + Username pulumi.StringPtrInput +} + +func (OrganizationBlockState) ElementType() reflect.Type { + return reflect.TypeOf((*organizationBlockState)(nil)).Elem() +} + +type organizationBlockArgs struct { + // The name of the user to block. + Username string `pulumi:"username"` +} + +// The set of arguments for constructing a OrganizationBlock resource. +type OrganizationBlockArgs struct { + // The name of the user to block. + Username pulumi.StringInput +} + +func (OrganizationBlockArgs) ElementType() reflect.Type { + return reflect.TypeOf((*organizationBlockArgs)(nil)).Elem() +} + +type OrganizationBlockInput interface { + pulumi.Input + + ToOrganizationBlockOutput() OrganizationBlockOutput + ToOrganizationBlockOutputWithContext(ctx context.Context) OrganizationBlockOutput +} + +func (*OrganizationBlock) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationBlock)(nil)).Elem() +} + +func (i *OrganizationBlock) ToOrganizationBlockOutput() OrganizationBlockOutput { + return i.ToOrganizationBlockOutputWithContext(context.Background()) +} + +func (i *OrganizationBlock) ToOrganizationBlockOutputWithContext(ctx context.Context) OrganizationBlockOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationBlockOutput) +} + +// OrganizationBlockArrayInput is an input type that accepts OrganizationBlockArray and OrganizationBlockArrayOutput values. +// You can construct a concrete instance of `OrganizationBlockArrayInput` via: +// +// OrganizationBlockArray{ OrganizationBlockArgs{...} } +type OrganizationBlockArrayInput interface { + pulumi.Input + + ToOrganizationBlockArrayOutput() OrganizationBlockArrayOutput + ToOrganizationBlockArrayOutputWithContext(context.Context) OrganizationBlockArrayOutput +} + +type OrganizationBlockArray []OrganizationBlockInput + +func (OrganizationBlockArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationBlock)(nil)).Elem() +} + +func (i OrganizationBlockArray) ToOrganizationBlockArrayOutput() OrganizationBlockArrayOutput { + return i.ToOrganizationBlockArrayOutputWithContext(context.Background()) +} + +func (i OrganizationBlockArray) ToOrganizationBlockArrayOutputWithContext(ctx context.Context) OrganizationBlockArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationBlockArrayOutput) +} + +// OrganizationBlockMapInput is an input type that accepts OrganizationBlockMap and OrganizationBlockMapOutput values. +// You can construct a concrete instance of `OrganizationBlockMapInput` via: +// +// OrganizationBlockMap{ "key": OrganizationBlockArgs{...} } +type OrganizationBlockMapInput interface { + pulumi.Input + + ToOrganizationBlockMapOutput() OrganizationBlockMapOutput + ToOrganizationBlockMapOutputWithContext(context.Context) OrganizationBlockMapOutput +} + +type OrganizationBlockMap map[string]OrganizationBlockInput + +func (OrganizationBlockMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationBlock)(nil)).Elem() +} + +func (i OrganizationBlockMap) ToOrganizationBlockMapOutput() OrganizationBlockMapOutput { + return i.ToOrganizationBlockMapOutputWithContext(context.Background()) +} + +func (i OrganizationBlockMap) ToOrganizationBlockMapOutputWithContext(ctx context.Context) OrganizationBlockMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationBlockMapOutput) +} + +type OrganizationBlockOutput struct{ *pulumi.OutputState } + +func (OrganizationBlockOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationBlock)(nil)).Elem() +} + +func (o OrganizationBlockOutput) ToOrganizationBlockOutput() OrganizationBlockOutput { + return o +} + +func (o OrganizationBlockOutput) ToOrganizationBlockOutputWithContext(ctx context.Context) OrganizationBlockOutput { + return o +} + +func (o OrganizationBlockOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationBlock) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// The name of the user to block. +func (o OrganizationBlockOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationBlock) pulumi.StringOutput { return v.Username }).(pulumi.StringOutput) +} + +type OrganizationBlockArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationBlockArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationBlock)(nil)).Elem() +} + +func (o OrganizationBlockArrayOutput) ToOrganizationBlockArrayOutput() OrganizationBlockArrayOutput { + return o +} + +func (o OrganizationBlockArrayOutput) ToOrganizationBlockArrayOutputWithContext(ctx context.Context) OrganizationBlockArrayOutput { + return o +} + +func (o OrganizationBlockArrayOutput) Index(i pulumi.IntInput) OrganizationBlockOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OrganizationBlock { + return vs[0].([]*OrganizationBlock)[vs[1].(int)] + }).(OrganizationBlockOutput) +} + +type OrganizationBlockMapOutput struct{ *pulumi.OutputState } + +func (OrganizationBlockMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationBlock)(nil)).Elem() +} + +func (o OrganizationBlockMapOutput) ToOrganizationBlockMapOutput() OrganizationBlockMapOutput { + return o +} + +func (o OrganizationBlockMapOutput) ToOrganizationBlockMapOutputWithContext(ctx context.Context) OrganizationBlockMapOutput { + return o +} + +func (o OrganizationBlockMapOutput) MapIndex(k pulumi.StringInput) OrganizationBlockOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *OrganizationBlock { + return vs[0].(map[string]*OrganizationBlock)[vs[1].(string)] + }).(OrganizationBlockOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationBlockInput)(nil)).Elem(), &OrganizationBlock{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationBlockArrayInput)(nil)).Elem(), OrganizationBlockArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationBlockMapInput)(nil)).Elem(), OrganizationBlockMap{}) + pulumi.RegisterOutputType(OrganizationBlockOutput{}) + pulumi.RegisterOutputType(OrganizationBlockArrayOutput{}) + pulumi.RegisterOutputType(OrganizationBlockMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationCustomProperties.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationCustomProperties.go new file mode 100644 index 000000000..f77e69f8a --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationCustomProperties.go @@ -0,0 +1,445 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage custom properties for a GitHub organization. +// +// Custom properties enable you to add metadata to repositories within your organization. You can use custom properties to add context about repositories, such as who owns them, when they expire, or compliance requirements. +// +// ## Example Usage +// +// ```go +// 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.NewOrganizationCustomProperties(ctx, "environment", &github.OrganizationCustomPropertiesArgs{ +// PropertyName: pulumi.String("environment"), +// ValueType: pulumi.String("single_select"), +// Required: pulumi.Bool(true), +// Description: pulumi.String("The deployment environment for this repository"), +// DefaultValue: pulumi.String("development"), +// AllowedValues: pulumi.StringArray{ +// pulumi.String("development"), +// pulumi.String("staging"), +// pulumi.String("production"), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ### Allow Repository Actors To Edit +// +// This example shows how to allow repository administrators to edit the property values: +// +// ```go +// 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.NewOrganizationCustomProperties(ctx, "team_contact", &github.OrganizationCustomPropertiesArgs{ +// PropertyName: pulumi.String("team_contact"), +// ValueType: pulumi.String("string"), +// Required: pulumi.Bool(false), +// Description: pulumi.String("Contact information for the team managing this repository"), +// ValuesEditableBy: pulumi.String("org_and_repo_actors"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ### Text Property +// +// ```go +// 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.NewOrganizationCustomProperties(ctx, "owner", &github.OrganizationCustomPropertiesArgs{ +// PropertyName: pulumi.String("owner"), +// ValueType: pulumi.String("string"), +// Required: pulumi.Bool(true), +// Description: pulumi.String("The team or individual responsible for this repository"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ### Boolean Property +// +// ```go +// 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.NewOrganizationCustomProperties(ctx, "archived", &github.OrganizationCustomPropertiesArgs{ +// PropertyName: pulumi.String("archived"), +// ValueType: pulumi.String("true_false"), +// Required: pulumi.Bool(false), +// Description: pulumi.String("Whether this repository is archived"), +// DefaultValue: pulumi.String("false"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// Organization custom properties can be imported using the property name: +// +// ```sh +// $ pulumi import github:index/organizationCustomProperties:OrganizationCustomProperties environment environment +// ``` +type OrganizationCustomProperties struct { + pulumi.CustomResourceState + + // List of allowed values for the custom property. Only applicable when `valueType` is `singleSelect` or `multiSelect`. + AllowedValues pulumi.StringArrayOutput `pulumi:"allowedValues"` + // The default value of the custom property. + DefaultValue pulumi.StringOutput `pulumi:"defaultValue"` + // The description of the custom property. + Description pulumi.StringOutput `pulumi:"description"` + // The name of the custom property. + PropertyName pulumi.StringOutput `pulumi:"propertyName"` + // Whether the custom property is required. Defaults to `false`. + Required pulumi.BoolPtrOutput `pulumi:"required"` + // The type of the custom property. Can be one of `string`, `singleSelect`, `multiSelect`, or `trueFalse`. Defaults to `string`. + ValueType pulumi.StringPtrOutput `pulumi:"valueType"` + // Who can edit the values of the custom property. Can be one of `orgActors` or `orgAndRepoActors`. When set to `orgActors` (the default), only organization owners can edit the property values on repositories. When set to `orgAndRepoActors`, both organization owners and repository administrators with the custom properties permission can edit the values. + ValuesEditableBy pulumi.StringOutput `pulumi:"valuesEditableBy"` +} + +// NewOrganizationCustomProperties registers a new resource with the given unique name, arguments, and options. +func NewOrganizationCustomProperties(ctx *pulumi.Context, + name string, args *OrganizationCustomPropertiesArgs, opts ...pulumi.ResourceOption) (*OrganizationCustomProperties, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.PropertyName == nil { + return nil, errors.New("invalid value for required argument 'PropertyName'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource OrganizationCustomProperties + err := ctx.RegisterResource("github:index/organizationCustomProperties:OrganizationCustomProperties", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetOrganizationCustomProperties gets an existing OrganizationCustomProperties 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 GetOrganizationCustomProperties(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *OrganizationCustomPropertiesState, opts ...pulumi.ResourceOption) (*OrganizationCustomProperties, error) { + var resource OrganizationCustomProperties + err := ctx.ReadResource("github:index/organizationCustomProperties:OrganizationCustomProperties", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering OrganizationCustomProperties resources. +type organizationCustomPropertiesState struct { + // List of allowed values for the custom property. Only applicable when `valueType` is `singleSelect` or `multiSelect`. + AllowedValues []string `pulumi:"allowedValues"` + // The default value of the custom property. + DefaultValue *string `pulumi:"defaultValue"` + // The description of the custom property. + Description *string `pulumi:"description"` + // The name of the custom property. + PropertyName *string `pulumi:"propertyName"` + // Whether the custom property is required. Defaults to `false`. + Required *bool `pulumi:"required"` + // The type of the custom property. Can be one of `string`, `singleSelect`, `multiSelect`, or `trueFalse`. Defaults to `string`. + ValueType *string `pulumi:"valueType"` + // Who can edit the values of the custom property. Can be one of `orgActors` or `orgAndRepoActors`. When set to `orgActors` (the default), only organization owners can edit the property values on repositories. When set to `orgAndRepoActors`, both organization owners and repository administrators with the custom properties permission can edit the values. + ValuesEditableBy *string `pulumi:"valuesEditableBy"` +} + +type OrganizationCustomPropertiesState struct { + // List of allowed values for the custom property. Only applicable when `valueType` is `singleSelect` or `multiSelect`. + AllowedValues pulumi.StringArrayInput + // The default value of the custom property. + DefaultValue pulumi.StringPtrInput + // The description of the custom property. + Description pulumi.StringPtrInput + // The name of the custom property. + PropertyName pulumi.StringPtrInput + // Whether the custom property is required. Defaults to `false`. + Required pulumi.BoolPtrInput + // The type of the custom property. Can be one of `string`, `singleSelect`, `multiSelect`, or `trueFalse`. Defaults to `string`. + ValueType pulumi.StringPtrInput + // Who can edit the values of the custom property. Can be one of `orgActors` or `orgAndRepoActors`. When set to `orgActors` (the default), only organization owners can edit the property values on repositories. When set to `orgAndRepoActors`, both organization owners and repository administrators with the custom properties permission can edit the values. + ValuesEditableBy pulumi.StringPtrInput +} + +func (OrganizationCustomPropertiesState) ElementType() reflect.Type { + return reflect.TypeOf((*organizationCustomPropertiesState)(nil)).Elem() +} + +type organizationCustomPropertiesArgs struct { + // List of allowed values for the custom property. Only applicable when `valueType` is `singleSelect` or `multiSelect`. + AllowedValues []string `pulumi:"allowedValues"` + // The default value of the custom property. + DefaultValue *string `pulumi:"defaultValue"` + // The description of the custom property. + Description *string `pulumi:"description"` + // The name of the custom property. + PropertyName string `pulumi:"propertyName"` + // Whether the custom property is required. Defaults to `false`. + Required *bool `pulumi:"required"` + // The type of the custom property. Can be one of `string`, `singleSelect`, `multiSelect`, or `trueFalse`. Defaults to `string`. + ValueType *string `pulumi:"valueType"` + // Who can edit the values of the custom property. Can be one of `orgActors` or `orgAndRepoActors`. When set to `orgActors` (the default), only organization owners can edit the property values on repositories. When set to `orgAndRepoActors`, both organization owners and repository administrators with the custom properties permission can edit the values. + ValuesEditableBy *string `pulumi:"valuesEditableBy"` +} + +// The set of arguments for constructing a OrganizationCustomProperties resource. +type OrganizationCustomPropertiesArgs struct { + // List of allowed values for the custom property. Only applicable when `valueType` is `singleSelect` or `multiSelect`. + AllowedValues pulumi.StringArrayInput + // The default value of the custom property. + DefaultValue pulumi.StringPtrInput + // The description of the custom property. + Description pulumi.StringPtrInput + // The name of the custom property. + PropertyName pulumi.StringInput + // Whether the custom property is required. Defaults to `false`. + Required pulumi.BoolPtrInput + // The type of the custom property. Can be one of `string`, `singleSelect`, `multiSelect`, or `trueFalse`. Defaults to `string`. + ValueType pulumi.StringPtrInput + // Who can edit the values of the custom property. Can be one of `orgActors` or `orgAndRepoActors`. When set to `orgActors` (the default), only organization owners can edit the property values on repositories. When set to `orgAndRepoActors`, both organization owners and repository administrators with the custom properties permission can edit the values. + ValuesEditableBy pulumi.StringPtrInput +} + +func (OrganizationCustomPropertiesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*organizationCustomPropertiesArgs)(nil)).Elem() +} + +type OrganizationCustomPropertiesInput interface { + pulumi.Input + + ToOrganizationCustomPropertiesOutput() OrganizationCustomPropertiesOutput + ToOrganizationCustomPropertiesOutputWithContext(ctx context.Context) OrganizationCustomPropertiesOutput +} + +func (*OrganizationCustomProperties) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationCustomProperties)(nil)).Elem() +} + +func (i *OrganizationCustomProperties) ToOrganizationCustomPropertiesOutput() OrganizationCustomPropertiesOutput { + return i.ToOrganizationCustomPropertiesOutputWithContext(context.Background()) +} + +func (i *OrganizationCustomProperties) ToOrganizationCustomPropertiesOutputWithContext(ctx context.Context) OrganizationCustomPropertiesOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationCustomPropertiesOutput) +} + +// OrganizationCustomPropertiesArrayInput is an input type that accepts OrganizationCustomPropertiesArray and OrganizationCustomPropertiesArrayOutput values. +// You can construct a concrete instance of `OrganizationCustomPropertiesArrayInput` via: +// +// OrganizationCustomPropertiesArray{ OrganizationCustomPropertiesArgs{...} } +type OrganizationCustomPropertiesArrayInput interface { + pulumi.Input + + ToOrganizationCustomPropertiesArrayOutput() OrganizationCustomPropertiesArrayOutput + ToOrganizationCustomPropertiesArrayOutputWithContext(context.Context) OrganizationCustomPropertiesArrayOutput +} + +type OrganizationCustomPropertiesArray []OrganizationCustomPropertiesInput + +func (OrganizationCustomPropertiesArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationCustomProperties)(nil)).Elem() +} + +func (i OrganizationCustomPropertiesArray) ToOrganizationCustomPropertiesArrayOutput() OrganizationCustomPropertiesArrayOutput { + return i.ToOrganizationCustomPropertiesArrayOutputWithContext(context.Background()) +} + +func (i OrganizationCustomPropertiesArray) ToOrganizationCustomPropertiesArrayOutputWithContext(ctx context.Context) OrganizationCustomPropertiesArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationCustomPropertiesArrayOutput) +} + +// OrganizationCustomPropertiesMapInput is an input type that accepts OrganizationCustomPropertiesMap and OrganizationCustomPropertiesMapOutput values. +// You can construct a concrete instance of `OrganizationCustomPropertiesMapInput` via: +// +// OrganizationCustomPropertiesMap{ "key": OrganizationCustomPropertiesArgs{...} } +type OrganizationCustomPropertiesMapInput interface { + pulumi.Input + + ToOrganizationCustomPropertiesMapOutput() OrganizationCustomPropertiesMapOutput + ToOrganizationCustomPropertiesMapOutputWithContext(context.Context) OrganizationCustomPropertiesMapOutput +} + +type OrganizationCustomPropertiesMap map[string]OrganizationCustomPropertiesInput + +func (OrganizationCustomPropertiesMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationCustomProperties)(nil)).Elem() +} + +func (i OrganizationCustomPropertiesMap) ToOrganizationCustomPropertiesMapOutput() OrganizationCustomPropertiesMapOutput { + return i.ToOrganizationCustomPropertiesMapOutputWithContext(context.Background()) +} + +func (i OrganizationCustomPropertiesMap) ToOrganizationCustomPropertiesMapOutputWithContext(ctx context.Context) OrganizationCustomPropertiesMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationCustomPropertiesMapOutput) +} + +type OrganizationCustomPropertiesOutput struct{ *pulumi.OutputState } + +func (OrganizationCustomPropertiesOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationCustomProperties)(nil)).Elem() +} + +func (o OrganizationCustomPropertiesOutput) ToOrganizationCustomPropertiesOutput() OrganizationCustomPropertiesOutput { + return o +} + +func (o OrganizationCustomPropertiesOutput) ToOrganizationCustomPropertiesOutputWithContext(ctx context.Context) OrganizationCustomPropertiesOutput { + return o +} + +// List of allowed values for the custom property. Only applicable when `valueType` is `singleSelect` or `multiSelect`. +func (o OrganizationCustomPropertiesOutput) AllowedValues() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OrganizationCustomProperties) pulumi.StringArrayOutput { return v.AllowedValues }).(pulumi.StringArrayOutput) +} + +// The default value of the custom property. +func (o OrganizationCustomPropertiesOutput) DefaultValue() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationCustomProperties) pulumi.StringOutput { return v.DefaultValue }).(pulumi.StringOutput) +} + +// The description of the custom property. +func (o OrganizationCustomPropertiesOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationCustomProperties) pulumi.StringOutput { return v.Description }).(pulumi.StringOutput) +} + +// The name of the custom property. +func (o OrganizationCustomPropertiesOutput) PropertyName() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationCustomProperties) pulumi.StringOutput { return v.PropertyName }).(pulumi.StringOutput) +} + +// Whether the custom property is required. Defaults to `false`. +func (o OrganizationCustomPropertiesOutput) Required() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationCustomProperties) pulumi.BoolPtrOutput { return v.Required }).(pulumi.BoolPtrOutput) +} + +// The type of the custom property. Can be one of `string`, `singleSelect`, `multiSelect`, or `trueFalse`. Defaults to `string`. +func (o OrganizationCustomPropertiesOutput) ValueType() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationCustomProperties) pulumi.StringPtrOutput { return v.ValueType }).(pulumi.StringPtrOutput) +} + +// Who can edit the values of the custom property. Can be one of `orgActors` or `orgAndRepoActors`. When set to `orgActors` (the default), only organization owners can edit the property values on repositories. When set to `orgAndRepoActors`, both organization owners and repository administrators with the custom properties permission can edit the values. +func (o OrganizationCustomPropertiesOutput) ValuesEditableBy() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationCustomProperties) pulumi.StringOutput { return v.ValuesEditableBy }).(pulumi.StringOutput) +} + +type OrganizationCustomPropertiesArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationCustomPropertiesArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationCustomProperties)(nil)).Elem() +} + +func (o OrganizationCustomPropertiesArrayOutput) ToOrganizationCustomPropertiesArrayOutput() OrganizationCustomPropertiesArrayOutput { + return o +} + +func (o OrganizationCustomPropertiesArrayOutput) ToOrganizationCustomPropertiesArrayOutputWithContext(ctx context.Context) OrganizationCustomPropertiesArrayOutput { + return o +} + +func (o OrganizationCustomPropertiesArrayOutput) Index(i pulumi.IntInput) OrganizationCustomPropertiesOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OrganizationCustomProperties { + return vs[0].([]*OrganizationCustomProperties)[vs[1].(int)] + }).(OrganizationCustomPropertiesOutput) +} + +type OrganizationCustomPropertiesMapOutput struct{ *pulumi.OutputState } + +func (OrganizationCustomPropertiesMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationCustomProperties)(nil)).Elem() +} + +func (o OrganizationCustomPropertiesMapOutput) ToOrganizationCustomPropertiesMapOutput() OrganizationCustomPropertiesMapOutput { + return o +} + +func (o OrganizationCustomPropertiesMapOutput) ToOrganizationCustomPropertiesMapOutputWithContext(ctx context.Context) OrganizationCustomPropertiesMapOutput { + return o +} + +func (o OrganizationCustomPropertiesMapOutput) MapIndex(k pulumi.StringInput) OrganizationCustomPropertiesOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *OrganizationCustomProperties { + return vs[0].(map[string]*OrganizationCustomProperties)[vs[1].(string)] + }).(OrganizationCustomPropertiesOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationCustomPropertiesInput)(nil)).Elem(), &OrganizationCustomProperties{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationCustomPropertiesArrayInput)(nil)).Elem(), OrganizationCustomPropertiesArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationCustomPropertiesMapInput)(nil)).Elem(), OrganizationCustomPropertiesMap{}) + pulumi.RegisterOutputType(OrganizationCustomPropertiesOutput{}) + pulumi.RegisterOutputType(OrganizationCustomPropertiesArrayOutput{}) + pulumi.RegisterOutputType(OrganizationCustomPropertiesMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationCustomRole.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationCustomRole.go new file mode 100644 index 000000000..bc6830f0e --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationCustomRole.go @@ -0,0 +1,329 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// > **Note:** This resource is deprecated, please use the `OrganizationRepositoryRole` resource instead. +// +// This resource allows you to create and manage custom roles in a GitHub Organization for use in repositories. +// +// > Note: Custom roles are currently only available in GitHub Enterprise Cloud. +// +// ## Example Usage +// +// ```go +// 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.NewOrganizationCustomRole(ctx, "example", &github.OrganizationCustomRoleArgs{ +// Name: pulumi.String("example"), +// Description: pulumi.String("Example custom role that uses the read role as its base"), +// BaseRole: pulumi.String("read"), +// Permissions: pulumi.StringArray{ +// pulumi.String("add_assignee"), +// pulumi.String("add_label"), +// pulumi.String("bypass_branch_protection"), +// pulumi.String("close_issue"), +// pulumi.String("close_pull_request"), +// pulumi.String("mark_as_duplicate"), +// pulumi.String("create_tag"), +// pulumi.String("delete_issue"), +// pulumi.String("delete_tag"), +// pulumi.String("manage_deploy_keys"), +// pulumi.String("push_protected_branch"), +// pulumi.String("read_code_scanning"), +// pulumi.String("reopen_issue"), +// pulumi.String("reopen_pull_request"), +// pulumi.String("request_pr_review"), +// pulumi.String("resolve_dependabot_alerts"), +// pulumi.String("resolve_secret_scanning_alerts"), +// pulumi.String("view_secret_scanning_alerts"), +// pulumi.String("write_code_scanning"), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// Custom roles can be imported using the `id` of the role. +// The `id` of the custom role can be found using the [list custom roles in an organization](https://docs.github.com/en/enterprise-cloud@latest/rest/orgs/custom-roles#list-custom-repository-roles-in-an-organization) API. +// +// ```sh +// $ pulumi import github:index/organizationCustomRole:OrganizationCustomRole example 1234 +// ``` +type OrganizationCustomRole struct { + pulumi.CustomResourceState + + // The system role from which the role inherits permissions. Can be one of: `read`, `triage`, `write`, or `maintain`. + BaseRole pulumi.StringOutput `pulumi:"baseRole"` + // The description for the custom role. + Description pulumi.StringPtrOutput `pulumi:"description"` + // The name of the custom role. + Name pulumi.StringOutput `pulumi:"name"` + // A list of additional permissions included in this role. Must have a minimum of 1 additional permission. The list of available permissions can be found using the [list repository fine-grained permissions for an organization](https://docs.github.com/en/enterprise-cloud@latest/rest/orgs/custom-roles?apiVersion=2022-11-28#list-repository-fine-grained-permissions-for-an-organization) API. + Permissions pulumi.StringArrayOutput `pulumi:"permissions"` +} + +// NewOrganizationCustomRole registers a new resource with the given unique name, arguments, and options. +func NewOrganizationCustomRole(ctx *pulumi.Context, + name string, args *OrganizationCustomRoleArgs, opts ...pulumi.ResourceOption) (*OrganizationCustomRole, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.BaseRole == nil { + return nil, errors.New("invalid value for required argument 'BaseRole'") + } + if args.Permissions == nil { + return nil, errors.New("invalid value for required argument 'Permissions'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource OrganizationCustomRole + err := ctx.RegisterResource("github:index/organizationCustomRole:OrganizationCustomRole", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetOrganizationCustomRole gets an existing OrganizationCustomRole 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 GetOrganizationCustomRole(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *OrganizationCustomRoleState, opts ...pulumi.ResourceOption) (*OrganizationCustomRole, error) { + var resource OrganizationCustomRole + err := ctx.ReadResource("github:index/organizationCustomRole:OrganizationCustomRole", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering OrganizationCustomRole resources. +type organizationCustomRoleState struct { + // The system role from which the role inherits permissions. Can be one of: `read`, `triage`, `write`, or `maintain`. + BaseRole *string `pulumi:"baseRole"` + // The description for the custom role. + Description *string `pulumi:"description"` + // The name of the custom role. + Name *string `pulumi:"name"` + // A list of additional permissions included in this role. Must have a minimum of 1 additional permission. The list of available permissions can be found using the [list repository fine-grained permissions for an organization](https://docs.github.com/en/enterprise-cloud@latest/rest/orgs/custom-roles?apiVersion=2022-11-28#list-repository-fine-grained-permissions-for-an-organization) API. + Permissions []string `pulumi:"permissions"` +} + +type OrganizationCustomRoleState struct { + // The system role from which the role inherits permissions. Can be one of: `read`, `triage`, `write`, or `maintain`. + BaseRole pulumi.StringPtrInput + // The description for the custom role. + Description pulumi.StringPtrInput + // The name of the custom role. + Name pulumi.StringPtrInput + // A list of additional permissions included in this role. Must have a minimum of 1 additional permission. The list of available permissions can be found using the [list repository fine-grained permissions for an organization](https://docs.github.com/en/enterprise-cloud@latest/rest/orgs/custom-roles?apiVersion=2022-11-28#list-repository-fine-grained-permissions-for-an-organization) API. + Permissions pulumi.StringArrayInput +} + +func (OrganizationCustomRoleState) ElementType() reflect.Type { + return reflect.TypeOf((*organizationCustomRoleState)(nil)).Elem() +} + +type organizationCustomRoleArgs struct { + // The system role from which the role inherits permissions. Can be one of: `read`, `triage`, `write`, or `maintain`. + BaseRole string `pulumi:"baseRole"` + // The description for the custom role. + Description *string `pulumi:"description"` + // The name of the custom role. + Name *string `pulumi:"name"` + // A list of additional permissions included in this role. Must have a minimum of 1 additional permission. The list of available permissions can be found using the [list repository fine-grained permissions for an organization](https://docs.github.com/en/enterprise-cloud@latest/rest/orgs/custom-roles?apiVersion=2022-11-28#list-repository-fine-grained-permissions-for-an-organization) API. + Permissions []string `pulumi:"permissions"` +} + +// The set of arguments for constructing a OrganizationCustomRole resource. +type OrganizationCustomRoleArgs struct { + // The system role from which the role inherits permissions. Can be one of: `read`, `triage`, `write`, or `maintain`. + BaseRole pulumi.StringInput + // The description for the custom role. + Description pulumi.StringPtrInput + // The name of the custom role. + Name pulumi.StringPtrInput + // A list of additional permissions included in this role. Must have a minimum of 1 additional permission. The list of available permissions can be found using the [list repository fine-grained permissions for an organization](https://docs.github.com/en/enterprise-cloud@latest/rest/orgs/custom-roles?apiVersion=2022-11-28#list-repository-fine-grained-permissions-for-an-organization) API. + Permissions pulumi.StringArrayInput +} + +func (OrganizationCustomRoleArgs) ElementType() reflect.Type { + return reflect.TypeOf((*organizationCustomRoleArgs)(nil)).Elem() +} + +type OrganizationCustomRoleInput interface { + pulumi.Input + + ToOrganizationCustomRoleOutput() OrganizationCustomRoleOutput + ToOrganizationCustomRoleOutputWithContext(ctx context.Context) OrganizationCustomRoleOutput +} + +func (*OrganizationCustomRole) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationCustomRole)(nil)).Elem() +} + +func (i *OrganizationCustomRole) ToOrganizationCustomRoleOutput() OrganizationCustomRoleOutput { + return i.ToOrganizationCustomRoleOutputWithContext(context.Background()) +} + +func (i *OrganizationCustomRole) ToOrganizationCustomRoleOutputWithContext(ctx context.Context) OrganizationCustomRoleOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationCustomRoleOutput) +} + +// OrganizationCustomRoleArrayInput is an input type that accepts OrganizationCustomRoleArray and OrganizationCustomRoleArrayOutput values. +// You can construct a concrete instance of `OrganizationCustomRoleArrayInput` via: +// +// OrganizationCustomRoleArray{ OrganizationCustomRoleArgs{...} } +type OrganizationCustomRoleArrayInput interface { + pulumi.Input + + ToOrganizationCustomRoleArrayOutput() OrganizationCustomRoleArrayOutput + ToOrganizationCustomRoleArrayOutputWithContext(context.Context) OrganizationCustomRoleArrayOutput +} + +type OrganizationCustomRoleArray []OrganizationCustomRoleInput + +func (OrganizationCustomRoleArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationCustomRole)(nil)).Elem() +} + +func (i OrganizationCustomRoleArray) ToOrganizationCustomRoleArrayOutput() OrganizationCustomRoleArrayOutput { + return i.ToOrganizationCustomRoleArrayOutputWithContext(context.Background()) +} + +func (i OrganizationCustomRoleArray) ToOrganizationCustomRoleArrayOutputWithContext(ctx context.Context) OrganizationCustomRoleArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationCustomRoleArrayOutput) +} + +// OrganizationCustomRoleMapInput is an input type that accepts OrganizationCustomRoleMap and OrganizationCustomRoleMapOutput values. +// You can construct a concrete instance of `OrganizationCustomRoleMapInput` via: +// +// OrganizationCustomRoleMap{ "key": OrganizationCustomRoleArgs{...} } +type OrganizationCustomRoleMapInput interface { + pulumi.Input + + ToOrganizationCustomRoleMapOutput() OrganizationCustomRoleMapOutput + ToOrganizationCustomRoleMapOutputWithContext(context.Context) OrganizationCustomRoleMapOutput +} + +type OrganizationCustomRoleMap map[string]OrganizationCustomRoleInput + +func (OrganizationCustomRoleMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationCustomRole)(nil)).Elem() +} + +func (i OrganizationCustomRoleMap) ToOrganizationCustomRoleMapOutput() OrganizationCustomRoleMapOutput { + return i.ToOrganizationCustomRoleMapOutputWithContext(context.Background()) +} + +func (i OrganizationCustomRoleMap) ToOrganizationCustomRoleMapOutputWithContext(ctx context.Context) OrganizationCustomRoleMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationCustomRoleMapOutput) +} + +type OrganizationCustomRoleOutput struct{ *pulumi.OutputState } + +func (OrganizationCustomRoleOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationCustomRole)(nil)).Elem() +} + +func (o OrganizationCustomRoleOutput) ToOrganizationCustomRoleOutput() OrganizationCustomRoleOutput { + return o +} + +func (o OrganizationCustomRoleOutput) ToOrganizationCustomRoleOutputWithContext(ctx context.Context) OrganizationCustomRoleOutput { + return o +} + +// The system role from which the role inherits permissions. Can be one of: `read`, `triage`, `write`, or `maintain`. +func (o OrganizationCustomRoleOutput) BaseRole() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationCustomRole) pulumi.StringOutput { return v.BaseRole }).(pulumi.StringOutput) +} + +// The description for the custom role. +func (o OrganizationCustomRoleOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationCustomRole) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) +} + +// The name of the custom role. +func (o OrganizationCustomRoleOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationCustomRole) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// A list of additional permissions included in this role. Must have a minimum of 1 additional permission. The list of available permissions can be found using the [list repository fine-grained permissions for an organization](https://docs.github.com/en/enterprise-cloud@latest/rest/orgs/custom-roles?apiVersion=2022-11-28#list-repository-fine-grained-permissions-for-an-organization) API. +func (o OrganizationCustomRoleOutput) Permissions() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OrganizationCustomRole) pulumi.StringArrayOutput { return v.Permissions }).(pulumi.StringArrayOutput) +} + +type OrganizationCustomRoleArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationCustomRoleArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationCustomRole)(nil)).Elem() +} + +func (o OrganizationCustomRoleArrayOutput) ToOrganizationCustomRoleArrayOutput() OrganizationCustomRoleArrayOutput { + return o +} + +func (o OrganizationCustomRoleArrayOutput) ToOrganizationCustomRoleArrayOutputWithContext(ctx context.Context) OrganizationCustomRoleArrayOutput { + return o +} + +func (o OrganizationCustomRoleArrayOutput) Index(i pulumi.IntInput) OrganizationCustomRoleOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OrganizationCustomRole { + return vs[0].([]*OrganizationCustomRole)[vs[1].(int)] + }).(OrganizationCustomRoleOutput) +} + +type OrganizationCustomRoleMapOutput struct{ *pulumi.OutputState } + +func (OrganizationCustomRoleMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationCustomRole)(nil)).Elem() +} + +func (o OrganizationCustomRoleMapOutput) ToOrganizationCustomRoleMapOutput() OrganizationCustomRoleMapOutput { + return o +} + +func (o OrganizationCustomRoleMapOutput) ToOrganizationCustomRoleMapOutputWithContext(ctx context.Context) OrganizationCustomRoleMapOutput { + return o +} + +func (o OrganizationCustomRoleMapOutput) MapIndex(k pulumi.StringInput) OrganizationCustomRoleOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *OrganizationCustomRole { + return vs[0].(map[string]*OrganizationCustomRole)[vs[1].(string)] + }).(OrganizationCustomRoleOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationCustomRoleInput)(nil)).Elem(), &OrganizationCustomRole{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationCustomRoleArrayInput)(nil)).Elem(), OrganizationCustomRoleArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationCustomRoleMapInput)(nil)).Elem(), OrganizationCustomRoleMap{}) + pulumi.RegisterOutputType(OrganizationCustomRoleOutput{}) + pulumi.RegisterOutputType(OrganizationCustomRoleArrayOutput{}) + pulumi.RegisterOutputType(OrganizationCustomRoleMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationProject.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationProject.go new file mode 100644 index 000000000..2a5ee8c6b --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationProject.go @@ -0,0 +1,277 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// !> **Warning:** This resource no longer works as the [Projects (classic) REST API](https://docs.github.com/en/rest/projects/projects?apiVersion=2022-11-28) has been [removed](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) and as such has been deprecated. It will be removed in a future release. +// +// This resource allows you to create and manage projects for GitHub organization. +// +// ## Example Usage +// +// ```go +// 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.NewOrganizationProject(ctx, "project", &github.OrganizationProjectArgs{ +// Name: pulumi.String("A Organization Project"), +// Body: pulumi.String("This is a organization project."), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +type OrganizationProject struct { + pulumi.CustomResourceState + + // The body of the project. + Body pulumi.StringPtrOutput `pulumi:"body"` + Etag pulumi.StringOutput `pulumi:"etag"` + // The name of the project. + Name pulumi.StringOutput `pulumi:"name"` + // URL of the project + Url pulumi.StringOutput `pulumi:"url"` +} + +// NewOrganizationProject registers a new resource with the given unique name, arguments, and options. +func NewOrganizationProject(ctx *pulumi.Context, + name string, args *OrganizationProjectArgs, opts ...pulumi.ResourceOption) (*OrganizationProject, error) { + if args == nil { + args = &OrganizationProjectArgs{} + } + + opts = internal.PkgResourceDefaultOpts(opts) + var resource OrganizationProject + err := ctx.RegisterResource("github:index/organizationProject:OrganizationProject", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetOrganizationProject gets an existing OrganizationProject 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 GetOrganizationProject(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *OrganizationProjectState, opts ...pulumi.ResourceOption) (*OrganizationProject, error) { + var resource OrganizationProject + err := ctx.ReadResource("github:index/organizationProject:OrganizationProject", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering OrganizationProject resources. +type organizationProjectState struct { + // The body of the project. + Body *string `pulumi:"body"` + Etag *string `pulumi:"etag"` + // The name of the project. + Name *string `pulumi:"name"` + // URL of the project + Url *string `pulumi:"url"` +} + +type OrganizationProjectState struct { + // The body of the project. + Body pulumi.StringPtrInput + Etag pulumi.StringPtrInput + // The name of the project. + Name pulumi.StringPtrInput + // URL of the project + Url pulumi.StringPtrInput +} + +func (OrganizationProjectState) ElementType() reflect.Type { + return reflect.TypeOf((*organizationProjectState)(nil)).Elem() +} + +type organizationProjectArgs struct { + // The body of the project. + Body *string `pulumi:"body"` + // The name of the project. + Name *string `pulumi:"name"` +} + +// The set of arguments for constructing a OrganizationProject resource. +type OrganizationProjectArgs struct { + // The body of the project. + Body pulumi.StringPtrInput + // The name of the project. + Name pulumi.StringPtrInput +} + +func (OrganizationProjectArgs) ElementType() reflect.Type { + return reflect.TypeOf((*organizationProjectArgs)(nil)).Elem() +} + +type OrganizationProjectInput interface { + pulumi.Input + + ToOrganizationProjectOutput() OrganizationProjectOutput + ToOrganizationProjectOutputWithContext(ctx context.Context) OrganizationProjectOutput +} + +func (*OrganizationProject) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationProject)(nil)).Elem() +} + +func (i *OrganizationProject) ToOrganizationProjectOutput() OrganizationProjectOutput { + return i.ToOrganizationProjectOutputWithContext(context.Background()) +} + +func (i *OrganizationProject) ToOrganizationProjectOutputWithContext(ctx context.Context) OrganizationProjectOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationProjectOutput) +} + +// OrganizationProjectArrayInput is an input type that accepts OrganizationProjectArray and OrganizationProjectArrayOutput values. +// You can construct a concrete instance of `OrganizationProjectArrayInput` via: +// +// OrganizationProjectArray{ OrganizationProjectArgs{...} } +type OrganizationProjectArrayInput interface { + pulumi.Input + + ToOrganizationProjectArrayOutput() OrganizationProjectArrayOutput + ToOrganizationProjectArrayOutputWithContext(context.Context) OrganizationProjectArrayOutput +} + +type OrganizationProjectArray []OrganizationProjectInput + +func (OrganizationProjectArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationProject)(nil)).Elem() +} + +func (i OrganizationProjectArray) ToOrganizationProjectArrayOutput() OrganizationProjectArrayOutput { + return i.ToOrganizationProjectArrayOutputWithContext(context.Background()) +} + +func (i OrganizationProjectArray) ToOrganizationProjectArrayOutputWithContext(ctx context.Context) OrganizationProjectArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationProjectArrayOutput) +} + +// OrganizationProjectMapInput is an input type that accepts OrganizationProjectMap and OrganizationProjectMapOutput values. +// You can construct a concrete instance of `OrganizationProjectMapInput` via: +// +// OrganizationProjectMap{ "key": OrganizationProjectArgs{...} } +type OrganizationProjectMapInput interface { + pulumi.Input + + ToOrganizationProjectMapOutput() OrganizationProjectMapOutput + ToOrganizationProjectMapOutputWithContext(context.Context) OrganizationProjectMapOutput +} + +type OrganizationProjectMap map[string]OrganizationProjectInput + +func (OrganizationProjectMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationProject)(nil)).Elem() +} + +func (i OrganizationProjectMap) ToOrganizationProjectMapOutput() OrganizationProjectMapOutput { + return i.ToOrganizationProjectMapOutputWithContext(context.Background()) +} + +func (i OrganizationProjectMap) ToOrganizationProjectMapOutputWithContext(ctx context.Context) OrganizationProjectMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationProjectMapOutput) +} + +type OrganizationProjectOutput struct{ *pulumi.OutputState } + +func (OrganizationProjectOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationProject)(nil)).Elem() +} + +func (o OrganizationProjectOutput) ToOrganizationProjectOutput() OrganizationProjectOutput { + return o +} + +func (o OrganizationProjectOutput) ToOrganizationProjectOutputWithContext(ctx context.Context) OrganizationProjectOutput { + return o +} + +// The body of the project. +func (o OrganizationProjectOutput) Body() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationProject) pulumi.StringPtrOutput { return v.Body }).(pulumi.StringPtrOutput) +} + +func (o OrganizationProjectOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationProject) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// The name of the project. +func (o OrganizationProjectOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationProject) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// URL of the project +func (o OrganizationProjectOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationProject) pulumi.StringOutput { return v.Url }).(pulumi.StringOutput) +} + +type OrganizationProjectArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationProjectArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationProject)(nil)).Elem() +} + +func (o OrganizationProjectArrayOutput) ToOrganizationProjectArrayOutput() OrganizationProjectArrayOutput { + return o +} + +func (o OrganizationProjectArrayOutput) ToOrganizationProjectArrayOutputWithContext(ctx context.Context) OrganizationProjectArrayOutput { + return o +} + +func (o OrganizationProjectArrayOutput) Index(i pulumi.IntInput) OrganizationProjectOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OrganizationProject { + return vs[0].([]*OrganizationProject)[vs[1].(int)] + }).(OrganizationProjectOutput) +} + +type OrganizationProjectMapOutput struct{ *pulumi.OutputState } + +func (OrganizationProjectMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationProject)(nil)).Elem() +} + +func (o OrganizationProjectMapOutput) ToOrganizationProjectMapOutput() OrganizationProjectMapOutput { + return o +} + +func (o OrganizationProjectMapOutput) ToOrganizationProjectMapOutputWithContext(ctx context.Context) OrganizationProjectMapOutput { + return o +} + +func (o OrganizationProjectMapOutput) MapIndex(k pulumi.StringInput) OrganizationProjectOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *OrganizationProject { + return vs[0].(map[string]*OrganizationProject)[vs[1].(string)] + }).(OrganizationProjectOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationProjectInput)(nil)).Elem(), &OrganizationProject{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationProjectArrayInput)(nil)).Elem(), OrganizationProjectArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationProjectMapInput)(nil)).Elem(), OrganizationProjectMap{}) + pulumi.RegisterOutputType(OrganizationProjectOutput{}) + pulumi.RegisterOutputType(OrganizationProjectArrayOutput{}) + pulumi.RegisterOutputType(OrganizationProjectMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRepositoryRole.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRepositoryRole.go new file mode 100644 index 000000000..ead40e282 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRepositoryRole.go @@ -0,0 +1,319 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Manage a custom organization repository role. +// +// > **Note**: Custom organization repository roles are currently only available in GitHub Enterprise Cloud. +// +// ## Example Usage +// +// ```go +// 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.NewOrganizationRepositoryRole(ctx, "example", &github.OrganizationRepositoryRoleArgs{ +// Name: pulumi.String("example"), +// BaseRole: pulumi.String("read"), +// Permissions: pulumi.StringArray{ +// pulumi.String("add_assignee"), +// pulumi.String("add_label"), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// A custom organization repository role can be imported using its ID. +// +// ```sh +// $ pulumi import github:index/organizationRepositoryRole:OrganizationRepositoryRole example 1234 +// ``` +type OrganizationRepositoryRole struct { + pulumi.CustomResourceState + + // The system role from which this role inherits permissions. + BaseRole pulumi.StringOutput `pulumi:"baseRole"` + // The description of the organization repository role. + Description pulumi.StringPtrOutput `pulumi:"description"` + // The name of the organization repository role. + Name pulumi.StringOutput `pulumi:"name"` + // The permissions included in this role. + Permissions pulumi.StringArrayOutput `pulumi:"permissions"` + // The ID of the organization repository role. + RoleId pulumi.IntOutput `pulumi:"roleId"` +} + +// NewOrganizationRepositoryRole registers a new resource with the given unique name, arguments, and options. +func NewOrganizationRepositoryRole(ctx *pulumi.Context, + name string, args *OrganizationRepositoryRoleArgs, opts ...pulumi.ResourceOption) (*OrganizationRepositoryRole, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.BaseRole == nil { + return nil, errors.New("invalid value for required argument 'BaseRole'") + } + if args.Permissions == nil { + return nil, errors.New("invalid value for required argument 'Permissions'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource OrganizationRepositoryRole + err := ctx.RegisterResource("github:index/organizationRepositoryRole:OrganizationRepositoryRole", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetOrganizationRepositoryRole gets an existing OrganizationRepositoryRole 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 GetOrganizationRepositoryRole(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *OrganizationRepositoryRoleState, opts ...pulumi.ResourceOption) (*OrganizationRepositoryRole, error) { + var resource OrganizationRepositoryRole + err := ctx.ReadResource("github:index/organizationRepositoryRole:OrganizationRepositoryRole", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering OrganizationRepositoryRole resources. +type organizationRepositoryRoleState struct { + // The system role from which this role inherits permissions. + BaseRole *string `pulumi:"baseRole"` + // The description of the organization repository role. + Description *string `pulumi:"description"` + // The name of the organization repository role. + Name *string `pulumi:"name"` + // The permissions included in this role. + Permissions []string `pulumi:"permissions"` + // The ID of the organization repository role. + RoleId *int `pulumi:"roleId"` +} + +type OrganizationRepositoryRoleState struct { + // The system role from which this role inherits permissions. + BaseRole pulumi.StringPtrInput + // The description of the organization repository role. + Description pulumi.StringPtrInput + // The name of the organization repository role. + Name pulumi.StringPtrInput + // The permissions included in this role. + Permissions pulumi.StringArrayInput + // The ID of the organization repository role. + RoleId pulumi.IntPtrInput +} + +func (OrganizationRepositoryRoleState) ElementType() reflect.Type { + return reflect.TypeOf((*organizationRepositoryRoleState)(nil)).Elem() +} + +type organizationRepositoryRoleArgs struct { + // The system role from which this role inherits permissions. + BaseRole string `pulumi:"baseRole"` + // The description of the organization repository role. + Description *string `pulumi:"description"` + // The name of the organization repository role. + Name *string `pulumi:"name"` + // The permissions included in this role. + Permissions []string `pulumi:"permissions"` +} + +// The set of arguments for constructing a OrganizationRepositoryRole resource. +type OrganizationRepositoryRoleArgs struct { + // The system role from which this role inherits permissions. + BaseRole pulumi.StringInput + // The description of the organization repository role. + Description pulumi.StringPtrInput + // The name of the organization repository role. + Name pulumi.StringPtrInput + // The permissions included in this role. + Permissions pulumi.StringArrayInput +} + +func (OrganizationRepositoryRoleArgs) ElementType() reflect.Type { + return reflect.TypeOf((*organizationRepositoryRoleArgs)(nil)).Elem() +} + +type OrganizationRepositoryRoleInput interface { + pulumi.Input + + ToOrganizationRepositoryRoleOutput() OrganizationRepositoryRoleOutput + ToOrganizationRepositoryRoleOutputWithContext(ctx context.Context) OrganizationRepositoryRoleOutput +} + +func (*OrganizationRepositoryRole) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRepositoryRole)(nil)).Elem() +} + +func (i *OrganizationRepositoryRole) ToOrganizationRepositoryRoleOutput() OrganizationRepositoryRoleOutput { + return i.ToOrganizationRepositoryRoleOutputWithContext(context.Background()) +} + +func (i *OrganizationRepositoryRole) ToOrganizationRepositoryRoleOutputWithContext(ctx context.Context) OrganizationRepositoryRoleOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRepositoryRoleOutput) +} + +// OrganizationRepositoryRoleArrayInput is an input type that accepts OrganizationRepositoryRoleArray and OrganizationRepositoryRoleArrayOutput values. +// You can construct a concrete instance of `OrganizationRepositoryRoleArrayInput` via: +// +// OrganizationRepositoryRoleArray{ OrganizationRepositoryRoleArgs{...} } +type OrganizationRepositoryRoleArrayInput interface { + pulumi.Input + + ToOrganizationRepositoryRoleArrayOutput() OrganizationRepositoryRoleArrayOutput + ToOrganizationRepositoryRoleArrayOutputWithContext(context.Context) OrganizationRepositoryRoleArrayOutput +} + +type OrganizationRepositoryRoleArray []OrganizationRepositoryRoleInput + +func (OrganizationRepositoryRoleArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationRepositoryRole)(nil)).Elem() +} + +func (i OrganizationRepositoryRoleArray) ToOrganizationRepositoryRoleArrayOutput() OrganizationRepositoryRoleArrayOutput { + return i.ToOrganizationRepositoryRoleArrayOutputWithContext(context.Background()) +} + +func (i OrganizationRepositoryRoleArray) ToOrganizationRepositoryRoleArrayOutputWithContext(ctx context.Context) OrganizationRepositoryRoleArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRepositoryRoleArrayOutput) +} + +// OrganizationRepositoryRoleMapInput is an input type that accepts OrganizationRepositoryRoleMap and OrganizationRepositoryRoleMapOutput values. +// You can construct a concrete instance of `OrganizationRepositoryRoleMapInput` via: +// +// OrganizationRepositoryRoleMap{ "key": OrganizationRepositoryRoleArgs{...} } +type OrganizationRepositoryRoleMapInput interface { + pulumi.Input + + ToOrganizationRepositoryRoleMapOutput() OrganizationRepositoryRoleMapOutput + ToOrganizationRepositoryRoleMapOutputWithContext(context.Context) OrganizationRepositoryRoleMapOutput +} + +type OrganizationRepositoryRoleMap map[string]OrganizationRepositoryRoleInput + +func (OrganizationRepositoryRoleMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationRepositoryRole)(nil)).Elem() +} + +func (i OrganizationRepositoryRoleMap) ToOrganizationRepositoryRoleMapOutput() OrganizationRepositoryRoleMapOutput { + return i.ToOrganizationRepositoryRoleMapOutputWithContext(context.Background()) +} + +func (i OrganizationRepositoryRoleMap) ToOrganizationRepositoryRoleMapOutputWithContext(ctx context.Context) OrganizationRepositoryRoleMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRepositoryRoleMapOutput) +} + +type OrganizationRepositoryRoleOutput struct{ *pulumi.OutputState } + +func (OrganizationRepositoryRoleOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRepositoryRole)(nil)).Elem() +} + +func (o OrganizationRepositoryRoleOutput) ToOrganizationRepositoryRoleOutput() OrganizationRepositoryRoleOutput { + return o +} + +func (o OrganizationRepositoryRoleOutput) ToOrganizationRepositoryRoleOutputWithContext(ctx context.Context) OrganizationRepositoryRoleOutput { + return o +} + +// The system role from which this role inherits permissions. +func (o OrganizationRepositoryRoleOutput) BaseRole() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationRepositoryRole) pulumi.StringOutput { return v.BaseRole }).(pulumi.StringOutput) +} + +// The description of the organization repository role. +func (o OrganizationRepositoryRoleOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRepositoryRole) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) +} + +// The name of the organization repository role. +func (o OrganizationRepositoryRoleOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationRepositoryRole) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// The permissions included in this role. +func (o OrganizationRepositoryRoleOutput) Permissions() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OrganizationRepositoryRole) pulumi.StringArrayOutput { return v.Permissions }).(pulumi.StringArrayOutput) +} + +// The ID of the organization repository role. +func (o OrganizationRepositoryRoleOutput) RoleId() pulumi.IntOutput { + return o.ApplyT(func(v *OrganizationRepositoryRole) pulumi.IntOutput { return v.RoleId }).(pulumi.IntOutput) +} + +type OrganizationRepositoryRoleArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationRepositoryRoleArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationRepositoryRole)(nil)).Elem() +} + +func (o OrganizationRepositoryRoleArrayOutput) ToOrganizationRepositoryRoleArrayOutput() OrganizationRepositoryRoleArrayOutput { + return o +} + +func (o OrganizationRepositoryRoleArrayOutput) ToOrganizationRepositoryRoleArrayOutputWithContext(ctx context.Context) OrganizationRepositoryRoleArrayOutput { + return o +} + +func (o OrganizationRepositoryRoleArrayOutput) Index(i pulumi.IntInput) OrganizationRepositoryRoleOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OrganizationRepositoryRole { + return vs[0].([]*OrganizationRepositoryRole)[vs[1].(int)] + }).(OrganizationRepositoryRoleOutput) +} + +type OrganizationRepositoryRoleMapOutput struct{ *pulumi.OutputState } + +func (OrganizationRepositoryRoleMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationRepositoryRole)(nil)).Elem() +} + +func (o OrganizationRepositoryRoleMapOutput) ToOrganizationRepositoryRoleMapOutput() OrganizationRepositoryRoleMapOutput { + return o +} + +func (o OrganizationRepositoryRoleMapOutput) ToOrganizationRepositoryRoleMapOutputWithContext(ctx context.Context) OrganizationRepositoryRoleMapOutput { + return o +} + +func (o OrganizationRepositoryRoleMapOutput) MapIndex(k pulumi.StringInput) OrganizationRepositoryRoleOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *OrganizationRepositoryRole { + return vs[0].(map[string]*OrganizationRepositoryRole)[vs[1].(string)] + }).(OrganizationRepositoryRoleOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRepositoryRoleInput)(nil)).Elem(), &OrganizationRepositoryRole{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRepositoryRoleArrayInput)(nil)).Elem(), OrganizationRepositoryRoleArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRepositoryRoleMapInput)(nil)).Elem(), OrganizationRepositoryRoleMap{}) + pulumi.RegisterOutputType(OrganizationRepositoryRoleOutput{}) + pulumi.RegisterOutputType(OrganizationRepositoryRoleArrayOutput{}) + pulumi.RegisterOutputType(OrganizationRepositoryRoleMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRole.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRole.go new file mode 100644 index 000000000..e310da953 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRole.go @@ -0,0 +1,316 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Manage a custom organization role. +// +// > **Note**: Custom organization roles are currently only available in GitHub Enterprise Cloud. +// +// ## Example Usage +// +// ```go +// 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.NewOrganizationRole(ctx, "example", &github.OrganizationRoleArgs{ +// Name: pulumi.String("example"), +// BaseRole: pulumi.String("read"), +// Permissions: pulumi.StringArray{ +// pulumi.String("read_organization_custom_org_role"), +// pulumi.String("read_organization_custom_repo_role"), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// A custom organization role can be imported using its ID. +// +// ```sh +// $ pulumi import github:index/organizationRole:OrganizationRole example 1234 +// ``` +type OrganizationRole struct { + pulumi.CustomResourceState + + // The system role from which this role inherits permissions; one of `none`, `read`, `triage`, `write`, `maintain`, or `admin`. Defaults to `none`. + BaseRole pulumi.StringPtrOutput `pulumi:"baseRole"` + // The description of the organization role. + Description pulumi.StringPtrOutput `pulumi:"description"` + // The name of the organization role. + Name pulumi.StringOutput `pulumi:"name"` + // The permissions included in this role. Only organization permissions can be set if the `baseRole` isn't set or is set to `none`. + Permissions pulumi.StringArrayOutput `pulumi:"permissions"` + // The ID of the organization role. + RoleId pulumi.IntOutput `pulumi:"roleId"` +} + +// NewOrganizationRole registers a new resource with the given unique name, arguments, and options. +func NewOrganizationRole(ctx *pulumi.Context, + name string, args *OrganizationRoleArgs, opts ...pulumi.ResourceOption) (*OrganizationRole, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Permissions == nil { + return nil, errors.New("invalid value for required argument 'Permissions'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource OrganizationRole + err := ctx.RegisterResource("github:index/organizationRole:OrganizationRole", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetOrganizationRole gets an existing OrganizationRole 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 GetOrganizationRole(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *OrganizationRoleState, opts ...pulumi.ResourceOption) (*OrganizationRole, error) { + var resource OrganizationRole + err := ctx.ReadResource("github:index/organizationRole:OrganizationRole", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering OrganizationRole resources. +type organizationRoleState struct { + // The system role from which this role inherits permissions; one of `none`, `read`, `triage`, `write`, `maintain`, or `admin`. Defaults to `none`. + BaseRole *string `pulumi:"baseRole"` + // The description of the organization role. + Description *string `pulumi:"description"` + // The name of the organization role. + Name *string `pulumi:"name"` + // The permissions included in this role. Only organization permissions can be set if the `baseRole` isn't set or is set to `none`. + Permissions []string `pulumi:"permissions"` + // The ID of the organization role. + RoleId *int `pulumi:"roleId"` +} + +type OrganizationRoleState struct { + // The system role from which this role inherits permissions; one of `none`, `read`, `triage`, `write`, `maintain`, or `admin`. Defaults to `none`. + BaseRole pulumi.StringPtrInput + // The description of the organization role. + Description pulumi.StringPtrInput + // The name of the organization role. + Name pulumi.StringPtrInput + // The permissions included in this role. Only organization permissions can be set if the `baseRole` isn't set or is set to `none`. + Permissions pulumi.StringArrayInput + // The ID of the organization role. + RoleId pulumi.IntPtrInput +} + +func (OrganizationRoleState) ElementType() reflect.Type { + return reflect.TypeOf((*organizationRoleState)(nil)).Elem() +} + +type organizationRoleArgs struct { + // The system role from which this role inherits permissions; one of `none`, `read`, `triage`, `write`, `maintain`, or `admin`. Defaults to `none`. + BaseRole *string `pulumi:"baseRole"` + // The description of the organization role. + Description *string `pulumi:"description"` + // The name of the organization role. + Name *string `pulumi:"name"` + // The permissions included in this role. Only organization permissions can be set if the `baseRole` isn't set or is set to `none`. + Permissions []string `pulumi:"permissions"` +} + +// The set of arguments for constructing a OrganizationRole resource. +type OrganizationRoleArgs struct { + // The system role from which this role inherits permissions; one of `none`, `read`, `triage`, `write`, `maintain`, or `admin`. Defaults to `none`. + BaseRole pulumi.StringPtrInput + // The description of the organization role. + Description pulumi.StringPtrInput + // The name of the organization role. + Name pulumi.StringPtrInput + // The permissions included in this role. Only organization permissions can be set if the `baseRole` isn't set or is set to `none`. + Permissions pulumi.StringArrayInput +} + +func (OrganizationRoleArgs) ElementType() reflect.Type { + return reflect.TypeOf((*organizationRoleArgs)(nil)).Elem() +} + +type OrganizationRoleInput interface { + pulumi.Input + + ToOrganizationRoleOutput() OrganizationRoleOutput + ToOrganizationRoleOutputWithContext(ctx context.Context) OrganizationRoleOutput +} + +func (*OrganizationRole) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRole)(nil)).Elem() +} + +func (i *OrganizationRole) ToOrganizationRoleOutput() OrganizationRoleOutput { + return i.ToOrganizationRoleOutputWithContext(context.Background()) +} + +func (i *OrganizationRole) ToOrganizationRoleOutputWithContext(ctx context.Context) OrganizationRoleOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRoleOutput) +} + +// OrganizationRoleArrayInput is an input type that accepts OrganizationRoleArray and OrganizationRoleArrayOutput values. +// You can construct a concrete instance of `OrganizationRoleArrayInput` via: +// +// OrganizationRoleArray{ OrganizationRoleArgs{...} } +type OrganizationRoleArrayInput interface { + pulumi.Input + + ToOrganizationRoleArrayOutput() OrganizationRoleArrayOutput + ToOrganizationRoleArrayOutputWithContext(context.Context) OrganizationRoleArrayOutput +} + +type OrganizationRoleArray []OrganizationRoleInput + +func (OrganizationRoleArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationRole)(nil)).Elem() +} + +func (i OrganizationRoleArray) ToOrganizationRoleArrayOutput() OrganizationRoleArrayOutput { + return i.ToOrganizationRoleArrayOutputWithContext(context.Background()) +} + +func (i OrganizationRoleArray) ToOrganizationRoleArrayOutputWithContext(ctx context.Context) OrganizationRoleArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRoleArrayOutput) +} + +// OrganizationRoleMapInput is an input type that accepts OrganizationRoleMap and OrganizationRoleMapOutput values. +// You can construct a concrete instance of `OrganizationRoleMapInput` via: +// +// OrganizationRoleMap{ "key": OrganizationRoleArgs{...} } +type OrganizationRoleMapInput interface { + pulumi.Input + + ToOrganizationRoleMapOutput() OrganizationRoleMapOutput + ToOrganizationRoleMapOutputWithContext(context.Context) OrganizationRoleMapOutput +} + +type OrganizationRoleMap map[string]OrganizationRoleInput + +func (OrganizationRoleMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationRole)(nil)).Elem() +} + +func (i OrganizationRoleMap) ToOrganizationRoleMapOutput() OrganizationRoleMapOutput { + return i.ToOrganizationRoleMapOutputWithContext(context.Background()) +} + +func (i OrganizationRoleMap) ToOrganizationRoleMapOutputWithContext(ctx context.Context) OrganizationRoleMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRoleMapOutput) +} + +type OrganizationRoleOutput struct{ *pulumi.OutputState } + +func (OrganizationRoleOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRole)(nil)).Elem() +} + +func (o OrganizationRoleOutput) ToOrganizationRoleOutput() OrganizationRoleOutput { + return o +} + +func (o OrganizationRoleOutput) ToOrganizationRoleOutputWithContext(ctx context.Context) OrganizationRoleOutput { + return o +} + +// The system role from which this role inherits permissions; one of `none`, `read`, `triage`, `write`, `maintain`, or `admin`. Defaults to `none`. +func (o OrganizationRoleOutput) BaseRole() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRole) pulumi.StringPtrOutput { return v.BaseRole }).(pulumi.StringPtrOutput) +} + +// The description of the organization role. +func (o OrganizationRoleOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRole) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) +} + +// The name of the organization role. +func (o OrganizationRoleOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationRole) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// The permissions included in this role. Only organization permissions can be set if the `baseRole` isn't set or is set to `none`. +func (o OrganizationRoleOutput) Permissions() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OrganizationRole) pulumi.StringArrayOutput { return v.Permissions }).(pulumi.StringArrayOutput) +} + +// The ID of the organization role. +func (o OrganizationRoleOutput) RoleId() pulumi.IntOutput { + return o.ApplyT(func(v *OrganizationRole) pulumi.IntOutput { return v.RoleId }).(pulumi.IntOutput) +} + +type OrganizationRoleArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationRoleArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationRole)(nil)).Elem() +} + +func (o OrganizationRoleArrayOutput) ToOrganizationRoleArrayOutput() OrganizationRoleArrayOutput { + return o +} + +func (o OrganizationRoleArrayOutput) ToOrganizationRoleArrayOutputWithContext(ctx context.Context) OrganizationRoleArrayOutput { + return o +} + +func (o OrganizationRoleArrayOutput) Index(i pulumi.IntInput) OrganizationRoleOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OrganizationRole { + return vs[0].([]*OrganizationRole)[vs[1].(int)] + }).(OrganizationRoleOutput) +} + +type OrganizationRoleMapOutput struct{ *pulumi.OutputState } + +func (OrganizationRoleMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationRole)(nil)).Elem() +} + +func (o OrganizationRoleMapOutput) ToOrganizationRoleMapOutput() OrganizationRoleMapOutput { + return o +} + +func (o OrganizationRoleMapOutput) ToOrganizationRoleMapOutputWithContext(ctx context.Context) OrganizationRoleMapOutput { + return o +} + +func (o OrganizationRoleMapOutput) MapIndex(k pulumi.StringInput) OrganizationRoleOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *OrganizationRole { + return vs[0].(map[string]*OrganizationRole)[vs[1].(string)] + }).(OrganizationRoleOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRoleInput)(nil)).Elem(), &OrganizationRole{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRoleArrayInput)(nil)).Elem(), OrganizationRoleArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRoleMapInput)(nil)).Elem(), OrganizationRoleMap{}) + pulumi.RegisterOutputType(OrganizationRoleOutput{}) + pulumi.RegisterOutputType(OrganizationRoleArrayOutput{}) + pulumi.RegisterOutputType(OrganizationRoleMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRoleTeam.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRoleTeam.go new file mode 100644 index 000000000..dc0772383 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRoleTeam.go @@ -0,0 +1,272 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Manage an association between an organization role and a team. +// +// ## Example Usage +// +// ```go +// 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.NewOrganizationRoleTeam(ctx, "example", &github.OrganizationRoleTeamArgs{ +// RoleId: pulumi.Int(1234), +// TeamSlug: pulumi.String("example-team"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// An organization role team association can be imported using the role ID and the team slug separated by a `:`. +// +// ```sh +// $ pulumi import github:index/organizationRoleTeam:OrganizationRoleTeam example "1234:example-team" +// ``` +type OrganizationRoleTeam struct { + pulumi.CustomResourceState + + // The ID of the organization role. + RoleId pulumi.IntOutput `pulumi:"roleId"` + // The slug of the team name. + TeamSlug pulumi.StringOutput `pulumi:"teamSlug"` +} + +// NewOrganizationRoleTeam registers a new resource with the given unique name, arguments, and options. +func NewOrganizationRoleTeam(ctx *pulumi.Context, + name string, args *OrganizationRoleTeamArgs, opts ...pulumi.ResourceOption) (*OrganizationRoleTeam, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.RoleId == nil { + return nil, errors.New("invalid value for required argument 'RoleId'") + } + if args.TeamSlug == nil { + return nil, errors.New("invalid value for required argument 'TeamSlug'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource OrganizationRoleTeam + err := ctx.RegisterResource("github:index/organizationRoleTeam:OrganizationRoleTeam", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetOrganizationRoleTeam gets an existing OrganizationRoleTeam 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 GetOrganizationRoleTeam(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *OrganizationRoleTeamState, opts ...pulumi.ResourceOption) (*OrganizationRoleTeam, error) { + var resource OrganizationRoleTeam + err := ctx.ReadResource("github:index/organizationRoleTeam:OrganizationRoleTeam", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering OrganizationRoleTeam resources. +type organizationRoleTeamState struct { + // The ID of the organization role. + RoleId *int `pulumi:"roleId"` + // The slug of the team name. + TeamSlug *string `pulumi:"teamSlug"` +} + +type OrganizationRoleTeamState struct { + // The ID of the organization role. + RoleId pulumi.IntPtrInput + // The slug of the team name. + TeamSlug pulumi.StringPtrInput +} + +func (OrganizationRoleTeamState) ElementType() reflect.Type { + return reflect.TypeOf((*organizationRoleTeamState)(nil)).Elem() +} + +type organizationRoleTeamArgs struct { + // The ID of the organization role. + RoleId int `pulumi:"roleId"` + // The slug of the team name. + TeamSlug string `pulumi:"teamSlug"` +} + +// The set of arguments for constructing a OrganizationRoleTeam resource. +type OrganizationRoleTeamArgs struct { + // The ID of the organization role. + RoleId pulumi.IntInput + // The slug of the team name. + TeamSlug pulumi.StringInput +} + +func (OrganizationRoleTeamArgs) ElementType() reflect.Type { + return reflect.TypeOf((*organizationRoleTeamArgs)(nil)).Elem() +} + +type OrganizationRoleTeamInput interface { + pulumi.Input + + ToOrganizationRoleTeamOutput() OrganizationRoleTeamOutput + ToOrganizationRoleTeamOutputWithContext(ctx context.Context) OrganizationRoleTeamOutput +} + +func (*OrganizationRoleTeam) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRoleTeam)(nil)).Elem() +} + +func (i *OrganizationRoleTeam) ToOrganizationRoleTeamOutput() OrganizationRoleTeamOutput { + return i.ToOrganizationRoleTeamOutputWithContext(context.Background()) +} + +func (i *OrganizationRoleTeam) ToOrganizationRoleTeamOutputWithContext(ctx context.Context) OrganizationRoleTeamOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRoleTeamOutput) +} + +// OrganizationRoleTeamArrayInput is an input type that accepts OrganizationRoleTeamArray and OrganizationRoleTeamArrayOutput values. +// You can construct a concrete instance of `OrganizationRoleTeamArrayInput` via: +// +// OrganizationRoleTeamArray{ OrganizationRoleTeamArgs{...} } +type OrganizationRoleTeamArrayInput interface { + pulumi.Input + + ToOrganizationRoleTeamArrayOutput() OrganizationRoleTeamArrayOutput + ToOrganizationRoleTeamArrayOutputWithContext(context.Context) OrganizationRoleTeamArrayOutput +} + +type OrganizationRoleTeamArray []OrganizationRoleTeamInput + +func (OrganizationRoleTeamArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationRoleTeam)(nil)).Elem() +} + +func (i OrganizationRoleTeamArray) ToOrganizationRoleTeamArrayOutput() OrganizationRoleTeamArrayOutput { + return i.ToOrganizationRoleTeamArrayOutputWithContext(context.Background()) +} + +func (i OrganizationRoleTeamArray) ToOrganizationRoleTeamArrayOutputWithContext(ctx context.Context) OrganizationRoleTeamArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRoleTeamArrayOutput) +} + +// OrganizationRoleTeamMapInput is an input type that accepts OrganizationRoleTeamMap and OrganizationRoleTeamMapOutput values. +// You can construct a concrete instance of `OrganizationRoleTeamMapInput` via: +// +// OrganizationRoleTeamMap{ "key": OrganizationRoleTeamArgs{...} } +type OrganizationRoleTeamMapInput interface { + pulumi.Input + + ToOrganizationRoleTeamMapOutput() OrganizationRoleTeamMapOutput + ToOrganizationRoleTeamMapOutputWithContext(context.Context) OrganizationRoleTeamMapOutput +} + +type OrganizationRoleTeamMap map[string]OrganizationRoleTeamInput + +func (OrganizationRoleTeamMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationRoleTeam)(nil)).Elem() +} + +func (i OrganizationRoleTeamMap) ToOrganizationRoleTeamMapOutput() OrganizationRoleTeamMapOutput { + return i.ToOrganizationRoleTeamMapOutputWithContext(context.Background()) +} + +func (i OrganizationRoleTeamMap) ToOrganizationRoleTeamMapOutputWithContext(ctx context.Context) OrganizationRoleTeamMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRoleTeamMapOutput) +} + +type OrganizationRoleTeamOutput struct{ *pulumi.OutputState } + +func (OrganizationRoleTeamOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRoleTeam)(nil)).Elem() +} + +func (o OrganizationRoleTeamOutput) ToOrganizationRoleTeamOutput() OrganizationRoleTeamOutput { + return o +} + +func (o OrganizationRoleTeamOutput) ToOrganizationRoleTeamOutputWithContext(ctx context.Context) OrganizationRoleTeamOutput { + return o +} + +// The ID of the organization role. +func (o OrganizationRoleTeamOutput) RoleId() pulumi.IntOutput { + return o.ApplyT(func(v *OrganizationRoleTeam) pulumi.IntOutput { return v.RoleId }).(pulumi.IntOutput) +} + +// The slug of the team name. +func (o OrganizationRoleTeamOutput) TeamSlug() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationRoleTeam) pulumi.StringOutput { return v.TeamSlug }).(pulumi.StringOutput) +} + +type OrganizationRoleTeamArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationRoleTeamArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationRoleTeam)(nil)).Elem() +} + +func (o OrganizationRoleTeamArrayOutput) ToOrganizationRoleTeamArrayOutput() OrganizationRoleTeamArrayOutput { + return o +} + +func (o OrganizationRoleTeamArrayOutput) ToOrganizationRoleTeamArrayOutputWithContext(ctx context.Context) OrganizationRoleTeamArrayOutput { + return o +} + +func (o OrganizationRoleTeamArrayOutput) Index(i pulumi.IntInput) OrganizationRoleTeamOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OrganizationRoleTeam { + return vs[0].([]*OrganizationRoleTeam)[vs[1].(int)] + }).(OrganizationRoleTeamOutput) +} + +type OrganizationRoleTeamMapOutput struct{ *pulumi.OutputState } + +func (OrganizationRoleTeamMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationRoleTeam)(nil)).Elem() +} + +func (o OrganizationRoleTeamMapOutput) ToOrganizationRoleTeamMapOutput() OrganizationRoleTeamMapOutput { + return o +} + +func (o OrganizationRoleTeamMapOutput) ToOrganizationRoleTeamMapOutputWithContext(ctx context.Context) OrganizationRoleTeamMapOutput { + return o +} + +func (o OrganizationRoleTeamMapOutput) MapIndex(k pulumi.StringInput) OrganizationRoleTeamOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *OrganizationRoleTeam { + return vs[0].(map[string]*OrganizationRoleTeam)[vs[1].(string)] + }).(OrganizationRoleTeamOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRoleTeamInput)(nil)).Elem(), &OrganizationRoleTeam{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRoleTeamArrayInput)(nil)).Elem(), OrganizationRoleTeamArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRoleTeamMapInput)(nil)).Elem(), OrganizationRoleTeamMap{}) + pulumi.RegisterOutputType(OrganizationRoleTeamOutput{}) + pulumi.RegisterOutputType(OrganizationRoleTeamArrayOutput{}) + pulumi.RegisterOutputType(OrganizationRoleTeamMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRoleTeamAssignment.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRoleTeamAssignment.go new file mode 100644 index 000000000..cc1fc3905 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRoleTeamAssignment.go @@ -0,0 +1,282 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// > **Note:** This resource is deprecated, please use the `OrganizationRoleTeam` resource instead. +// +// This resource manages relationships between teams and organization roles +// in your GitHub organization. This works on predefined roles, and custom roles, where the latter is an Enterprise feature. +// +// Creating this resource assigns the role to a team. +// +// The organization role and team must both belong to the same organization +// on GitHub. +// +// ## Example Usage +// +// ```go +// 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 { +// test_team, err := github.NewTeam(ctx, "test-team", &github.TeamArgs{ +// Name: pulumi.String("test-team"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewOrganizationRoleTeamAssignment(ctx, "test-team-role-assignment", &github.OrganizationRoleTeamAssignmentArgs{ +// TeamSlug: test_team.Slug, +// RoleId: pulumi.String("8132"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Team Organization Role Assignment can be imported using an ID made up of `team_slug:role_id` +type OrganizationRoleTeamAssignment struct { + pulumi.CustomResourceState + + // The GitHub organization role id + RoleId pulumi.StringOutput `pulumi:"roleId"` + // The GitHub team slug + TeamSlug pulumi.StringOutput `pulumi:"teamSlug"` +} + +// NewOrganizationRoleTeamAssignment registers a new resource with the given unique name, arguments, and options. +func NewOrganizationRoleTeamAssignment(ctx *pulumi.Context, + name string, args *OrganizationRoleTeamAssignmentArgs, opts ...pulumi.ResourceOption) (*OrganizationRoleTeamAssignment, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.RoleId == nil { + return nil, errors.New("invalid value for required argument 'RoleId'") + } + if args.TeamSlug == nil { + return nil, errors.New("invalid value for required argument 'TeamSlug'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource OrganizationRoleTeamAssignment + err := ctx.RegisterResource("github:index/organizationRoleTeamAssignment:OrganizationRoleTeamAssignment", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetOrganizationRoleTeamAssignment gets an existing OrganizationRoleTeamAssignment 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 GetOrganizationRoleTeamAssignment(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *OrganizationRoleTeamAssignmentState, opts ...pulumi.ResourceOption) (*OrganizationRoleTeamAssignment, error) { + var resource OrganizationRoleTeamAssignment + err := ctx.ReadResource("github:index/organizationRoleTeamAssignment:OrganizationRoleTeamAssignment", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering OrganizationRoleTeamAssignment resources. +type organizationRoleTeamAssignmentState struct { + // The GitHub organization role id + RoleId *string `pulumi:"roleId"` + // The GitHub team slug + TeamSlug *string `pulumi:"teamSlug"` +} + +type OrganizationRoleTeamAssignmentState struct { + // The GitHub organization role id + RoleId pulumi.StringPtrInput + // The GitHub team slug + TeamSlug pulumi.StringPtrInput +} + +func (OrganizationRoleTeamAssignmentState) ElementType() reflect.Type { + return reflect.TypeOf((*organizationRoleTeamAssignmentState)(nil)).Elem() +} + +type organizationRoleTeamAssignmentArgs struct { + // The GitHub organization role id + RoleId string `pulumi:"roleId"` + // The GitHub team slug + TeamSlug string `pulumi:"teamSlug"` +} + +// The set of arguments for constructing a OrganizationRoleTeamAssignment resource. +type OrganizationRoleTeamAssignmentArgs struct { + // The GitHub organization role id + RoleId pulumi.StringInput + // The GitHub team slug + TeamSlug pulumi.StringInput +} + +func (OrganizationRoleTeamAssignmentArgs) ElementType() reflect.Type { + return reflect.TypeOf((*organizationRoleTeamAssignmentArgs)(nil)).Elem() +} + +type OrganizationRoleTeamAssignmentInput interface { + pulumi.Input + + ToOrganizationRoleTeamAssignmentOutput() OrganizationRoleTeamAssignmentOutput + ToOrganizationRoleTeamAssignmentOutputWithContext(ctx context.Context) OrganizationRoleTeamAssignmentOutput +} + +func (*OrganizationRoleTeamAssignment) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRoleTeamAssignment)(nil)).Elem() +} + +func (i *OrganizationRoleTeamAssignment) ToOrganizationRoleTeamAssignmentOutput() OrganizationRoleTeamAssignmentOutput { + return i.ToOrganizationRoleTeamAssignmentOutputWithContext(context.Background()) +} + +func (i *OrganizationRoleTeamAssignment) ToOrganizationRoleTeamAssignmentOutputWithContext(ctx context.Context) OrganizationRoleTeamAssignmentOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRoleTeamAssignmentOutput) +} + +// OrganizationRoleTeamAssignmentArrayInput is an input type that accepts OrganizationRoleTeamAssignmentArray and OrganizationRoleTeamAssignmentArrayOutput values. +// You can construct a concrete instance of `OrganizationRoleTeamAssignmentArrayInput` via: +// +// OrganizationRoleTeamAssignmentArray{ OrganizationRoleTeamAssignmentArgs{...} } +type OrganizationRoleTeamAssignmentArrayInput interface { + pulumi.Input + + ToOrganizationRoleTeamAssignmentArrayOutput() OrganizationRoleTeamAssignmentArrayOutput + ToOrganizationRoleTeamAssignmentArrayOutputWithContext(context.Context) OrganizationRoleTeamAssignmentArrayOutput +} + +type OrganizationRoleTeamAssignmentArray []OrganizationRoleTeamAssignmentInput + +func (OrganizationRoleTeamAssignmentArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationRoleTeamAssignment)(nil)).Elem() +} + +func (i OrganizationRoleTeamAssignmentArray) ToOrganizationRoleTeamAssignmentArrayOutput() OrganizationRoleTeamAssignmentArrayOutput { + return i.ToOrganizationRoleTeamAssignmentArrayOutputWithContext(context.Background()) +} + +func (i OrganizationRoleTeamAssignmentArray) ToOrganizationRoleTeamAssignmentArrayOutputWithContext(ctx context.Context) OrganizationRoleTeamAssignmentArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRoleTeamAssignmentArrayOutput) +} + +// OrganizationRoleTeamAssignmentMapInput is an input type that accepts OrganizationRoleTeamAssignmentMap and OrganizationRoleTeamAssignmentMapOutput values. +// You can construct a concrete instance of `OrganizationRoleTeamAssignmentMapInput` via: +// +// OrganizationRoleTeamAssignmentMap{ "key": OrganizationRoleTeamAssignmentArgs{...} } +type OrganizationRoleTeamAssignmentMapInput interface { + pulumi.Input + + ToOrganizationRoleTeamAssignmentMapOutput() OrganizationRoleTeamAssignmentMapOutput + ToOrganizationRoleTeamAssignmentMapOutputWithContext(context.Context) OrganizationRoleTeamAssignmentMapOutput +} + +type OrganizationRoleTeamAssignmentMap map[string]OrganizationRoleTeamAssignmentInput + +func (OrganizationRoleTeamAssignmentMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationRoleTeamAssignment)(nil)).Elem() +} + +func (i OrganizationRoleTeamAssignmentMap) ToOrganizationRoleTeamAssignmentMapOutput() OrganizationRoleTeamAssignmentMapOutput { + return i.ToOrganizationRoleTeamAssignmentMapOutputWithContext(context.Background()) +} + +func (i OrganizationRoleTeamAssignmentMap) ToOrganizationRoleTeamAssignmentMapOutputWithContext(ctx context.Context) OrganizationRoleTeamAssignmentMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRoleTeamAssignmentMapOutput) +} + +type OrganizationRoleTeamAssignmentOutput struct{ *pulumi.OutputState } + +func (OrganizationRoleTeamAssignmentOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRoleTeamAssignment)(nil)).Elem() +} + +func (o OrganizationRoleTeamAssignmentOutput) ToOrganizationRoleTeamAssignmentOutput() OrganizationRoleTeamAssignmentOutput { + return o +} + +func (o OrganizationRoleTeamAssignmentOutput) ToOrganizationRoleTeamAssignmentOutputWithContext(ctx context.Context) OrganizationRoleTeamAssignmentOutput { + return o +} + +// The GitHub organization role id +func (o OrganizationRoleTeamAssignmentOutput) RoleId() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationRoleTeamAssignment) pulumi.StringOutput { return v.RoleId }).(pulumi.StringOutput) +} + +// The GitHub team slug +func (o OrganizationRoleTeamAssignmentOutput) TeamSlug() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationRoleTeamAssignment) pulumi.StringOutput { return v.TeamSlug }).(pulumi.StringOutput) +} + +type OrganizationRoleTeamAssignmentArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationRoleTeamAssignmentArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationRoleTeamAssignment)(nil)).Elem() +} + +func (o OrganizationRoleTeamAssignmentArrayOutput) ToOrganizationRoleTeamAssignmentArrayOutput() OrganizationRoleTeamAssignmentArrayOutput { + return o +} + +func (o OrganizationRoleTeamAssignmentArrayOutput) ToOrganizationRoleTeamAssignmentArrayOutputWithContext(ctx context.Context) OrganizationRoleTeamAssignmentArrayOutput { + return o +} + +func (o OrganizationRoleTeamAssignmentArrayOutput) Index(i pulumi.IntInput) OrganizationRoleTeamAssignmentOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OrganizationRoleTeamAssignment { + return vs[0].([]*OrganizationRoleTeamAssignment)[vs[1].(int)] + }).(OrganizationRoleTeamAssignmentOutput) +} + +type OrganizationRoleTeamAssignmentMapOutput struct{ *pulumi.OutputState } + +func (OrganizationRoleTeamAssignmentMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationRoleTeamAssignment)(nil)).Elem() +} + +func (o OrganizationRoleTeamAssignmentMapOutput) ToOrganizationRoleTeamAssignmentMapOutput() OrganizationRoleTeamAssignmentMapOutput { + return o +} + +func (o OrganizationRoleTeamAssignmentMapOutput) ToOrganizationRoleTeamAssignmentMapOutputWithContext(ctx context.Context) OrganizationRoleTeamAssignmentMapOutput { + return o +} + +func (o OrganizationRoleTeamAssignmentMapOutput) MapIndex(k pulumi.StringInput) OrganizationRoleTeamAssignmentOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *OrganizationRoleTeamAssignment { + return vs[0].(map[string]*OrganizationRoleTeamAssignment)[vs[1].(string)] + }).(OrganizationRoleTeamAssignmentOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRoleTeamAssignmentInput)(nil)).Elem(), &OrganizationRoleTeamAssignment{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRoleTeamAssignmentArrayInput)(nil)).Elem(), OrganizationRoleTeamAssignmentArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRoleTeamAssignmentMapInput)(nil)).Elem(), OrganizationRoleTeamAssignmentMap{}) + pulumi.RegisterOutputType(OrganizationRoleTeamAssignmentOutput{}) + pulumi.RegisterOutputType(OrganizationRoleTeamAssignmentArrayOutput{}) + pulumi.RegisterOutputType(OrganizationRoleTeamAssignmentMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRoleUser.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRoleUser.go new file mode 100644 index 000000000..c5bf0bf12 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRoleUser.go @@ -0,0 +1,272 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Manage an association between an organization role and a user. +// +// ## Example Usage +// +// ```go +// 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.NewOrganizationRoleUser(ctx, "example", &github.OrganizationRoleUserArgs{ +// RoleId: pulumi.Int(1234), +// Login: pulumi.String("example-user"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// An organization role user association can be imported using the role ID and the user login separated by a `:`. +// +// ```sh +// $ pulumi import github:index/organizationRoleUser:OrganizationRoleUser example "1234:example-user" +// ``` +type OrganizationRoleUser struct { + pulumi.CustomResourceState + + // The login for the GitHub user account. + Login pulumi.StringOutput `pulumi:"login"` + // The ID of the organization role. + RoleId pulumi.IntOutput `pulumi:"roleId"` +} + +// NewOrganizationRoleUser registers a new resource with the given unique name, arguments, and options. +func NewOrganizationRoleUser(ctx *pulumi.Context, + name string, args *OrganizationRoleUserArgs, opts ...pulumi.ResourceOption) (*OrganizationRoleUser, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Login == nil { + return nil, errors.New("invalid value for required argument 'Login'") + } + if args.RoleId == nil { + return nil, errors.New("invalid value for required argument 'RoleId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource OrganizationRoleUser + err := ctx.RegisterResource("github:index/organizationRoleUser:OrganizationRoleUser", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetOrganizationRoleUser gets an existing OrganizationRoleUser 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 GetOrganizationRoleUser(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *OrganizationRoleUserState, opts ...pulumi.ResourceOption) (*OrganizationRoleUser, error) { + var resource OrganizationRoleUser + err := ctx.ReadResource("github:index/organizationRoleUser:OrganizationRoleUser", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering OrganizationRoleUser resources. +type organizationRoleUserState struct { + // The login for the GitHub user account. + Login *string `pulumi:"login"` + // The ID of the organization role. + RoleId *int `pulumi:"roleId"` +} + +type OrganizationRoleUserState struct { + // The login for the GitHub user account. + Login pulumi.StringPtrInput + // The ID of the organization role. + RoleId pulumi.IntPtrInput +} + +func (OrganizationRoleUserState) ElementType() reflect.Type { + return reflect.TypeOf((*organizationRoleUserState)(nil)).Elem() +} + +type organizationRoleUserArgs struct { + // The login for the GitHub user account. + Login string `pulumi:"login"` + // The ID of the organization role. + RoleId int `pulumi:"roleId"` +} + +// The set of arguments for constructing a OrganizationRoleUser resource. +type OrganizationRoleUserArgs struct { + // The login for the GitHub user account. + Login pulumi.StringInput + // The ID of the organization role. + RoleId pulumi.IntInput +} + +func (OrganizationRoleUserArgs) ElementType() reflect.Type { + return reflect.TypeOf((*organizationRoleUserArgs)(nil)).Elem() +} + +type OrganizationRoleUserInput interface { + pulumi.Input + + ToOrganizationRoleUserOutput() OrganizationRoleUserOutput + ToOrganizationRoleUserOutputWithContext(ctx context.Context) OrganizationRoleUserOutput +} + +func (*OrganizationRoleUser) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRoleUser)(nil)).Elem() +} + +func (i *OrganizationRoleUser) ToOrganizationRoleUserOutput() OrganizationRoleUserOutput { + return i.ToOrganizationRoleUserOutputWithContext(context.Background()) +} + +func (i *OrganizationRoleUser) ToOrganizationRoleUserOutputWithContext(ctx context.Context) OrganizationRoleUserOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRoleUserOutput) +} + +// OrganizationRoleUserArrayInput is an input type that accepts OrganizationRoleUserArray and OrganizationRoleUserArrayOutput values. +// You can construct a concrete instance of `OrganizationRoleUserArrayInput` via: +// +// OrganizationRoleUserArray{ OrganizationRoleUserArgs{...} } +type OrganizationRoleUserArrayInput interface { + pulumi.Input + + ToOrganizationRoleUserArrayOutput() OrganizationRoleUserArrayOutput + ToOrganizationRoleUserArrayOutputWithContext(context.Context) OrganizationRoleUserArrayOutput +} + +type OrganizationRoleUserArray []OrganizationRoleUserInput + +func (OrganizationRoleUserArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationRoleUser)(nil)).Elem() +} + +func (i OrganizationRoleUserArray) ToOrganizationRoleUserArrayOutput() OrganizationRoleUserArrayOutput { + return i.ToOrganizationRoleUserArrayOutputWithContext(context.Background()) +} + +func (i OrganizationRoleUserArray) ToOrganizationRoleUserArrayOutputWithContext(ctx context.Context) OrganizationRoleUserArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRoleUserArrayOutput) +} + +// OrganizationRoleUserMapInput is an input type that accepts OrganizationRoleUserMap and OrganizationRoleUserMapOutput values. +// You can construct a concrete instance of `OrganizationRoleUserMapInput` via: +// +// OrganizationRoleUserMap{ "key": OrganizationRoleUserArgs{...} } +type OrganizationRoleUserMapInput interface { + pulumi.Input + + ToOrganizationRoleUserMapOutput() OrganizationRoleUserMapOutput + ToOrganizationRoleUserMapOutputWithContext(context.Context) OrganizationRoleUserMapOutput +} + +type OrganizationRoleUserMap map[string]OrganizationRoleUserInput + +func (OrganizationRoleUserMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationRoleUser)(nil)).Elem() +} + +func (i OrganizationRoleUserMap) ToOrganizationRoleUserMapOutput() OrganizationRoleUserMapOutput { + return i.ToOrganizationRoleUserMapOutputWithContext(context.Background()) +} + +func (i OrganizationRoleUserMap) ToOrganizationRoleUserMapOutputWithContext(ctx context.Context) OrganizationRoleUserMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRoleUserMapOutput) +} + +type OrganizationRoleUserOutput struct{ *pulumi.OutputState } + +func (OrganizationRoleUserOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRoleUser)(nil)).Elem() +} + +func (o OrganizationRoleUserOutput) ToOrganizationRoleUserOutput() OrganizationRoleUserOutput { + return o +} + +func (o OrganizationRoleUserOutput) ToOrganizationRoleUserOutputWithContext(ctx context.Context) OrganizationRoleUserOutput { + return o +} + +// The login for the GitHub user account. +func (o OrganizationRoleUserOutput) Login() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationRoleUser) pulumi.StringOutput { return v.Login }).(pulumi.StringOutput) +} + +// The ID of the organization role. +func (o OrganizationRoleUserOutput) RoleId() pulumi.IntOutput { + return o.ApplyT(func(v *OrganizationRoleUser) pulumi.IntOutput { return v.RoleId }).(pulumi.IntOutput) +} + +type OrganizationRoleUserArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationRoleUserArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationRoleUser)(nil)).Elem() +} + +func (o OrganizationRoleUserArrayOutput) ToOrganizationRoleUserArrayOutput() OrganizationRoleUserArrayOutput { + return o +} + +func (o OrganizationRoleUserArrayOutput) ToOrganizationRoleUserArrayOutputWithContext(ctx context.Context) OrganizationRoleUserArrayOutput { + return o +} + +func (o OrganizationRoleUserArrayOutput) Index(i pulumi.IntInput) OrganizationRoleUserOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OrganizationRoleUser { + return vs[0].([]*OrganizationRoleUser)[vs[1].(int)] + }).(OrganizationRoleUserOutput) +} + +type OrganizationRoleUserMapOutput struct{ *pulumi.OutputState } + +func (OrganizationRoleUserMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationRoleUser)(nil)).Elem() +} + +func (o OrganizationRoleUserMapOutput) ToOrganizationRoleUserMapOutput() OrganizationRoleUserMapOutput { + return o +} + +func (o OrganizationRoleUserMapOutput) ToOrganizationRoleUserMapOutputWithContext(ctx context.Context) OrganizationRoleUserMapOutput { + return o +} + +func (o OrganizationRoleUserMapOutput) MapIndex(k pulumi.StringInput) OrganizationRoleUserOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *OrganizationRoleUser { + return vs[0].(map[string]*OrganizationRoleUser)[vs[1].(string)] + }).(OrganizationRoleUserOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRoleUserInput)(nil)).Elem(), &OrganizationRoleUser{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRoleUserArrayInput)(nil)).Elem(), OrganizationRoleUserArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRoleUserMapInput)(nil)).Elem(), OrganizationRoleUserMap{}) + pulumi.RegisterOutputType(OrganizationRoleUserOutput{}) + pulumi.RegisterOutputType(OrganizationRoleUserArrayOutput{}) + pulumi.RegisterOutputType(OrganizationRoleUserMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRuleset.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRuleset.go new file mode 100644 index 000000000..0050875dd --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationRuleset.go @@ -0,0 +1,504 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Creates a GitHub organization ruleset. +// +// This resource allows you to create and manage rulesets on the organization level. When applied, a new ruleset will be created. When destroyed, that ruleset will be removed. +// +// ## Example Usage +// +// ```go +// 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.NewOrganizationRuleset(ctx, "example", &github.OrganizationRulesetArgs{ +// Name: pulumi.String("example"), +// Target: pulumi.String("branch"), +// Enforcement: pulumi.String("active"), +// Conditions: &github.OrganizationRulesetConditionsArgs{ +// RefName: &github.OrganizationRulesetConditionsRefNameArgs{ +// Includes: pulumi.StringArray{ +// pulumi.String("~ALL"), +// }, +// Excludes: pulumi.StringArray{}, +// }, +// }, +// BypassActors: github.OrganizationRulesetBypassActorArray{ +// &github.OrganizationRulesetBypassActorArgs{ +// ActorId: pulumi.Int(13473), +// ActorType: pulumi.String("Integration"), +// BypassMode: pulumi.String("always"), +// }, +// }, +// Rules: &github.OrganizationRulesetRulesArgs{ +// Creation: pulumi.Bool(true), +// Update: pulumi.Bool(true), +// Deletion: pulumi.Bool(true), +// RequiredLinearHistory: pulumi.Bool(true), +// RequiredSignatures: pulumi.Bool(true), +// BranchNamePattern: &github.OrganizationRulesetRulesBranchNamePatternArgs{ +// Name: pulumi.String("example"), +// Negate: pulumi.Bool(false), +// Operator: pulumi.String("starts_with"), +// Pattern: pulumi.String("ex"), +// }, +// RequiredWorkflows: &github.OrganizationRulesetRulesRequiredWorkflowsArgs{ +// DoNotEnforceOnCreate: pulumi.Bool(true), +// RequiredWorkflows: github.OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArray{ +// &github.OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArgs{ +// RepositoryId: pulumi.Int(1234), +// Path: pulumi.String(".github/workflows/ci.yml"), +// Ref: pulumi.String("main"), +// }, +// }, +// }, +// RequiredCodeScanning: &github.OrganizationRulesetRulesRequiredCodeScanningArgs{ +// RequiredCodeScanningTools: github.OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArray{ +// &github.OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs{ +// AlertsThreshold: pulumi.String("errors"), +// SecurityAlertsThreshold: pulumi.String("high_or_higher"), +// Tool: pulumi.String("CodeQL"), +// }, +// }, +// }, +// }, +// }) +// if err != nil { +// return err +// } +// // Example with push ruleset +// // Note: Push targets must NOT have ref_name in conditions, only repository_name or repository_id +// _, err = github.NewOrganizationRuleset(ctx, "example_push", &github.OrganizationRulesetArgs{ +// Name: pulumi.String("example_push"), +// Target: pulumi.String("push"), +// Enforcement: pulumi.String("active"), +// Conditions: &github.OrganizationRulesetConditionsArgs{ +// RepositoryName: &github.OrganizationRulesetConditionsRepositoryNameArgs{ +// Includes: pulumi.StringArray{ +// pulumi.String("~ALL"), +// }, +// Excludes: pulumi.StringArray{}, +// }, +// }, +// Rules: &github.OrganizationRulesetRulesArgs{ +// FilePathRestriction: &github.OrganizationRulesetRulesFilePathRestrictionArgs{ +// RestrictedFilePaths: pulumi.StringArray{ +// pulumi.String(".github/workflows/*"), +// pulumi.String("*.env"), +// }, +// }, +// MaxFileSize: &github.OrganizationRulesetRulesMaxFileSizeArgs{ +// MaxFileSize: pulumi.Int(100), +// }, +// MaxFilePathLength: &github.OrganizationRulesetRulesMaxFilePathLengthArgs{ +// MaxFilePathLength: pulumi.Int(255), +// }, +// FileExtensionRestriction: &github.OrganizationRulesetRulesFileExtensionRestrictionArgs{ +// RestrictedFileExtensions: pulumi.StringArray{ +// pulumi.String("*.exe"), +// pulumi.String("*.dll"), +// pulumi.String("*.so"), +// }, +// }, +// }, +// }) +// if err != nil { +// return err +// } +// // Example with repository_property targeting +// _, err = github.NewOrganizationRuleset(ctx, "example_property", &github.OrganizationRulesetArgs{ +// Name: pulumi.String("example_property"), +// Target: pulumi.String("branch"), +// Enforcement: pulumi.String("active"), +// Conditions: &github.OrganizationRulesetConditionsArgs{ +// RefName: &github.OrganizationRulesetConditionsRefNameArgs{ +// Includes: pulumi.StringArray{ +// pulumi.String("~ALL"), +// }, +// Excludes: pulumi.StringArray{}, +// }, +// RepositoryProperty: &github.OrganizationRulesetConditionsRepositoryPropertyArgs{ +// Includes: github.OrganizationRulesetConditionsRepositoryPropertyIncludeArray{ +// &github.OrganizationRulesetConditionsRepositoryPropertyIncludeArgs{ +// Name: pulumi.String("environment"), +// PropertyValues: pulumi.StringArray{ +// pulumi.String("production"), +// pulumi.String("staging"), +// }, +// Source: pulumi.String("custom"), +// }, +// &github.OrganizationRulesetConditionsRepositoryPropertyIncludeArgs{ +// Name: pulumi.String("team"), +// PropertyValues: pulumi.StringArray{ +// pulumi.String("backend"), +// }, +// Source: pulumi.String("custom"), +// }, +// }, +// Excludes: github.OrganizationRulesetConditionsRepositoryPropertyExcludeArray{ +// &github.OrganizationRulesetConditionsRepositoryPropertyExcludeArgs{ +// Name: pulumi.String("archived"), +// PropertyValues: pulumi.StringArray{ +// pulumi.String("true"), +// }, +// Source: pulumi.String("system"), +// }, +// }, +// }, +// }, +// Rules: &github.OrganizationRulesetRulesArgs{ +// RequiredSignatures: pulumi.Bool(true), +// PullRequest: &github.OrganizationRulesetRulesPullRequestArgs{}, +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Organization Rulesets can be imported using the GitHub ruleset ID e.g. +// +// `$ terraform import github_organization_ruleset.example 12345` +type OrganizationRuleset struct { + pulumi.CustomResourceState + + // (Block List) The actors that can bypass the rules in this ruleset. (see below for nested schema) + BypassActors OrganizationRulesetBypassActorArrayOutput `pulumi:"bypassActors"` + // (Block List, Max: 1) Parameters for an organization ruleset condition. For `branch` and `tag` targets, `refName` is required alongside one of `repositoryName` or `repositoryId`. For `push` targets, `refName` must NOT be set - only `repositoryName` or `repositoryId` should be used. (see below for nested schema) + Conditions OrganizationRulesetConditionsPtrOutput `pulumi:"conditions"` + // (String) Possible values for Enforcement are `disabled`, `active`, `evaluate`. Note: `evaluate` is currently only supported for owners of type `organization`. + Enforcement pulumi.StringOutput `pulumi:"enforcement"` + // (String) + Etag pulumi.StringOutput `pulumi:"etag"` + // (String) The name of the ruleset. + Name pulumi.StringOutput `pulumi:"name"` + // (String) GraphQL global node id for use with v4 API. + NodeId pulumi.StringOutput `pulumi:"nodeId"` + // (Block List, Min: 1, Max: 1) Rules within the ruleset. (see below for nested schema) + Rules OrganizationRulesetRulesOutput `pulumi:"rules"` + // (Number) GitHub ID for the ruleset. + RulesetId pulumi.IntOutput `pulumi:"rulesetId"` + // (String) Possible values are `branch`, `tag` and `push`. + Target pulumi.StringOutput `pulumi:"target"` +} + +// NewOrganizationRuleset registers a new resource with the given unique name, arguments, and options. +func NewOrganizationRuleset(ctx *pulumi.Context, + name string, args *OrganizationRulesetArgs, opts ...pulumi.ResourceOption) (*OrganizationRuleset, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Enforcement == nil { + return nil, errors.New("invalid value for required argument 'Enforcement'") + } + if args.Rules == nil { + return nil, errors.New("invalid value for required argument 'Rules'") + } + if args.Target == nil { + return nil, errors.New("invalid value for required argument 'Target'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource OrganizationRuleset + err := ctx.RegisterResource("github:index/organizationRuleset:OrganizationRuleset", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetOrganizationRuleset gets an existing OrganizationRuleset 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 GetOrganizationRuleset(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *OrganizationRulesetState, opts ...pulumi.ResourceOption) (*OrganizationRuleset, error) { + var resource OrganizationRuleset + err := ctx.ReadResource("github:index/organizationRuleset:OrganizationRuleset", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering OrganizationRuleset resources. +type organizationRulesetState struct { + // (Block List) The actors that can bypass the rules in this ruleset. (see below for nested schema) + BypassActors []OrganizationRulesetBypassActor `pulumi:"bypassActors"` + // (Block List, Max: 1) Parameters for an organization ruleset condition. For `branch` and `tag` targets, `refName` is required alongside one of `repositoryName` or `repositoryId`. For `push` targets, `refName` must NOT be set - only `repositoryName` or `repositoryId` should be used. (see below for nested schema) + Conditions *OrganizationRulesetConditions `pulumi:"conditions"` + // (String) Possible values for Enforcement are `disabled`, `active`, `evaluate`. Note: `evaluate` is currently only supported for owners of type `organization`. + Enforcement *string `pulumi:"enforcement"` + // (String) + Etag *string `pulumi:"etag"` + // (String) The name of the ruleset. + Name *string `pulumi:"name"` + // (String) GraphQL global node id for use with v4 API. + NodeId *string `pulumi:"nodeId"` + // (Block List, Min: 1, Max: 1) Rules within the ruleset. (see below for nested schema) + Rules *OrganizationRulesetRules `pulumi:"rules"` + // (Number) GitHub ID for the ruleset. + RulesetId *int `pulumi:"rulesetId"` + // (String) Possible values are `branch`, `tag` and `push`. + Target *string `pulumi:"target"` +} + +type OrganizationRulesetState struct { + // (Block List) The actors that can bypass the rules in this ruleset. (see below for nested schema) + BypassActors OrganizationRulesetBypassActorArrayInput + // (Block List, Max: 1) Parameters for an organization ruleset condition. For `branch` and `tag` targets, `refName` is required alongside one of `repositoryName` or `repositoryId`. For `push` targets, `refName` must NOT be set - only `repositoryName` or `repositoryId` should be used. (see below for nested schema) + Conditions OrganizationRulesetConditionsPtrInput + // (String) Possible values for Enforcement are `disabled`, `active`, `evaluate`. Note: `evaluate` is currently only supported for owners of type `organization`. + Enforcement pulumi.StringPtrInput + // (String) + Etag pulumi.StringPtrInput + // (String) The name of the ruleset. + Name pulumi.StringPtrInput + // (String) GraphQL global node id for use with v4 API. + NodeId pulumi.StringPtrInput + // (Block List, Min: 1, Max: 1) Rules within the ruleset. (see below for nested schema) + Rules OrganizationRulesetRulesPtrInput + // (Number) GitHub ID for the ruleset. + RulesetId pulumi.IntPtrInput + // (String) Possible values are `branch`, `tag` and `push`. + Target pulumi.StringPtrInput +} + +func (OrganizationRulesetState) ElementType() reflect.Type { + return reflect.TypeOf((*organizationRulesetState)(nil)).Elem() +} + +type organizationRulesetArgs struct { + // (Block List) The actors that can bypass the rules in this ruleset. (see below for nested schema) + BypassActors []OrganizationRulesetBypassActor `pulumi:"bypassActors"` + // (Block List, Max: 1) Parameters for an organization ruleset condition. For `branch` and `tag` targets, `refName` is required alongside one of `repositoryName` or `repositoryId`. For `push` targets, `refName` must NOT be set - only `repositoryName` or `repositoryId` should be used. (see below for nested schema) + Conditions *OrganizationRulesetConditions `pulumi:"conditions"` + // (String) Possible values for Enforcement are `disabled`, `active`, `evaluate`. Note: `evaluate` is currently only supported for owners of type `organization`. + Enforcement string `pulumi:"enforcement"` + // (String) The name of the ruleset. + Name *string `pulumi:"name"` + // (Block List, Min: 1, Max: 1) Rules within the ruleset. (see below for nested schema) + Rules OrganizationRulesetRules `pulumi:"rules"` + // (String) Possible values are `branch`, `tag` and `push`. + Target string `pulumi:"target"` +} + +// The set of arguments for constructing a OrganizationRuleset resource. +type OrganizationRulesetArgs struct { + // (Block List) The actors that can bypass the rules in this ruleset. (see below for nested schema) + BypassActors OrganizationRulesetBypassActorArrayInput + // (Block List, Max: 1) Parameters for an organization ruleset condition. For `branch` and `tag` targets, `refName` is required alongside one of `repositoryName` or `repositoryId`. For `push` targets, `refName` must NOT be set - only `repositoryName` or `repositoryId` should be used. (see below for nested schema) + Conditions OrganizationRulesetConditionsPtrInput + // (String) Possible values for Enforcement are `disabled`, `active`, `evaluate`. Note: `evaluate` is currently only supported for owners of type `organization`. + Enforcement pulumi.StringInput + // (String) The name of the ruleset. + Name pulumi.StringPtrInput + // (Block List, Min: 1, Max: 1) Rules within the ruleset. (see below for nested schema) + Rules OrganizationRulesetRulesInput + // (String) Possible values are `branch`, `tag` and `push`. + Target pulumi.StringInput +} + +func (OrganizationRulesetArgs) ElementType() reflect.Type { + return reflect.TypeOf((*organizationRulesetArgs)(nil)).Elem() +} + +type OrganizationRulesetInput interface { + pulumi.Input + + ToOrganizationRulesetOutput() OrganizationRulesetOutput + ToOrganizationRulesetOutputWithContext(ctx context.Context) OrganizationRulesetOutput +} + +func (*OrganizationRuleset) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRuleset)(nil)).Elem() +} + +func (i *OrganizationRuleset) ToOrganizationRulesetOutput() OrganizationRulesetOutput { + return i.ToOrganizationRulesetOutputWithContext(context.Background()) +} + +func (i *OrganizationRuleset) ToOrganizationRulesetOutputWithContext(ctx context.Context) OrganizationRulesetOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetOutput) +} + +// OrganizationRulesetArrayInput is an input type that accepts OrganizationRulesetArray and OrganizationRulesetArrayOutput values. +// You can construct a concrete instance of `OrganizationRulesetArrayInput` via: +// +// OrganizationRulesetArray{ OrganizationRulesetArgs{...} } +type OrganizationRulesetArrayInput interface { + pulumi.Input + + ToOrganizationRulesetArrayOutput() OrganizationRulesetArrayOutput + ToOrganizationRulesetArrayOutputWithContext(context.Context) OrganizationRulesetArrayOutput +} + +type OrganizationRulesetArray []OrganizationRulesetInput + +func (OrganizationRulesetArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationRuleset)(nil)).Elem() +} + +func (i OrganizationRulesetArray) ToOrganizationRulesetArrayOutput() OrganizationRulesetArrayOutput { + return i.ToOrganizationRulesetArrayOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetArray) ToOrganizationRulesetArrayOutputWithContext(ctx context.Context) OrganizationRulesetArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetArrayOutput) +} + +// OrganizationRulesetMapInput is an input type that accepts OrganizationRulesetMap and OrganizationRulesetMapOutput values. +// You can construct a concrete instance of `OrganizationRulesetMapInput` via: +// +// OrganizationRulesetMap{ "key": OrganizationRulesetArgs{...} } +type OrganizationRulesetMapInput interface { + pulumi.Input + + ToOrganizationRulesetMapOutput() OrganizationRulesetMapOutput + ToOrganizationRulesetMapOutputWithContext(context.Context) OrganizationRulesetMapOutput +} + +type OrganizationRulesetMap map[string]OrganizationRulesetInput + +func (OrganizationRulesetMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationRuleset)(nil)).Elem() +} + +func (i OrganizationRulesetMap) ToOrganizationRulesetMapOutput() OrganizationRulesetMapOutput { + return i.ToOrganizationRulesetMapOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetMap) ToOrganizationRulesetMapOutputWithContext(ctx context.Context) OrganizationRulesetMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetMapOutput) +} + +type OrganizationRulesetOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRuleset)(nil)).Elem() +} + +func (o OrganizationRulesetOutput) ToOrganizationRulesetOutput() OrganizationRulesetOutput { + return o +} + +func (o OrganizationRulesetOutput) ToOrganizationRulesetOutputWithContext(ctx context.Context) OrganizationRulesetOutput { + return o +} + +// (Block List) The actors that can bypass the rules in this ruleset. (see below for nested schema) +func (o OrganizationRulesetOutput) BypassActors() OrganizationRulesetBypassActorArrayOutput { + return o.ApplyT(func(v *OrganizationRuleset) OrganizationRulesetBypassActorArrayOutput { return v.BypassActors }).(OrganizationRulesetBypassActorArrayOutput) +} + +// (Block List, Max: 1) Parameters for an organization ruleset condition. For `branch` and `tag` targets, `refName` is required alongside one of `repositoryName` or `repositoryId`. For `push` targets, `refName` must NOT be set - only `repositoryName` or `repositoryId` should be used. (see below for nested schema) +func (o OrganizationRulesetOutput) Conditions() OrganizationRulesetConditionsPtrOutput { + return o.ApplyT(func(v *OrganizationRuleset) OrganizationRulesetConditionsPtrOutput { return v.Conditions }).(OrganizationRulesetConditionsPtrOutput) +} + +// (String) Possible values for Enforcement are `disabled`, `active`, `evaluate`. Note: `evaluate` is currently only supported for owners of type `organization`. +func (o OrganizationRulesetOutput) Enforcement() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationRuleset) pulumi.StringOutput { return v.Enforcement }).(pulumi.StringOutput) +} + +// (String) +func (o OrganizationRulesetOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationRuleset) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// (String) The name of the ruleset. +func (o OrganizationRulesetOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationRuleset) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// (String) GraphQL global node id for use with v4 API. +func (o OrganizationRulesetOutput) NodeId() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationRuleset) pulumi.StringOutput { return v.NodeId }).(pulumi.StringOutput) +} + +// (Block List, Min: 1, Max: 1) Rules within the ruleset. (see below for nested schema) +func (o OrganizationRulesetOutput) Rules() OrganizationRulesetRulesOutput { + return o.ApplyT(func(v *OrganizationRuleset) OrganizationRulesetRulesOutput { return v.Rules }).(OrganizationRulesetRulesOutput) +} + +// (Number) GitHub ID for the ruleset. +func (o OrganizationRulesetOutput) RulesetId() pulumi.IntOutput { + return o.ApplyT(func(v *OrganizationRuleset) pulumi.IntOutput { return v.RulesetId }).(pulumi.IntOutput) +} + +// (String) Possible values are `branch`, `tag` and `push`. +func (o OrganizationRulesetOutput) Target() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationRuleset) pulumi.StringOutput { return v.Target }).(pulumi.StringOutput) +} + +type OrganizationRulesetArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationRuleset)(nil)).Elem() +} + +func (o OrganizationRulesetArrayOutput) ToOrganizationRulesetArrayOutput() OrganizationRulesetArrayOutput { + return o +} + +func (o OrganizationRulesetArrayOutput) ToOrganizationRulesetArrayOutputWithContext(ctx context.Context) OrganizationRulesetArrayOutput { + return o +} + +func (o OrganizationRulesetArrayOutput) Index(i pulumi.IntInput) OrganizationRulesetOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OrganizationRuleset { + return vs[0].([]*OrganizationRuleset)[vs[1].(int)] + }).(OrganizationRulesetOutput) +} + +type OrganizationRulesetMapOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationRuleset)(nil)).Elem() +} + +func (o OrganizationRulesetMapOutput) ToOrganizationRulesetMapOutput() OrganizationRulesetMapOutput { + return o +} + +func (o OrganizationRulesetMapOutput) ToOrganizationRulesetMapOutputWithContext(ctx context.Context) OrganizationRulesetMapOutput { + return o +} + +func (o OrganizationRulesetMapOutput) MapIndex(k pulumi.StringInput) OrganizationRulesetOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *OrganizationRuleset { + return vs[0].(map[string]*OrganizationRuleset)[vs[1].(string)] + }).(OrganizationRulesetOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetInput)(nil)).Elem(), &OrganizationRuleset{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetArrayInput)(nil)).Elem(), OrganizationRulesetArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetMapInput)(nil)).Elem(), OrganizationRulesetMap{}) + pulumi.RegisterOutputType(OrganizationRulesetOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetArrayOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationSecurityManager.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationSecurityManager.go new file mode 100644 index 000000000..ca8c68ffd --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationSecurityManager.go @@ -0,0 +1,256 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// > **Note:** This resource is deprecated, please use the `OrganizationRoleTeam` resource instead. +// +// ## Example Usage +// +// ```go +// 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 { +// 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.NewOrganizationSecurityManager(ctx, "some_team", &github.OrganizationSecurityManagerArgs{ +// TeamSlug: someTeam.Slug, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Security Manager Teams can be imported using the GitHub team ID e.g. +type OrganizationSecurityManager struct { + pulumi.CustomResourceState + + // The slug of the team to manage. + TeamSlug pulumi.StringOutput `pulumi:"teamSlug"` +} + +// NewOrganizationSecurityManager registers a new resource with the given unique name, arguments, and options. +func NewOrganizationSecurityManager(ctx *pulumi.Context, + name string, args *OrganizationSecurityManagerArgs, opts ...pulumi.ResourceOption) (*OrganizationSecurityManager, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.TeamSlug == nil { + return nil, errors.New("invalid value for required argument 'TeamSlug'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource OrganizationSecurityManager + err := ctx.RegisterResource("github:index/organizationSecurityManager:OrganizationSecurityManager", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetOrganizationSecurityManager gets an existing OrganizationSecurityManager 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 GetOrganizationSecurityManager(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *OrganizationSecurityManagerState, opts ...pulumi.ResourceOption) (*OrganizationSecurityManager, error) { + var resource OrganizationSecurityManager + err := ctx.ReadResource("github:index/organizationSecurityManager:OrganizationSecurityManager", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering OrganizationSecurityManager resources. +type organizationSecurityManagerState struct { + // The slug of the team to manage. + TeamSlug *string `pulumi:"teamSlug"` +} + +type OrganizationSecurityManagerState struct { + // The slug of the team to manage. + TeamSlug pulumi.StringPtrInput +} + +func (OrganizationSecurityManagerState) ElementType() reflect.Type { + return reflect.TypeOf((*organizationSecurityManagerState)(nil)).Elem() +} + +type organizationSecurityManagerArgs struct { + // The slug of the team to manage. + TeamSlug string `pulumi:"teamSlug"` +} + +// The set of arguments for constructing a OrganizationSecurityManager resource. +type OrganizationSecurityManagerArgs struct { + // The slug of the team to manage. + TeamSlug pulumi.StringInput +} + +func (OrganizationSecurityManagerArgs) ElementType() reflect.Type { + return reflect.TypeOf((*organizationSecurityManagerArgs)(nil)).Elem() +} + +type OrganizationSecurityManagerInput interface { + pulumi.Input + + ToOrganizationSecurityManagerOutput() OrganizationSecurityManagerOutput + ToOrganizationSecurityManagerOutputWithContext(ctx context.Context) OrganizationSecurityManagerOutput +} + +func (*OrganizationSecurityManager) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationSecurityManager)(nil)).Elem() +} + +func (i *OrganizationSecurityManager) ToOrganizationSecurityManagerOutput() OrganizationSecurityManagerOutput { + return i.ToOrganizationSecurityManagerOutputWithContext(context.Background()) +} + +func (i *OrganizationSecurityManager) ToOrganizationSecurityManagerOutputWithContext(ctx context.Context) OrganizationSecurityManagerOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationSecurityManagerOutput) +} + +// OrganizationSecurityManagerArrayInput is an input type that accepts OrganizationSecurityManagerArray and OrganizationSecurityManagerArrayOutput values. +// You can construct a concrete instance of `OrganizationSecurityManagerArrayInput` via: +// +// OrganizationSecurityManagerArray{ OrganizationSecurityManagerArgs{...} } +type OrganizationSecurityManagerArrayInput interface { + pulumi.Input + + ToOrganizationSecurityManagerArrayOutput() OrganizationSecurityManagerArrayOutput + ToOrganizationSecurityManagerArrayOutputWithContext(context.Context) OrganizationSecurityManagerArrayOutput +} + +type OrganizationSecurityManagerArray []OrganizationSecurityManagerInput + +func (OrganizationSecurityManagerArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationSecurityManager)(nil)).Elem() +} + +func (i OrganizationSecurityManagerArray) ToOrganizationSecurityManagerArrayOutput() OrganizationSecurityManagerArrayOutput { + return i.ToOrganizationSecurityManagerArrayOutputWithContext(context.Background()) +} + +func (i OrganizationSecurityManagerArray) ToOrganizationSecurityManagerArrayOutputWithContext(ctx context.Context) OrganizationSecurityManagerArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationSecurityManagerArrayOutput) +} + +// OrganizationSecurityManagerMapInput is an input type that accepts OrganizationSecurityManagerMap and OrganizationSecurityManagerMapOutput values. +// You can construct a concrete instance of `OrganizationSecurityManagerMapInput` via: +// +// OrganizationSecurityManagerMap{ "key": OrganizationSecurityManagerArgs{...} } +type OrganizationSecurityManagerMapInput interface { + pulumi.Input + + ToOrganizationSecurityManagerMapOutput() OrganizationSecurityManagerMapOutput + ToOrganizationSecurityManagerMapOutputWithContext(context.Context) OrganizationSecurityManagerMapOutput +} + +type OrganizationSecurityManagerMap map[string]OrganizationSecurityManagerInput + +func (OrganizationSecurityManagerMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationSecurityManager)(nil)).Elem() +} + +func (i OrganizationSecurityManagerMap) ToOrganizationSecurityManagerMapOutput() OrganizationSecurityManagerMapOutput { + return i.ToOrganizationSecurityManagerMapOutputWithContext(context.Background()) +} + +func (i OrganizationSecurityManagerMap) ToOrganizationSecurityManagerMapOutputWithContext(ctx context.Context) OrganizationSecurityManagerMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationSecurityManagerMapOutput) +} + +type OrganizationSecurityManagerOutput struct{ *pulumi.OutputState } + +func (OrganizationSecurityManagerOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationSecurityManager)(nil)).Elem() +} + +func (o OrganizationSecurityManagerOutput) ToOrganizationSecurityManagerOutput() OrganizationSecurityManagerOutput { + return o +} + +func (o OrganizationSecurityManagerOutput) ToOrganizationSecurityManagerOutputWithContext(ctx context.Context) OrganizationSecurityManagerOutput { + return o +} + +// The slug of the team to manage. +func (o OrganizationSecurityManagerOutput) TeamSlug() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationSecurityManager) pulumi.StringOutput { return v.TeamSlug }).(pulumi.StringOutput) +} + +type OrganizationSecurityManagerArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationSecurityManagerArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationSecurityManager)(nil)).Elem() +} + +func (o OrganizationSecurityManagerArrayOutput) ToOrganizationSecurityManagerArrayOutput() OrganizationSecurityManagerArrayOutput { + return o +} + +func (o OrganizationSecurityManagerArrayOutput) ToOrganizationSecurityManagerArrayOutputWithContext(ctx context.Context) OrganizationSecurityManagerArrayOutput { + return o +} + +func (o OrganizationSecurityManagerArrayOutput) Index(i pulumi.IntInput) OrganizationSecurityManagerOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OrganizationSecurityManager { + return vs[0].([]*OrganizationSecurityManager)[vs[1].(int)] + }).(OrganizationSecurityManagerOutput) +} + +type OrganizationSecurityManagerMapOutput struct{ *pulumi.OutputState } + +func (OrganizationSecurityManagerMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationSecurityManager)(nil)).Elem() +} + +func (o OrganizationSecurityManagerMapOutput) ToOrganizationSecurityManagerMapOutput() OrganizationSecurityManagerMapOutput { + return o +} + +func (o OrganizationSecurityManagerMapOutput) ToOrganizationSecurityManagerMapOutputWithContext(ctx context.Context) OrganizationSecurityManagerMapOutput { + return o +} + +func (o OrganizationSecurityManagerMapOutput) MapIndex(k pulumi.StringInput) OrganizationSecurityManagerOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *OrganizationSecurityManager { + return vs[0].(map[string]*OrganizationSecurityManager)[vs[1].(string)] + }).(OrganizationSecurityManagerOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationSecurityManagerInput)(nil)).Elem(), &OrganizationSecurityManager{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationSecurityManagerArrayInput)(nil)).Elem(), OrganizationSecurityManagerArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationSecurityManagerMapInput)(nil)).Elem(), OrganizationSecurityManagerMap{}) + pulumi.RegisterOutputType(OrganizationSecurityManagerOutput{}) + pulumi.RegisterOutputType(OrganizationSecurityManagerArrayOutput{}) + pulumi.RegisterOutputType(OrganizationSecurityManagerMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationSettings.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationSettings.go new file mode 100644 index 000000000..f69f82086 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationSettings.go @@ -0,0 +1,658 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage settings for a GitHub Organization. +// +// ## Example Usage +// +// ```go +// 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 +// }) +// } +// +// ``` +// +// ## 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](https://docs.github.com/en/rest/orgs/orgs#get-an-organization) API. +// +// ```sh +// $ pulumi import github:index/organizationSettings:OrganizationSettings test 123456789 +// ``` +type OrganizationSettings struct { + pulumi.CustomResourceState + + // Whether or not advanced security is enabled for new repositories. Defaults to `false`. + AdvancedSecurityEnabledForNewRepositories pulumi.BoolPtrOutput `pulumi:"advancedSecurityEnabledForNewRepositories"` + // The billing email address for the organization. + BillingEmail pulumi.StringOutput `pulumi:"billingEmail"` + // The blog URL for the organization. + Blog pulumi.StringPtrOutput `pulumi:"blog"` + // The company name for the organization. + Company pulumi.StringPtrOutput `pulumi:"company"` + // The default permission for organization members to create new repositories. Can be one of `read`, `write`, `admin`, or `none`. Defaults to `read`. + DefaultRepositoryPermission pulumi.StringPtrOutput `pulumi:"defaultRepositoryPermission"` + // Whether or not dependabot alerts are enabled for new repositories. Defaults to `false`. + DependabotAlertsEnabledForNewRepositories pulumi.BoolPtrOutput `pulumi:"dependabotAlertsEnabledForNewRepositories"` + // Whether or not dependabot security updates are enabled for new repositories. Defaults to `false`. + DependabotSecurityUpdatesEnabledForNewRepositories pulumi.BoolPtrOutput `pulumi:"dependabotSecurityUpdatesEnabledForNewRepositories"` + // Whether or not dependency graph is enabled for new repositories. Defaults to `false`. + DependencyGraphEnabledForNewRepositories pulumi.BoolPtrOutput `pulumi:"dependencyGraphEnabledForNewRepositories"` + // The description for the organization. + Description pulumi.StringPtrOutput `pulumi:"description"` + // The email address for the organization. + Email pulumi.StringPtrOutput `pulumi:"email"` + // Whether or not organization projects are enabled for the organization. + HasOrganizationProjects pulumi.BoolPtrOutput `pulumi:"hasOrganizationProjects"` + // Whether or not repository projects are enabled for the organization. + HasRepositoryProjects pulumi.BoolPtrOutput `pulumi:"hasRepositoryProjects"` + // The location for the organization. + Location pulumi.StringPtrOutput `pulumi:"location"` + // Whether or not organization members can create new internal repositories. For Enterprise Organizations only. + MembersCanCreateInternalRepositories pulumi.BoolPtrOutput `pulumi:"membersCanCreateInternalRepositories"` + // Whether or not organization members can create new pages. Defaults to `true`. + MembersCanCreatePages pulumi.BoolPtrOutput `pulumi:"membersCanCreatePages"` + // Whether or not organization members can create new private pages. Defaults to `true`. + MembersCanCreatePrivatePages pulumi.BoolPtrOutput `pulumi:"membersCanCreatePrivatePages"` + // Whether or not organization members can create new private repositories. Defaults to `true`. + MembersCanCreatePrivateRepositories pulumi.BoolPtrOutput `pulumi:"membersCanCreatePrivateRepositories"` + // Whether or not organization members can create new public pages. Defaults to `true`. + MembersCanCreatePublicPages pulumi.BoolPtrOutput `pulumi:"membersCanCreatePublicPages"` + // Whether or not organization members can create new public repositories. Defaults to `true`. + MembersCanCreatePublicRepositories pulumi.BoolPtrOutput `pulumi:"membersCanCreatePublicRepositories"` + // Whether or not organization members can create new repositories. Defaults to `true`. + MembersCanCreateRepositories pulumi.BoolPtrOutput `pulumi:"membersCanCreateRepositories"` + // Whether or not organization members can fork private repositories. Defaults to `false`. + MembersCanForkPrivateRepositories pulumi.BoolPtrOutput `pulumi:"membersCanForkPrivateRepositories"` + // The name for the organization. + Name pulumi.StringOutput `pulumi:"name"` + // Whether or not secret scanning is enabled for new repositories. Defaults to `false`. + SecretScanningEnabledForNewRepositories pulumi.BoolPtrOutput `pulumi:"secretScanningEnabledForNewRepositories"` + // Whether or not secret scanning push protection is enabled for new repositories. Defaults to `false`. + SecretScanningPushProtectionEnabledForNewRepositories pulumi.BoolPtrOutput `pulumi:"secretScanningPushProtectionEnabledForNewRepositories"` + // The Twitter username for the organization. + TwitterUsername pulumi.StringPtrOutput `pulumi:"twitterUsername"` + // Whether or not commit signatures are required for commits to the organization. Defaults to `false`. + WebCommitSignoffRequired pulumi.BoolPtrOutput `pulumi:"webCommitSignoffRequired"` +} + +// NewOrganizationSettings registers a new resource with the given unique name, arguments, and options. +func NewOrganizationSettings(ctx *pulumi.Context, + name string, args *OrganizationSettingsArgs, opts ...pulumi.ResourceOption) (*OrganizationSettings, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.BillingEmail == nil { + return nil, errors.New("invalid value for required argument 'BillingEmail'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource OrganizationSettings + err := ctx.RegisterResource("github:index/organizationSettings:OrganizationSettings", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetOrganizationSettings gets an existing OrganizationSettings 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 GetOrganizationSettings(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *OrganizationSettingsState, opts ...pulumi.ResourceOption) (*OrganizationSettings, error) { + var resource OrganizationSettings + err := ctx.ReadResource("github:index/organizationSettings:OrganizationSettings", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering OrganizationSettings resources. +type organizationSettingsState struct { + // Whether or not advanced security is enabled for new repositories. Defaults to `false`. + AdvancedSecurityEnabledForNewRepositories *bool `pulumi:"advancedSecurityEnabledForNewRepositories"` + // The billing email address for the organization. + BillingEmail *string `pulumi:"billingEmail"` + // The blog URL for the organization. + Blog *string `pulumi:"blog"` + // The company name for the organization. + Company *string `pulumi:"company"` + // The default permission for organization members to create new repositories. Can be one of `read`, `write`, `admin`, or `none`. Defaults to `read`. + DefaultRepositoryPermission *string `pulumi:"defaultRepositoryPermission"` + // Whether or not dependabot alerts are enabled for new repositories. Defaults to `false`. + DependabotAlertsEnabledForNewRepositories *bool `pulumi:"dependabotAlertsEnabledForNewRepositories"` + // Whether or not dependabot security updates are enabled for new repositories. Defaults to `false`. + DependabotSecurityUpdatesEnabledForNewRepositories *bool `pulumi:"dependabotSecurityUpdatesEnabledForNewRepositories"` + // Whether or not dependency graph is enabled for new repositories. Defaults to `false`. + DependencyGraphEnabledForNewRepositories *bool `pulumi:"dependencyGraphEnabledForNewRepositories"` + // The description for the organization. + Description *string `pulumi:"description"` + // The email address for the organization. + Email *string `pulumi:"email"` + // Whether or not organization projects are enabled for the organization. + HasOrganizationProjects *bool `pulumi:"hasOrganizationProjects"` + // Whether or not repository projects are enabled for the organization. + HasRepositoryProjects *bool `pulumi:"hasRepositoryProjects"` + // The location for the organization. + Location *string `pulumi:"location"` + // Whether or not organization members can create new internal repositories. For Enterprise Organizations only. + MembersCanCreateInternalRepositories *bool `pulumi:"membersCanCreateInternalRepositories"` + // Whether or not organization members can create new pages. Defaults to `true`. + MembersCanCreatePages *bool `pulumi:"membersCanCreatePages"` + // Whether or not organization members can create new private pages. Defaults to `true`. + MembersCanCreatePrivatePages *bool `pulumi:"membersCanCreatePrivatePages"` + // Whether or not organization members can create new private repositories. Defaults to `true`. + MembersCanCreatePrivateRepositories *bool `pulumi:"membersCanCreatePrivateRepositories"` + // Whether or not organization members can create new public pages. Defaults to `true`. + MembersCanCreatePublicPages *bool `pulumi:"membersCanCreatePublicPages"` + // Whether or not organization members can create new public repositories. Defaults to `true`. + MembersCanCreatePublicRepositories *bool `pulumi:"membersCanCreatePublicRepositories"` + // Whether or not organization members can create new repositories. Defaults to `true`. + MembersCanCreateRepositories *bool `pulumi:"membersCanCreateRepositories"` + // Whether or not organization members can fork private repositories. Defaults to `false`. + MembersCanForkPrivateRepositories *bool `pulumi:"membersCanForkPrivateRepositories"` + // The name for the organization. + Name *string `pulumi:"name"` + // Whether or not secret scanning is enabled for new repositories. Defaults to `false`. + SecretScanningEnabledForNewRepositories *bool `pulumi:"secretScanningEnabledForNewRepositories"` + // Whether or not secret scanning push protection is enabled for new repositories. Defaults to `false`. + SecretScanningPushProtectionEnabledForNewRepositories *bool `pulumi:"secretScanningPushProtectionEnabledForNewRepositories"` + // The Twitter username for the organization. + TwitterUsername *string `pulumi:"twitterUsername"` + // Whether or not commit signatures are required for commits to the organization. Defaults to `false`. + WebCommitSignoffRequired *bool `pulumi:"webCommitSignoffRequired"` +} + +type OrganizationSettingsState struct { + // Whether or not advanced security is enabled for new repositories. Defaults to `false`. + AdvancedSecurityEnabledForNewRepositories pulumi.BoolPtrInput + // The billing email address for the organization. + BillingEmail pulumi.StringPtrInput + // The blog URL for the organization. + Blog pulumi.StringPtrInput + // The company name for the organization. + Company pulumi.StringPtrInput + // The default permission for organization members to create new repositories. Can be one of `read`, `write`, `admin`, or `none`. Defaults to `read`. + DefaultRepositoryPermission pulumi.StringPtrInput + // Whether or not dependabot alerts are enabled for new repositories. Defaults to `false`. + DependabotAlertsEnabledForNewRepositories pulumi.BoolPtrInput + // Whether or not dependabot security updates are enabled for new repositories. Defaults to `false`. + DependabotSecurityUpdatesEnabledForNewRepositories pulumi.BoolPtrInput + // Whether or not dependency graph is enabled for new repositories. Defaults to `false`. + DependencyGraphEnabledForNewRepositories pulumi.BoolPtrInput + // The description for the organization. + Description pulumi.StringPtrInput + // The email address for the organization. + Email pulumi.StringPtrInput + // Whether or not organization projects are enabled for the organization. + HasOrganizationProjects pulumi.BoolPtrInput + // Whether or not repository projects are enabled for the organization. + HasRepositoryProjects pulumi.BoolPtrInput + // The location for the organization. + Location pulumi.StringPtrInput + // Whether or not organization members can create new internal repositories. For Enterprise Organizations only. + MembersCanCreateInternalRepositories pulumi.BoolPtrInput + // Whether or not organization members can create new pages. Defaults to `true`. + MembersCanCreatePages pulumi.BoolPtrInput + // Whether or not organization members can create new private pages. Defaults to `true`. + MembersCanCreatePrivatePages pulumi.BoolPtrInput + // Whether or not organization members can create new private repositories. Defaults to `true`. + MembersCanCreatePrivateRepositories pulumi.BoolPtrInput + // Whether or not organization members can create new public pages. Defaults to `true`. + MembersCanCreatePublicPages pulumi.BoolPtrInput + // Whether or not organization members can create new public repositories. Defaults to `true`. + MembersCanCreatePublicRepositories pulumi.BoolPtrInput + // Whether or not organization members can create new repositories. Defaults to `true`. + MembersCanCreateRepositories pulumi.BoolPtrInput + // Whether or not organization members can fork private repositories. Defaults to `false`. + MembersCanForkPrivateRepositories pulumi.BoolPtrInput + // The name for the organization. + Name pulumi.StringPtrInput + // Whether or not secret scanning is enabled for new repositories. Defaults to `false`. + SecretScanningEnabledForNewRepositories pulumi.BoolPtrInput + // Whether or not secret scanning push protection is enabled for new repositories. Defaults to `false`. + SecretScanningPushProtectionEnabledForNewRepositories pulumi.BoolPtrInput + // The Twitter username for the organization. + TwitterUsername pulumi.StringPtrInput + // Whether or not commit signatures are required for commits to the organization. Defaults to `false`. + WebCommitSignoffRequired pulumi.BoolPtrInput +} + +func (OrganizationSettingsState) ElementType() reflect.Type { + return reflect.TypeOf((*organizationSettingsState)(nil)).Elem() +} + +type organizationSettingsArgs struct { + // Whether or not advanced security is enabled for new repositories. Defaults to `false`. + AdvancedSecurityEnabledForNewRepositories *bool `pulumi:"advancedSecurityEnabledForNewRepositories"` + // The billing email address for the organization. + BillingEmail string `pulumi:"billingEmail"` + // The blog URL for the organization. + Blog *string `pulumi:"blog"` + // The company name for the organization. + Company *string `pulumi:"company"` + // The default permission for organization members to create new repositories. Can be one of `read`, `write`, `admin`, or `none`. Defaults to `read`. + DefaultRepositoryPermission *string `pulumi:"defaultRepositoryPermission"` + // Whether or not dependabot alerts are enabled for new repositories. Defaults to `false`. + DependabotAlertsEnabledForNewRepositories *bool `pulumi:"dependabotAlertsEnabledForNewRepositories"` + // Whether or not dependabot security updates are enabled for new repositories. Defaults to `false`. + DependabotSecurityUpdatesEnabledForNewRepositories *bool `pulumi:"dependabotSecurityUpdatesEnabledForNewRepositories"` + // Whether or not dependency graph is enabled for new repositories. Defaults to `false`. + DependencyGraphEnabledForNewRepositories *bool `pulumi:"dependencyGraphEnabledForNewRepositories"` + // The description for the organization. + Description *string `pulumi:"description"` + // The email address for the organization. + Email *string `pulumi:"email"` + // Whether or not organization projects are enabled for the organization. + HasOrganizationProjects *bool `pulumi:"hasOrganizationProjects"` + // Whether or not repository projects are enabled for the organization. + HasRepositoryProjects *bool `pulumi:"hasRepositoryProjects"` + // The location for the organization. + Location *string `pulumi:"location"` + // Whether or not organization members can create new internal repositories. For Enterprise Organizations only. + MembersCanCreateInternalRepositories *bool `pulumi:"membersCanCreateInternalRepositories"` + // Whether or not organization members can create new pages. Defaults to `true`. + MembersCanCreatePages *bool `pulumi:"membersCanCreatePages"` + // Whether or not organization members can create new private pages. Defaults to `true`. + MembersCanCreatePrivatePages *bool `pulumi:"membersCanCreatePrivatePages"` + // Whether or not organization members can create new private repositories. Defaults to `true`. + MembersCanCreatePrivateRepositories *bool `pulumi:"membersCanCreatePrivateRepositories"` + // Whether or not organization members can create new public pages. Defaults to `true`. + MembersCanCreatePublicPages *bool `pulumi:"membersCanCreatePublicPages"` + // Whether or not organization members can create new public repositories. Defaults to `true`. + MembersCanCreatePublicRepositories *bool `pulumi:"membersCanCreatePublicRepositories"` + // Whether or not organization members can create new repositories. Defaults to `true`. + MembersCanCreateRepositories *bool `pulumi:"membersCanCreateRepositories"` + // Whether or not organization members can fork private repositories. Defaults to `false`. + MembersCanForkPrivateRepositories *bool `pulumi:"membersCanForkPrivateRepositories"` + // The name for the organization. + Name *string `pulumi:"name"` + // Whether or not secret scanning is enabled for new repositories. Defaults to `false`. + SecretScanningEnabledForNewRepositories *bool `pulumi:"secretScanningEnabledForNewRepositories"` + // Whether or not secret scanning push protection is enabled for new repositories. Defaults to `false`. + SecretScanningPushProtectionEnabledForNewRepositories *bool `pulumi:"secretScanningPushProtectionEnabledForNewRepositories"` + // The Twitter username for the organization. + TwitterUsername *string `pulumi:"twitterUsername"` + // Whether or not commit signatures are required for commits to the organization. Defaults to `false`. + WebCommitSignoffRequired *bool `pulumi:"webCommitSignoffRequired"` +} + +// The set of arguments for constructing a OrganizationSettings resource. +type OrganizationSettingsArgs struct { + // Whether or not advanced security is enabled for new repositories. Defaults to `false`. + AdvancedSecurityEnabledForNewRepositories pulumi.BoolPtrInput + // The billing email address for the organization. + BillingEmail pulumi.StringInput + // The blog URL for the organization. + Blog pulumi.StringPtrInput + // The company name for the organization. + Company pulumi.StringPtrInput + // The default permission for organization members to create new repositories. Can be one of `read`, `write`, `admin`, or `none`. Defaults to `read`. + DefaultRepositoryPermission pulumi.StringPtrInput + // Whether or not dependabot alerts are enabled for new repositories. Defaults to `false`. + DependabotAlertsEnabledForNewRepositories pulumi.BoolPtrInput + // Whether or not dependabot security updates are enabled for new repositories. Defaults to `false`. + DependabotSecurityUpdatesEnabledForNewRepositories pulumi.BoolPtrInput + // Whether or not dependency graph is enabled for new repositories. Defaults to `false`. + DependencyGraphEnabledForNewRepositories pulumi.BoolPtrInput + // The description for the organization. + Description pulumi.StringPtrInput + // The email address for the organization. + Email pulumi.StringPtrInput + // Whether or not organization projects are enabled for the organization. + HasOrganizationProjects pulumi.BoolPtrInput + // Whether or not repository projects are enabled for the organization. + HasRepositoryProjects pulumi.BoolPtrInput + // The location for the organization. + Location pulumi.StringPtrInput + // Whether or not organization members can create new internal repositories. For Enterprise Organizations only. + MembersCanCreateInternalRepositories pulumi.BoolPtrInput + // Whether or not organization members can create new pages. Defaults to `true`. + MembersCanCreatePages pulumi.BoolPtrInput + // Whether or not organization members can create new private pages. Defaults to `true`. + MembersCanCreatePrivatePages pulumi.BoolPtrInput + // Whether or not organization members can create new private repositories. Defaults to `true`. + MembersCanCreatePrivateRepositories pulumi.BoolPtrInput + // Whether or not organization members can create new public pages. Defaults to `true`. + MembersCanCreatePublicPages pulumi.BoolPtrInput + // Whether or not organization members can create new public repositories. Defaults to `true`. + MembersCanCreatePublicRepositories pulumi.BoolPtrInput + // Whether or not organization members can create new repositories. Defaults to `true`. + MembersCanCreateRepositories pulumi.BoolPtrInput + // Whether or not organization members can fork private repositories. Defaults to `false`. + MembersCanForkPrivateRepositories pulumi.BoolPtrInput + // The name for the organization. + Name pulumi.StringPtrInput + // Whether or not secret scanning is enabled for new repositories. Defaults to `false`. + SecretScanningEnabledForNewRepositories pulumi.BoolPtrInput + // Whether or not secret scanning push protection is enabled for new repositories. Defaults to `false`. + SecretScanningPushProtectionEnabledForNewRepositories pulumi.BoolPtrInput + // The Twitter username for the organization. + TwitterUsername pulumi.StringPtrInput + // Whether or not commit signatures are required for commits to the organization. Defaults to `false`. + WebCommitSignoffRequired pulumi.BoolPtrInput +} + +func (OrganizationSettingsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*organizationSettingsArgs)(nil)).Elem() +} + +type OrganizationSettingsInput interface { + pulumi.Input + + ToOrganizationSettingsOutput() OrganizationSettingsOutput + ToOrganizationSettingsOutputWithContext(ctx context.Context) OrganizationSettingsOutput +} + +func (*OrganizationSettings) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationSettings)(nil)).Elem() +} + +func (i *OrganizationSettings) ToOrganizationSettingsOutput() OrganizationSettingsOutput { + return i.ToOrganizationSettingsOutputWithContext(context.Background()) +} + +func (i *OrganizationSettings) ToOrganizationSettingsOutputWithContext(ctx context.Context) OrganizationSettingsOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationSettingsOutput) +} + +// OrganizationSettingsArrayInput is an input type that accepts OrganizationSettingsArray and OrganizationSettingsArrayOutput values. +// You can construct a concrete instance of `OrganizationSettingsArrayInput` via: +// +// OrganizationSettingsArray{ OrganizationSettingsArgs{...} } +type OrganizationSettingsArrayInput interface { + pulumi.Input + + ToOrganizationSettingsArrayOutput() OrganizationSettingsArrayOutput + ToOrganizationSettingsArrayOutputWithContext(context.Context) OrganizationSettingsArrayOutput +} + +type OrganizationSettingsArray []OrganizationSettingsInput + +func (OrganizationSettingsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationSettings)(nil)).Elem() +} + +func (i OrganizationSettingsArray) ToOrganizationSettingsArrayOutput() OrganizationSettingsArrayOutput { + return i.ToOrganizationSettingsArrayOutputWithContext(context.Background()) +} + +func (i OrganizationSettingsArray) ToOrganizationSettingsArrayOutputWithContext(ctx context.Context) OrganizationSettingsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationSettingsArrayOutput) +} + +// OrganizationSettingsMapInput is an input type that accepts OrganizationSettingsMap and OrganizationSettingsMapOutput values. +// You can construct a concrete instance of `OrganizationSettingsMapInput` via: +// +// OrganizationSettingsMap{ "key": OrganizationSettingsArgs{...} } +type OrganizationSettingsMapInput interface { + pulumi.Input + + ToOrganizationSettingsMapOutput() OrganizationSettingsMapOutput + ToOrganizationSettingsMapOutputWithContext(context.Context) OrganizationSettingsMapOutput +} + +type OrganizationSettingsMap map[string]OrganizationSettingsInput + +func (OrganizationSettingsMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationSettings)(nil)).Elem() +} + +func (i OrganizationSettingsMap) ToOrganizationSettingsMapOutput() OrganizationSettingsMapOutput { + return i.ToOrganizationSettingsMapOutputWithContext(context.Background()) +} + +func (i OrganizationSettingsMap) ToOrganizationSettingsMapOutputWithContext(ctx context.Context) OrganizationSettingsMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationSettingsMapOutput) +} + +type OrganizationSettingsOutput struct{ *pulumi.OutputState } + +func (OrganizationSettingsOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationSettings)(nil)).Elem() +} + +func (o OrganizationSettingsOutput) ToOrganizationSettingsOutput() OrganizationSettingsOutput { + return o +} + +func (o OrganizationSettingsOutput) ToOrganizationSettingsOutputWithContext(ctx context.Context) OrganizationSettingsOutput { + return o +} + +// Whether or not advanced security is enabled for new repositories. Defaults to `false`. +func (o OrganizationSettingsOutput) AdvancedSecurityEnabledForNewRepositories() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { return v.AdvancedSecurityEnabledForNewRepositories }).(pulumi.BoolPtrOutput) +} + +// The billing email address for the organization. +func (o OrganizationSettingsOutput) BillingEmail() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.StringOutput { return v.BillingEmail }).(pulumi.StringOutput) +} + +// The blog URL for the organization. +func (o OrganizationSettingsOutput) Blog() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.StringPtrOutput { return v.Blog }).(pulumi.StringPtrOutput) +} + +// The company name for the organization. +func (o OrganizationSettingsOutput) Company() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.StringPtrOutput { return v.Company }).(pulumi.StringPtrOutput) +} + +// The default permission for organization members to create new repositories. Can be one of `read`, `write`, `admin`, or `none`. Defaults to `read`. +func (o OrganizationSettingsOutput) DefaultRepositoryPermission() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.StringPtrOutput { return v.DefaultRepositoryPermission }).(pulumi.StringPtrOutput) +} + +// Whether or not dependabot alerts are enabled for new repositories. Defaults to `false`. +func (o OrganizationSettingsOutput) DependabotAlertsEnabledForNewRepositories() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { return v.DependabotAlertsEnabledForNewRepositories }).(pulumi.BoolPtrOutput) +} + +// Whether or not dependabot security updates are enabled for new repositories. Defaults to `false`. +func (o OrganizationSettingsOutput) DependabotSecurityUpdatesEnabledForNewRepositories() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { + return v.DependabotSecurityUpdatesEnabledForNewRepositories + }).(pulumi.BoolPtrOutput) +} + +// Whether or not dependency graph is enabled for new repositories. Defaults to `false`. +func (o OrganizationSettingsOutput) DependencyGraphEnabledForNewRepositories() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { return v.DependencyGraphEnabledForNewRepositories }).(pulumi.BoolPtrOutput) +} + +// The description for the organization. +func (o OrganizationSettingsOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) +} + +// The email address for the organization. +func (o OrganizationSettingsOutput) Email() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.StringPtrOutput { return v.Email }).(pulumi.StringPtrOutput) +} + +// Whether or not organization projects are enabled for the organization. +func (o OrganizationSettingsOutput) HasOrganizationProjects() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { return v.HasOrganizationProjects }).(pulumi.BoolPtrOutput) +} + +// Whether or not repository projects are enabled for the organization. +func (o OrganizationSettingsOutput) HasRepositoryProjects() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { return v.HasRepositoryProjects }).(pulumi.BoolPtrOutput) +} + +// The location for the organization. +func (o OrganizationSettingsOutput) Location() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.StringPtrOutput { return v.Location }).(pulumi.StringPtrOutput) +} + +// Whether or not organization members can create new internal repositories. For Enterprise Organizations only. +func (o OrganizationSettingsOutput) MembersCanCreateInternalRepositories() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { return v.MembersCanCreateInternalRepositories }).(pulumi.BoolPtrOutput) +} + +// Whether or not organization members can create new pages. Defaults to `true`. +func (o OrganizationSettingsOutput) MembersCanCreatePages() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { return v.MembersCanCreatePages }).(pulumi.BoolPtrOutput) +} + +// Whether or not organization members can create new private pages. Defaults to `true`. +func (o OrganizationSettingsOutput) MembersCanCreatePrivatePages() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { return v.MembersCanCreatePrivatePages }).(pulumi.BoolPtrOutput) +} + +// Whether or not organization members can create new private repositories. Defaults to `true`. +func (o OrganizationSettingsOutput) MembersCanCreatePrivateRepositories() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { return v.MembersCanCreatePrivateRepositories }).(pulumi.BoolPtrOutput) +} + +// Whether or not organization members can create new public pages. Defaults to `true`. +func (o OrganizationSettingsOutput) MembersCanCreatePublicPages() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { return v.MembersCanCreatePublicPages }).(pulumi.BoolPtrOutput) +} + +// Whether or not organization members can create new public repositories. Defaults to `true`. +func (o OrganizationSettingsOutput) MembersCanCreatePublicRepositories() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { return v.MembersCanCreatePublicRepositories }).(pulumi.BoolPtrOutput) +} + +// Whether or not organization members can create new repositories. Defaults to `true`. +func (o OrganizationSettingsOutput) MembersCanCreateRepositories() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { return v.MembersCanCreateRepositories }).(pulumi.BoolPtrOutput) +} + +// Whether or not organization members can fork private repositories. Defaults to `false`. +func (o OrganizationSettingsOutput) MembersCanForkPrivateRepositories() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { return v.MembersCanForkPrivateRepositories }).(pulumi.BoolPtrOutput) +} + +// The name for the organization. +func (o OrganizationSettingsOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// Whether or not secret scanning is enabled for new repositories. Defaults to `false`. +func (o OrganizationSettingsOutput) SecretScanningEnabledForNewRepositories() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { return v.SecretScanningEnabledForNewRepositories }).(pulumi.BoolPtrOutput) +} + +// Whether or not secret scanning push protection is enabled for new repositories. Defaults to `false`. +func (o OrganizationSettingsOutput) SecretScanningPushProtectionEnabledForNewRepositories() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { + return v.SecretScanningPushProtectionEnabledForNewRepositories + }).(pulumi.BoolPtrOutput) +} + +// The Twitter username for the organization. +func (o OrganizationSettingsOutput) TwitterUsername() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.StringPtrOutput { return v.TwitterUsername }).(pulumi.StringPtrOutput) +} + +// Whether or not commit signatures are required for commits to the organization. Defaults to `false`. +func (o OrganizationSettingsOutput) WebCommitSignoffRequired() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationSettings) pulumi.BoolPtrOutput { return v.WebCommitSignoffRequired }).(pulumi.BoolPtrOutput) +} + +type OrganizationSettingsArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationSettingsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationSettings)(nil)).Elem() +} + +func (o OrganizationSettingsArrayOutput) ToOrganizationSettingsArrayOutput() OrganizationSettingsArrayOutput { + return o +} + +func (o OrganizationSettingsArrayOutput) ToOrganizationSettingsArrayOutputWithContext(ctx context.Context) OrganizationSettingsArrayOutput { + return o +} + +func (o OrganizationSettingsArrayOutput) Index(i pulumi.IntInput) OrganizationSettingsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OrganizationSettings { + return vs[0].([]*OrganizationSettings)[vs[1].(int)] + }).(OrganizationSettingsOutput) +} + +type OrganizationSettingsMapOutput struct{ *pulumi.OutputState } + +func (OrganizationSettingsMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationSettings)(nil)).Elem() +} + +func (o OrganizationSettingsMapOutput) ToOrganizationSettingsMapOutput() OrganizationSettingsMapOutput { + return o +} + +func (o OrganizationSettingsMapOutput) ToOrganizationSettingsMapOutputWithContext(ctx context.Context) OrganizationSettingsMapOutput { + return o +} + +func (o OrganizationSettingsMapOutput) MapIndex(k pulumi.StringInput) OrganizationSettingsOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *OrganizationSettings { + return vs[0].(map[string]*OrganizationSettings)[vs[1].(string)] + }).(OrganizationSettingsOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationSettingsInput)(nil)).Elem(), &OrganizationSettings{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationSettingsArrayInput)(nil)).Elem(), OrganizationSettingsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationSettingsMapInput)(nil)).Elem(), OrganizationSettingsMap{}) + pulumi.RegisterOutputType(OrganizationSettingsOutput{}) + pulumi.RegisterOutputType(OrganizationSettingsArrayOutput{}) + pulumi.RegisterOutputType(OrganizationSettingsMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationWebhook.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationWebhook.go new file mode 100644 index 000000000..ea01bbe67 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/organizationWebhook.go @@ -0,0 +1,313 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage webhooks for GitHub organization. +// +// ## Example Usage +// +// ```go +// 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.NewOrganizationWebhook(ctx, "foo", &github.OrganizationWebhookArgs{ +// Name: "web", +// Configuration: &github.OrganizationWebhookConfigurationArgs{ +// Url: pulumi.String("https://google.de/"), +// ContentType: pulumi.String("form"), +// InsecureSsl: pulumi.Bool(false), +// }, +// Active: pulumi.Bool(false), +// Events: pulumi.StringArray{ +// pulumi.String("issues"), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// Organization webhooks can be imported using the `id` of the webhook. +// The `id` of the webhook can be found in the URL of the webhook. For example, `"https://github.com/organizations/foo-org/settings/hooks/123456789"`. +// +// ```sh +// $ pulumi import github:index/organizationWebhook:OrganizationWebhook terraform 123456789 +// ``` +// +// If secret is populated in the webhook's configuration, the value will be imported as "********". +type OrganizationWebhook struct { + pulumi.CustomResourceState + + // Indicate of the webhook should receive events. Defaults to `true`. + Active pulumi.BoolPtrOutput `pulumi:"active"` + // key/value pair of configuration for this webhook. Available keys are `url`, `contentType`, `secret` and `insecureSsl`. + Configuration OrganizationWebhookConfigurationPtrOutput `pulumi:"configuration"` + Etag pulumi.StringOutput `pulumi:"etag"` + // A list of events which should trigger the webhook. See a list of [available events](https://developer.github.com/v3/activity/events/types/) + Events pulumi.StringArrayOutput `pulumi:"events"` + // URL of the webhook + Url pulumi.StringOutput `pulumi:"url"` +} + +// NewOrganizationWebhook registers a new resource with the given unique name, arguments, and options. +func NewOrganizationWebhook(ctx *pulumi.Context, + name string, args *OrganizationWebhookArgs, opts ...pulumi.ResourceOption) (*OrganizationWebhook, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Events == nil { + return nil, errors.New("invalid value for required argument 'Events'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource OrganizationWebhook + err := ctx.RegisterResource("github:index/organizationWebhook:OrganizationWebhook", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetOrganizationWebhook gets an existing OrganizationWebhook 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 GetOrganizationWebhook(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *OrganizationWebhookState, opts ...pulumi.ResourceOption) (*OrganizationWebhook, error) { + var resource OrganizationWebhook + err := ctx.ReadResource("github:index/organizationWebhook:OrganizationWebhook", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering OrganizationWebhook resources. +type organizationWebhookState struct { + // Indicate of the webhook should receive events. Defaults to `true`. + Active *bool `pulumi:"active"` + // key/value pair of configuration for this webhook. Available keys are `url`, `contentType`, `secret` and `insecureSsl`. + Configuration *OrganizationWebhookConfiguration `pulumi:"configuration"` + Etag *string `pulumi:"etag"` + // A list of events which should trigger the webhook. See a list of [available events](https://developer.github.com/v3/activity/events/types/) + Events []string `pulumi:"events"` + // URL of the webhook + Url *string `pulumi:"url"` +} + +type OrganizationWebhookState struct { + // Indicate of the webhook should receive events. Defaults to `true`. + Active pulumi.BoolPtrInput + // key/value pair of configuration for this webhook. Available keys are `url`, `contentType`, `secret` and `insecureSsl`. + Configuration OrganizationWebhookConfigurationPtrInput + Etag pulumi.StringPtrInput + // A list of events which should trigger the webhook. See a list of [available events](https://developer.github.com/v3/activity/events/types/) + Events pulumi.StringArrayInput + // URL of the webhook + Url pulumi.StringPtrInput +} + +func (OrganizationWebhookState) ElementType() reflect.Type { + return reflect.TypeOf((*organizationWebhookState)(nil)).Elem() +} + +type organizationWebhookArgs struct { + // Indicate of the webhook should receive events. Defaults to `true`. + Active *bool `pulumi:"active"` + // key/value pair of configuration for this webhook. Available keys are `url`, `contentType`, `secret` and `insecureSsl`. + Configuration *OrganizationWebhookConfiguration `pulumi:"configuration"` + // A list of events which should trigger the webhook. See a list of [available events](https://developer.github.com/v3/activity/events/types/) + Events []string `pulumi:"events"` +} + +// The set of arguments for constructing a OrganizationWebhook resource. +type OrganizationWebhookArgs struct { + // Indicate of the webhook should receive events. Defaults to `true`. + Active pulumi.BoolPtrInput + // key/value pair of configuration for this webhook. Available keys are `url`, `contentType`, `secret` and `insecureSsl`. + Configuration OrganizationWebhookConfigurationPtrInput + // A list of events which should trigger the webhook. See a list of [available events](https://developer.github.com/v3/activity/events/types/) + Events pulumi.StringArrayInput +} + +func (OrganizationWebhookArgs) ElementType() reflect.Type { + return reflect.TypeOf((*organizationWebhookArgs)(nil)).Elem() +} + +type OrganizationWebhookInput interface { + pulumi.Input + + ToOrganizationWebhookOutput() OrganizationWebhookOutput + ToOrganizationWebhookOutputWithContext(ctx context.Context) OrganizationWebhookOutput +} + +func (*OrganizationWebhook) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationWebhook)(nil)).Elem() +} + +func (i *OrganizationWebhook) ToOrganizationWebhookOutput() OrganizationWebhookOutput { + return i.ToOrganizationWebhookOutputWithContext(context.Background()) +} + +func (i *OrganizationWebhook) ToOrganizationWebhookOutputWithContext(ctx context.Context) OrganizationWebhookOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationWebhookOutput) +} + +// OrganizationWebhookArrayInput is an input type that accepts OrganizationWebhookArray and OrganizationWebhookArrayOutput values. +// You can construct a concrete instance of `OrganizationWebhookArrayInput` via: +// +// OrganizationWebhookArray{ OrganizationWebhookArgs{...} } +type OrganizationWebhookArrayInput interface { + pulumi.Input + + ToOrganizationWebhookArrayOutput() OrganizationWebhookArrayOutput + ToOrganizationWebhookArrayOutputWithContext(context.Context) OrganizationWebhookArrayOutput +} + +type OrganizationWebhookArray []OrganizationWebhookInput + +func (OrganizationWebhookArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationWebhook)(nil)).Elem() +} + +func (i OrganizationWebhookArray) ToOrganizationWebhookArrayOutput() OrganizationWebhookArrayOutput { + return i.ToOrganizationWebhookArrayOutputWithContext(context.Background()) +} + +func (i OrganizationWebhookArray) ToOrganizationWebhookArrayOutputWithContext(ctx context.Context) OrganizationWebhookArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationWebhookArrayOutput) +} + +// OrganizationWebhookMapInput is an input type that accepts OrganizationWebhookMap and OrganizationWebhookMapOutput values. +// You can construct a concrete instance of `OrganizationWebhookMapInput` via: +// +// OrganizationWebhookMap{ "key": OrganizationWebhookArgs{...} } +type OrganizationWebhookMapInput interface { + pulumi.Input + + ToOrganizationWebhookMapOutput() OrganizationWebhookMapOutput + ToOrganizationWebhookMapOutputWithContext(context.Context) OrganizationWebhookMapOutput +} + +type OrganizationWebhookMap map[string]OrganizationWebhookInput + +func (OrganizationWebhookMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationWebhook)(nil)).Elem() +} + +func (i OrganizationWebhookMap) ToOrganizationWebhookMapOutput() OrganizationWebhookMapOutput { + return i.ToOrganizationWebhookMapOutputWithContext(context.Background()) +} + +func (i OrganizationWebhookMap) ToOrganizationWebhookMapOutputWithContext(ctx context.Context) OrganizationWebhookMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationWebhookMapOutput) +} + +type OrganizationWebhookOutput struct{ *pulumi.OutputState } + +func (OrganizationWebhookOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationWebhook)(nil)).Elem() +} + +func (o OrganizationWebhookOutput) ToOrganizationWebhookOutput() OrganizationWebhookOutput { + return o +} + +func (o OrganizationWebhookOutput) ToOrganizationWebhookOutputWithContext(ctx context.Context) OrganizationWebhookOutput { + return o +} + +// Indicate of the webhook should receive events. Defaults to `true`. +func (o OrganizationWebhookOutput) Active() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationWebhook) pulumi.BoolPtrOutput { return v.Active }).(pulumi.BoolPtrOutput) +} + +// key/value pair of configuration for this webhook. Available keys are `url`, `contentType`, `secret` and `insecureSsl`. +func (o OrganizationWebhookOutput) Configuration() OrganizationWebhookConfigurationPtrOutput { + return o.ApplyT(func(v *OrganizationWebhook) OrganizationWebhookConfigurationPtrOutput { return v.Configuration }).(OrganizationWebhookConfigurationPtrOutput) +} + +func (o OrganizationWebhookOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationWebhook) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// A list of events which should trigger the webhook. See a list of [available events](https://developer.github.com/v3/activity/events/types/) +func (o OrganizationWebhookOutput) Events() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OrganizationWebhook) pulumi.StringArrayOutput { return v.Events }).(pulumi.StringArrayOutput) +} + +// URL of the webhook +func (o OrganizationWebhookOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v *OrganizationWebhook) pulumi.StringOutput { return v.Url }).(pulumi.StringOutput) +} + +type OrganizationWebhookArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationWebhookArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*OrganizationWebhook)(nil)).Elem() +} + +func (o OrganizationWebhookArrayOutput) ToOrganizationWebhookArrayOutput() OrganizationWebhookArrayOutput { + return o +} + +func (o OrganizationWebhookArrayOutput) ToOrganizationWebhookArrayOutputWithContext(ctx context.Context) OrganizationWebhookArrayOutput { + return o +} + +func (o OrganizationWebhookArrayOutput) Index(i pulumi.IntInput) OrganizationWebhookOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *OrganizationWebhook { + return vs[0].([]*OrganizationWebhook)[vs[1].(int)] + }).(OrganizationWebhookOutput) +} + +type OrganizationWebhookMapOutput struct{ *pulumi.OutputState } + +func (OrganizationWebhookMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*OrganizationWebhook)(nil)).Elem() +} + +func (o OrganizationWebhookMapOutput) ToOrganizationWebhookMapOutput() OrganizationWebhookMapOutput { + return o +} + +func (o OrganizationWebhookMapOutput) ToOrganizationWebhookMapOutputWithContext(ctx context.Context) OrganizationWebhookMapOutput { + return o +} + +func (o OrganizationWebhookMapOutput) MapIndex(k pulumi.StringInput) OrganizationWebhookOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *OrganizationWebhook { + return vs[0].(map[string]*OrganizationWebhook)[vs[1].(string)] + }).(OrganizationWebhookOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationWebhookInput)(nil)).Elem(), &OrganizationWebhook{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationWebhookArrayInput)(nil)).Elem(), OrganizationWebhookArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationWebhookMapInput)(nil)).Elem(), OrganizationWebhookMap{}) + pulumi.RegisterOutputType(OrganizationWebhookOutput{}) + pulumi.RegisterOutputType(OrganizationWebhookArrayOutput{}) + pulumi.RegisterOutputType(OrganizationWebhookMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/projectCard.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/projectCard.go new file mode 100644 index 000000000..ad7c22e79 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/projectCard.go @@ -0,0 +1,410 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// !> **Warning:** This resource no longer works as the [Projects (classic) REST API](https://docs.github.com/en/rest/projects/projects?apiVersion=2022-11-28) has been [removed](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) and as such has been deprecated. It will be removed in a future release. +// +// This resource allows you to create and manage cards for GitHub projects. +// +// ## Example Usage +// +// ```go +// 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 { +// project, err := github.NewOrganizationProject(ctx, "project", &github.OrganizationProjectArgs{ +// Name: pulumi.String("An Organization Project"), +// Body: pulumi.String("This is an organization project."), +// }) +// if err != nil { +// return err +// } +// column, err := github.NewProjectColumn(ctx, "column", &github.ProjectColumnArgs{ +// ProjectId: project.ID(), +// Name: pulumi.String("Backlog"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewProjectCard(ctx, "card", &github.ProjectCardArgs{ +// ColumnId: column.ColumnId, +// Note: pulumi.String("## Unaccepted 👇"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ### Adding An Issue To A Project +// +// ```go +// 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 { +// test, err := github.NewRepository(ctx, "test", &github.RepositoryArgs{ +// Name: pulumi.String("myrepo"), +// HasProjects: pulumi.Bool(true), +// HasIssues: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// testIssue, err := github.NewIssue(ctx, "test", &github.IssueArgs{ +// Repository: test.ID(), +// Title: pulumi.String("Test issue title"), +// Body: pulumi.String("Test issue body"), +// }) +// if err != nil { +// return err +// } +// testRepositoryProject, err := github.NewRepositoryProject(ctx, "test", &github.RepositoryProjectArgs{ +// Name: pulumi.String("test"), +// Repository: test.Name, +// Body: pulumi.String("this is a test project"), +// }) +// if err != nil { +// return err +// } +// testProjectColumn, err := github.NewProjectColumn(ctx, "test", &github.ProjectColumnArgs{ +// ProjectId: testRepositoryProject.ID(), +// Name: pulumi.String("Backlog"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewProjectCard(ctx, "test", &github.ProjectCardArgs{ +// ColumnId: testProjectColumn.ColumnId, +// ContentId: testIssue.IssueId, +// ContentType: pulumi.String("Issue"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// A GitHub Project Card can be imported using its [Card ID](https://developer.github.com/v3/projects/cards/#get-a-project-card): +// +// ```sh +// $ pulumi import github:index/projectCard:ProjectCard card 01234567 +// ``` +type ProjectCard struct { + pulumi.CustomResourceState + + // The ID of the card. + CardId pulumi.IntOutput `pulumi:"cardId"` + // The ID of the card. + ColumnId pulumi.StringOutput `pulumi:"columnId"` + // `github_issue.issue_id`. + ContentId pulumi.IntPtrOutput `pulumi:"contentId"` + // Must be either `Issue` or `PullRequest` + // + // **Remarks:** You must either set the `note` attribute or both `contentId` and `contentType`. + // See note example or issue example for more information. + ContentType pulumi.StringPtrOutput `pulumi:"contentType"` + Etag pulumi.StringOutput `pulumi:"etag"` + // The note contents of the card. Markdown supported. + Note pulumi.StringPtrOutput `pulumi:"note"` +} + +// NewProjectCard registers a new resource with the given unique name, arguments, and options. +func NewProjectCard(ctx *pulumi.Context, + name string, args *ProjectCardArgs, opts ...pulumi.ResourceOption) (*ProjectCard, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ColumnId == nil { + return nil, errors.New("invalid value for required argument 'ColumnId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ProjectCard + err := ctx.RegisterResource("github:index/projectCard:ProjectCard", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetProjectCard gets an existing ProjectCard 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 GetProjectCard(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ProjectCardState, opts ...pulumi.ResourceOption) (*ProjectCard, error) { + var resource ProjectCard + err := ctx.ReadResource("github:index/projectCard:ProjectCard", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ProjectCard resources. +type projectCardState struct { + // The ID of the card. + CardId *int `pulumi:"cardId"` + // The ID of the card. + ColumnId *string `pulumi:"columnId"` + // `github_issue.issue_id`. + ContentId *int `pulumi:"contentId"` + // Must be either `Issue` or `PullRequest` + // + // **Remarks:** You must either set the `note` attribute or both `contentId` and `contentType`. + // See note example or issue example for more information. + ContentType *string `pulumi:"contentType"` + Etag *string `pulumi:"etag"` + // The note contents of the card. Markdown supported. + Note *string `pulumi:"note"` +} + +type ProjectCardState struct { + // The ID of the card. + CardId pulumi.IntPtrInput + // The ID of the card. + ColumnId pulumi.StringPtrInput + // `github_issue.issue_id`. + ContentId pulumi.IntPtrInput + // Must be either `Issue` or `PullRequest` + // + // **Remarks:** You must either set the `note` attribute or both `contentId` and `contentType`. + // See note example or issue example for more information. + ContentType pulumi.StringPtrInput + Etag pulumi.StringPtrInput + // The note contents of the card. Markdown supported. + Note pulumi.StringPtrInput +} + +func (ProjectCardState) ElementType() reflect.Type { + return reflect.TypeOf((*projectCardState)(nil)).Elem() +} + +type projectCardArgs struct { + // The ID of the card. + ColumnId string `pulumi:"columnId"` + // `github_issue.issue_id`. + ContentId *int `pulumi:"contentId"` + // Must be either `Issue` or `PullRequest` + // + // **Remarks:** You must either set the `note` attribute or both `contentId` and `contentType`. + // See note example or issue example for more information. + ContentType *string `pulumi:"contentType"` + // The note contents of the card. Markdown supported. + Note *string `pulumi:"note"` +} + +// The set of arguments for constructing a ProjectCard resource. +type ProjectCardArgs struct { + // The ID of the card. + ColumnId pulumi.StringInput + // `github_issue.issue_id`. + ContentId pulumi.IntPtrInput + // Must be either `Issue` or `PullRequest` + // + // **Remarks:** You must either set the `note` attribute or both `contentId` and `contentType`. + // See note example or issue example for more information. + ContentType pulumi.StringPtrInput + // The note contents of the card. Markdown supported. + Note pulumi.StringPtrInput +} + +func (ProjectCardArgs) ElementType() reflect.Type { + return reflect.TypeOf((*projectCardArgs)(nil)).Elem() +} + +type ProjectCardInput interface { + pulumi.Input + + ToProjectCardOutput() ProjectCardOutput + ToProjectCardOutputWithContext(ctx context.Context) ProjectCardOutput +} + +func (*ProjectCard) ElementType() reflect.Type { + return reflect.TypeOf((**ProjectCard)(nil)).Elem() +} + +func (i *ProjectCard) ToProjectCardOutput() ProjectCardOutput { + return i.ToProjectCardOutputWithContext(context.Background()) +} + +func (i *ProjectCard) ToProjectCardOutputWithContext(ctx context.Context) ProjectCardOutput { + return pulumi.ToOutputWithContext(ctx, i).(ProjectCardOutput) +} + +// ProjectCardArrayInput is an input type that accepts ProjectCardArray and ProjectCardArrayOutput values. +// You can construct a concrete instance of `ProjectCardArrayInput` via: +// +// ProjectCardArray{ ProjectCardArgs{...} } +type ProjectCardArrayInput interface { + pulumi.Input + + ToProjectCardArrayOutput() ProjectCardArrayOutput + ToProjectCardArrayOutputWithContext(context.Context) ProjectCardArrayOutput +} + +type ProjectCardArray []ProjectCardInput + +func (ProjectCardArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ProjectCard)(nil)).Elem() +} + +func (i ProjectCardArray) ToProjectCardArrayOutput() ProjectCardArrayOutput { + return i.ToProjectCardArrayOutputWithContext(context.Background()) +} + +func (i ProjectCardArray) ToProjectCardArrayOutputWithContext(ctx context.Context) ProjectCardArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ProjectCardArrayOutput) +} + +// ProjectCardMapInput is an input type that accepts ProjectCardMap and ProjectCardMapOutput values. +// You can construct a concrete instance of `ProjectCardMapInput` via: +// +// ProjectCardMap{ "key": ProjectCardArgs{...} } +type ProjectCardMapInput interface { + pulumi.Input + + ToProjectCardMapOutput() ProjectCardMapOutput + ToProjectCardMapOutputWithContext(context.Context) ProjectCardMapOutput +} + +type ProjectCardMap map[string]ProjectCardInput + +func (ProjectCardMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ProjectCard)(nil)).Elem() +} + +func (i ProjectCardMap) ToProjectCardMapOutput() ProjectCardMapOutput { + return i.ToProjectCardMapOutputWithContext(context.Background()) +} + +func (i ProjectCardMap) ToProjectCardMapOutputWithContext(ctx context.Context) ProjectCardMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ProjectCardMapOutput) +} + +type ProjectCardOutput struct{ *pulumi.OutputState } + +func (ProjectCardOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ProjectCard)(nil)).Elem() +} + +func (o ProjectCardOutput) ToProjectCardOutput() ProjectCardOutput { + return o +} + +func (o ProjectCardOutput) ToProjectCardOutputWithContext(ctx context.Context) ProjectCardOutput { + return o +} + +// The ID of the card. +func (o ProjectCardOutput) CardId() pulumi.IntOutput { + return o.ApplyT(func(v *ProjectCard) pulumi.IntOutput { return v.CardId }).(pulumi.IntOutput) +} + +// The ID of the card. +func (o ProjectCardOutput) ColumnId() pulumi.StringOutput { + return o.ApplyT(func(v *ProjectCard) pulumi.StringOutput { return v.ColumnId }).(pulumi.StringOutput) +} + +// `github_issue.issue_id`. +func (o ProjectCardOutput) ContentId() pulumi.IntPtrOutput { + return o.ApplyT(func(v *ProjectCard) pulumi.IntPtrOutput { return v.ContentId }).(pulumi.IntPtrOutput) +} + +// Must be either `Issue` or `PullRequest` +// +// **Remarks:** You must either set the `note` attribute or both `contentId` and `contentType`. +// See note example or issue example for more information. +func (o ProjectCardOutput) ContentType() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ProjectCard) pulumi.StringPtrOutput { return v.ContentType }).(pulumi.StringPtrOutput) +} + +func (o ProjectCardOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *ProjectCard) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// The note contents of the card. Markdown supported. +func (o ProjectCardOutput) Note() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ProjectCard) pulumi.StringPtrOutput { return v.Note }).(pulumi.StringPtrOutput) +} + +type ProjectCardArrayOutput struct{ *pulumi.OutputState } + +func (ProjectCardArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ProjectCard)(nil)).Elem() +} + +func (o ProjectCardArrayOutput) ToProjectCardArrayOutput() ProjectCardArrayOutput { + return o +} + +func (o ProjectCardArrayOutput) ToProjectCardArrayOutputWithContext(ctx context.Context) ProjectCardArrayOutput { + return o +} + +func (o ProjectCardArrayOutput) Index(i pulumi.IntInput) ProjectCardOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ProjectCard { + return vs[0].([]*ProjectCard)[vs[1].(int)] + }).(ProjectCardOutput) +} + +type ProjectCardMapOutput struct{ *pulumi.OutputState } + +func (ProjectCardMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ProjectCard)(nil)).Elem() +} + +func (o ProjectCardMapOutput) ToProjectCardMapOutput() ProjectCardMapOutput { + return o +} + +func (o ProjectCardMapOutput) ToProjectCardMapOutputWithContext(ctx context.Context) ProjectCardMapOutput { + return o +} + +func (o ProjectCardMapOutput) MapIndex(k pulumi.StringInput) ProjectCardOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ProjectCard { + return vs[0].(map[string]*ProjectCard)[vs[1].(string)] + }).(ProjectCardOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ProjectCardInput)(nil)).Elem(), &ProjectCard{}) + pulumi.RegisterInputType(reflect.TypeOf((*ProjectCardArrayInput)(nil)).Elem(), ProjectCardArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ProjectCardMapInput)(nil)).Elem(), ProjectCardMap{}) + pulumi.RegisterOutputType(ProjectCardOutput{}) + pulumi.RegisterOutputType(ProjectCardArrayOutput{}) + pulumi.RegisterOutputType(ProjectCardMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/projectColumn.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/projectColumn.go new file mode 100644 index 000000000..246d06110 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/projectColumn.go @@ -0,0 +1,288 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// !> **Warning:** This resource no longer works as the [Projects (classic) REST API](https://docs.github.com/en/rest/projects/projects?apiVersion=2022-11-28) has been [removed](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) and as such has been deprecated. It will be removed in a future release. +// +// This resource allows you to create and manage columns for GitHub projects. +// +// ## Example Usage +// +// ```go +// 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 { +// project, err := github.NewOrganizationProject(ctx, "project", &github.OrganizationProjectArgs{ +// Name: pulumi.String("A Organization Project"), +// Body: pulumi.String("This is an organization project."), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewProjectColumn(ctx, "column", &github.ProjectColumnArgs{ +// ProjectId: project.ID(), +// Name: pulumi.String("a column"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +type ProjectColumn struct { + pulumi.CustomResourceState + + // The ID of the column. + ColumnId pulumi.IntOutput `pulumi:"columnId"` + Etag pulumi.StringOutput `pulumi:"etag"` + // The name of the column. + Name pulumi.StringOutput `pulumi:"name"` + // The ID of an existing project that the column will be created in. + ProjectId pulumi.StringOutput `pulumi:"projectId"` +} + +// NewProjectColumn registers a new resource with the given unique name, arguments, and options. +func NewProjectColumn(ctx *pulumi.Context, + name string, args *ProjectColumnArgs, opts ...pulumi.ResourceOption) (*ProjectColumn, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ProjectId == nil { + return nil, errors.New("invalid value for required argument 'ProjectId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource ProjectColumn + err := ctx.RegisterResource("github:index/projectColumn:ProjectColumn", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetProjectColumn gets an existing ProjectColumn 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 GetProjectColumn(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ProjectColumnState, opts ...pulumi.ResourceOption) (*ProjectColumn, error) { + var resource ProjectColumn + err := ctx.ReadResource("github:index/projectColumn:ProjectColumn", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering ProjectColumn resources. +type projectColumnState struct { + // The ID of the column. + ColumnId *int `pulumi:"columnId"` + Etag *string `pulumi:"etag"` + // The name of the column. + Name *string `pulumi:"name"` + // The ID of an existing project that the column will be created in. + ProjectId *string `pulumi:"projectId"` +} + +type ProjectColumnState struct { + // The ID of the column. + ColumnId pulumi.IntPtrInput + Etag pulumi.StringPtrInput + // The name of the column. + Name pulumi.StringPtrInput + // The ID of an existing project that the column will be created in. + ProjectId pulumi.StringPtrInput +} + +func (ProjectColumnState) ElementType() reflect.Type { + return reflect.TypeOf((*projectColumnState)(nil)).Elem() +} + +type projectColumnArgs struct { + // The name of the column. + Name *string `pulumi:"name"` + // The ID of an existing project that the column will be created in. + ProjectId string `pulumi:"projectId"` +} + +// The set of arguments for constructing a ProjectColumn resource. +type ProjectColumnArgs struct { + // The name of the column. + Name pulumi.StringPtrInput + // The ID of an existing project that the column will be created in. + ProjectId pulumi.StringInput +} + +func (ProjectColumnArgs) ElementType() reflect.Type { + return reflect.TypeOf((*projectColumnArgs)(nil)).Elem() +} + +type ProjectColumnInput interface { + pulumi.Input + + ToProjectColumnOutput() ProjectColumnOutput + ToProjectColumnOutputWithContext(ctx context.Context) ProjectColumnOutput +} + +func (*ProjectColumn) ElementType() reflect.Type { + return reflect.TypeOf((**ProjectColumn)(nil)).Elem() +} + +func (i *ProjectColumn) ToProjectColumnOutput() ProjectColumnOutput { + return i.ToProjectColumnOutputWithContext(context.Background()) +} + +func (i *ProjectColumn) ToProjectColumnOutputWithContext(ctx context.Context) ProjectColumnOutput { + return pulumi.ToOutputWithContext(ctx, i).(ProjectColumnOutput) +} + +// ProjectColumnArrayInput is an input type that accepts ProjectColumnArray and ProjectColumnArrayOutput values. +// You can construct a concrete instance of `ProjectColumnArrayInput` via: +// +// ProjectColumnArray{ ProjectColumnArgs{...} } +type ProjectColumnArrayInput interface { + pulumi.Input + + ToProjectColumnArrayOutput() ProjectColumnArrayOutput + ToProjectColumnArrayOutputWithContext(context.Context) ProjectColumnArrayOutput +} + +type ProjectColumnArray []ProjectColumnInput + +func (ProjectColumnArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ProjectColumn)(nil)).Elem() +} + +func (i ProjectColumnArray) ToProjectColumnArrayOutput() ProjectColumnArrayOutput { + return i.ToProjectColumnArrayOutputWithContext(context.Background()) +} + +func (i ProjectColumnArray) ToProjectColumnArrayOutputWithContext(ctx context.Context) ProjectColumnArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ProjectColumnArrayOutput) +} + +// ProjectColumnMapInput is an input type that accepts ProjectColumnMap and ProjectColumnMapOutput values. +// You can construct a concrete instance of `ProjectColumnMapInput` via: +// +// ProjectColumnMap{ "key": ProjectColumnArgs{...} } +type ProjectColumnMapInput interface { + pulumi.Input + + ToProjectColumnMapOutput() ProjectColumnMapOutput + ToProjectColumnMapOutputWithContext(context.Context) ProjectColumnMapOutput +} + +type ProjectColumnMap map[string]ProjectColumnInput + +func (ProjectColumnMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ProjectColumn)(nil)).Elem() +} + +func (i ProjectColumnMap) ToProjectColumnMapOutput() ProjectColumnMapOutput { + return i.ToProjectColumnMapOutputWithContext(context.Background()) +} + +func (i ProjectColumnMap) ToProjectColumnMapOutputWithContext(ctx context.Context) ProjectColumnMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ProjectColumnMapOutput) +} + +type ProjectColumnOutput struct{ *pulumi.OutputState } + +func (ProjectColumnOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ProjectColumn)(nil)).Elem() +} + +func (o ProjectColumnOutput) ToProjectColumnOutput() ProjectColumnOutput { + return o +} + +func (o ProjectColumnOutput) ToProjectColumnOutputWithContext(ctx context.Context) ProjectColumnOutput { + return o +} + +// The ID of the column. +func (o ProjectColumnOutput) ColumnId() pulumi.IntOutput { + return o.ApplyT(func(v *ProjectColumn) pulumi.IntOutput { return v.ColumnId }).(pulumi.IntOutput) +} + +func (o ProjectColumnOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *ProjectColumn) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// The name of the column. +func (o ProjectColumnOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *ProjectColumn) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// The ID of an existing project that the column will be created in. +func (o ProjectColumnOutput) ProjectId() pulumi.StringOutput { + return o.ApplyT(func(v *ProjectColumn) pulumi.StringOutput { return v.ProjectId }).(pulumi.StringOutput) +} + +type ProjectColumnArrayOutput struct{ *pulumi.OutputState } + +func (ProjectColumnArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*ProjectColumn)(nil)).Elem() +} + +func (o ProjectColumnArrayOutput) ToProjectColumnArrayOutput() ProjectColumnArrayOutput { + return o +} + +func (o ProjectColumnArrayOutput) ToProjectColumnArrayOutputWithContext(ctx context.Context) ProjectColumnArrayOutput { + return o +} + +func (o ProjectColumnArrayOutput) Index(i pulumi.IntInput) ProjectColumnOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *ProjectColumn { + return vs[0].([]*ProjectColumn)[vs[1].(int)] + }).(ProjectColumnOutput) +} + +type ProjectColumnMapOutput struct{ *pulumi.OutputState } + +func (ProjectColumnMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*ProjectColumn)(nil)).Elem() +} + +func (o ProjectColumnMapOutput) ToProjectColumnMapOutput() ProjectColumnMapOutput { + return o +} + +func (o ProjectColumnMapOutput) ToProjectColumnMapOutputWithContext(ctx context.Context) ProjectColumnMapOutput { + return o +} + +func (o ProjectColumnMapOutput) MapIndex(k pulumi.StringInput) ProjectColumnOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *ProjectColumn { + return vs[0].(map[string]*ProjectColumn)[vs[1].(string)] + }).(ProjectColumnOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ProjectColumnInput)(nil)).Elem(), &ProjectColumn{}) + pulumi.RegisterInputType(reflect.TypeOf((*ProjectColumnArrayInput)(nil)).Elem(), ProjectColumnArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ProjectColumnMapInput)(nil)).Elem(), ProjectColumnMap{}) + pulumi.RegisterOutputType(ProjectColumnOutput{}) + pulumi.RegisterOutputType(ProjectColumnArrayOutput{}) + pulumi.RegisterOutputType(ProjectColumnMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/provider.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/provider.go new file mode 100644 index 000000000..a99083913 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/provider.go @@ -0,0 +1,215 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// The provider type for the github package. By default, resources use package-wide configuration +// settings, however an explicit `Provider` instance may be created and passed during resource +// construction to achieve fine-grained programmatic control over provider settings. See the +// [documentation](https://www.pulumi.com/docs/reference/programming-model/#providers) for more information. +type Provider struct { + pulumi.ProviderResourceState + + // The GitHub Base API URL + BaseUrl pulumi.StringPtrOutput `pulumi:"baseUrl"` + // The GitHub organization name to manage. Use this field instead of `owner` when managing organization accounts. + // + // Deprecated: Use owner (or GITHUB_OWNER) instead of organization (or GITHUB_ORGANIZATION) + Organization pulumi.StringPtrOutput `pulumi:"organization"` + // The GitHub owner name to manage. Use this field instead of `organization` when managing individual accounts. + Owner pulumi.StringPtrOutput `pulumi:"owner"` + // The OAuth token used to connect to GitHub. Anonymous mode is enabled if both `token` and `appAuth` are not set. + Token pulumi.StringPtrOutput `pulumi:"token"` +} + +// NewProvider registers a new resource with the given unique name, arguments, and options. +func NewProvider(ctx *pulumi.Context, + name string, args *ProviderArgs, opts ...pulumi.ResourceOption) (*Provider, error) { + if args == nil { + args = &ProviderArgs{} + } + + if args.BaseUrl == nil { + if d := internal.GetEnvOrDefault("https://api.github.com/", nil, "GITHUB_BASE_URL"); d != nil { + args.BaseUrl = pulumi.StringPtr(d.(string)) + } + } + if args.Token == nil { + if d := internal.GetEnvOrDefault(nil, nil, "GITHUB_TOKEN"); d != nil { + args.Token = pulumi.StringPtr(d.(string)) + } + } + if args.Token != nil { + args.Token = pulumi.ToSecret(args.Token).(pulumi.StringPtrInput) + } + secrets := pulumi.AdditionalSecretOutputs([]string{ + "token", + }) + opts = append(opts, secrets) + opts = internal.PkgResourceDefaultOpts(opts) + var resource Provider + err := ctx.RegisterResource("pulumi:providers:github", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +type providerArgs struct { + // The GitHub App credentials used to connect to GitHub. Conflicts with `token`. Anonymous mode is enabled if both `token` and `appAuth` are not set. + AppAuth *ProviderAppAuth `pulumi:"appAuth"` + // The GitHub Base API URL + BaseUrl *string `pulumi:"baseUrl"` + // Enable `insecure` mode for testing purposes + Insecure *bool `pulumi:"insecure"` + // Number of items per page for paginationDefaults to 100 + MaxPerPage *int `pulumi:"maxPerPage"` + // Number of times to retry a request after receiving an error status codeDefaults to 3 + MaxRetries *int `pulumi:"maxRetries"` + // The GitHub organization name to manage. Use this field instead of `owner` when managing organization accounts. + // + // Deprecated: Use owner (or GITHUB_OWNER) instead of organization (or GITHUB_ORGANIZATION) + Organization *string `pulumi:"organization"` + // The GitHub owner name to manage. Use this field instead of `organization` when managing individual accounts. + Owner *string `pulumi:"owner"` + // Allow the provider to make parallel API calls to GitHub. You may want to set it to true when you have a private Github Enterprise without strict rate limits. While it is possible to enable this setting on github.com, github.com's best practices recommend using serialization to avoid hitting abuse rate limitsDefaults to false if not set + ParallelRequests *bool `pulumi:"parallelRequests"` + // Amount of time in milliseconds to sleep in between non-write requests to GitHub API. Defaults to 0ms if not set. + ReadDelayMs *int `pulumi:"readDelayMs"` + // Amount of time in milliseconds to sleep in between requests to GitHub API after an error response. Defaults to 1000ms or 1s if not set, the maxRetries must be set to greater than zero. + RetryDelayMs *int `pulumi:"retryDelayMs"` + // Allow the provider to retry after receiving an error status code, the maxRetries should be set for this to workDefaults to [500, 502, 503, 504] + RetryableErrors []int `pulumi:"retryableErrors"` + // The OAuth token used to connect to GitHub. Anonymous mode is enabled if both `token` and `appAuth` are not set. + Token *string `pulumi:"token"` + // Amount of time in milliseconds to sleep in between writes to GitHub API. Defaults to 1000ms or 1s if not set. + WriteDelayMs *int `pulumi:"writeDelayMs"` +} + +// The set of arguments for constructing a Provider resource. +type ProviderArgs struct { + // The GitHub App credentials used to connect to GitHub. Conflicts with `token`. Anonymous mode is enabled if both `token` and `appAuth` are not set. + AppAuth ProviderAppAuthPtrInput + // The GitHub Base API URL + BaseUrl pulumi.StringPtrInput + // Enable `insecure` mode for testing purposes + Insecure pulumi.BoolPtrInput + // Number of items per page for paginationDefaults to 100 + MaxPerPage pulumi.IntPtrInput + // Number of times to retry a request after receiving an error status codeDefaults to 3 + MaxRetries pulumi.IntPtrInput + // The GitHub organization name to manage. Use this field instead of `owner` when managing organization accounts. + // + // Deprecated: Use owner (or GITHUB_OWNER) instead of organization (or GITHUB_ORGANIZATION) + Organization pulumi.StringPtrInput + // The GitHub owner name to manage. Use this field instead of `organization` when managing individual accounts. + Owner pulumi.StringPtrInput + // Allow the provider to make parallel API calls to GitHub. You may want to set it to true when you have a private Github Enterprise without strict rate limits. While it is possible to enable this setting on github.com, github.com's best practices recommend using serialization to avoid hitting abuse rate limitsDefaults to false if not set + ParallelRequests pulumi.BoolPtrInput + // Amount of time in milliseconds to sleep in between non-write requests to GitHub API. Defaults to 0ms if not set. + ReadDelayMs pulumi.IntPtrInput + // Amount of time in milliseconds to sleep in between requests to GitHub API after an error response. Defaults to 1000ms or 1s if not set, the maxRetries must be set to greater than zero. + RetryDelayMs pulumi.IntPtrInput + // Allow the provider to retry after receiving an error status code, the maxRetries should be set for this to workDefaults to [500, 502, 503, 504] + RetryableErrors pulumi.IntArrayInput + // The OAuth token used to connect to GitHub. Anonymous mode is enabled if both `token` and `appAuth` are not set. + Token pulumi.StringPtrInput + // Amount of time in milliseconds to sleep in between writes to GitHub API. Defaults to 1000ms or 1s if not set. + WriteDelayMs pulumi.IntPtrInput +} + +func (ProviderArgs) ElementType() reflect.Type { + return reflect.TypeOf((*providerArgs)(nil)).Elem() +} + +// This function returns a Terraform config object with terraform-namecased keys,to be used with the Terraform Module Provider. +func (r *Provider) TerraformConfig(ctx *pulumi.Context) (ProviderTerraformConfigResultOutput, error) { + out, err := ctx.Call("pulumi:providers:github/terraformConfig", nil, ProviderTerraformConfigResultOutput{}, r) + if err != nil { + return ProviderTerraformConfigResultOutput{}, err + } + return out.(ProviderTerraformConfigResultOutput), nil +} + +type ProviderTerraformConfigResult struct { + Result map[string]interface{} `pulumi:"result"` +} + +type ProviderTerraformConfigResultOutput struct{ *pulumi.OutputState } + +func (ProviderTerraformConfigResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ProviderTerraformConfigResult)(nil)).Elem() +} + +func (o ProviderTerraformConfigResultOutput) Result() pulumi.MapOutput { + return o.ApplyT(func(v ProviderTerraformConfigResult) map[string]interface{} { return v.Result }).(pulumi.MapOutput) +} + +type ProviderInput interface { + pulumi.Input + + ToProviderOutput() ProviderOutput + ToProviderOutputWithContext(ctx context.Context) ProviderOutput +} + +func (*Provider) ElementType() reflect.Type { + return reflect.TypeOf((**Provider)(nil)).Elem() +} + +func (i *Provider) ToProviderOutput() ProviderOutput { + return i.ToProviderOutputWithContext(context.Background()) +} + +func (i *Provider) ToProviderOutputWithContext(ctx context.Context) ProviderOutput { + return pulumi.ToOutputWithContext(ctx, i).(ProviderOutput) +} + +type ProviderOutput struct{ *pulumi.OutputState } + +func (ProviderOutput) ElementType() reflect.Type { + return reflect.TypeOf((**Provider)(nil)).Elem() +} + +func (o ProviderOutput) ToProviderOutput() ProviderOutput { + return o +} + +func (o ProviderOutput) ToProviderOutputWithContext(ctx context.Context) ProviderOutput { + return o +} + +// The GitHub Base API URL +func (o ProviderOutput) BaseUrl() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.BaseUrl }).(pulumi.StringPtrOutput) +} + +// The GitHub organization name to manage. Use this field instead of `owner` when managing organization accounts. +// +// Deprecated: Use owner (or GITHUB_OWNER) instead of organization (or GITHUB_ORGANIZATION) +func (o ProviderOutput) Organization() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.Organization }).(pulumi.StringPtrOutput) +} + +// The GitHub owner name to manage. Use this field instead of `organization` when managing individual accounts. +func (o ProviderOutput) Owner() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.Owner }).(pulumi.StringPtrOutput) +} + +// The OAuth token used to connect to GitHub. Anonymous mode is enabled if both `token` and `appAuth` are not set. +func (o ProviderOutput) Token() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Provider) pulumi.StringPtrOutput { return v.Token }).(pulumi.StringPtrOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ProviderInput)(nil)).Elem(), &Provider{}) + pulumi.RegisterOutputType(ProviderOutput{}) + pulumi.RegisterOutputType(ProviderTerraformConfigResultOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/pulumi-plugin.json b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/pulumi-plugin.json new file mode 100644 index 000000000..be88203dd --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/pulumi-plugin.json @@ -0,0 +1,5 @@ +{ + "resource": true, + "name": "github", + "version": "6.14.0" +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/pulumiTypes.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/pulumiTypes.go new file mode 100644 index 000000000..55545bb4f --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/pulumiTypes.go @@ -0,0 +1,20801 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +var _ = internal.GetEnvOrDefault + +type ActionsHostedRunnerImage struct { + // The image ID. For GitHub-owned images, use numeric IDs like "2306" for Ubuntu Latest 24.04. To get available images, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/images/github-owned`. + Id string `pulumi:"id"` + // The size of the image in gigabytes. + SizeGb *int `pulumi:"sizeGb"` + // The image source. Valid values are "github", "partner", or "custom". Defaults to "github". + Source *string `pulumi:"source"` +} + +// ActionsHostedRunnerImageInput is an input type that accepts ActionsHostedRunnerImageArgs and ActionsHostedRunnerImageOutput values. +// You can construct a concrete instance of `ActionsHostedRunnerImageInput` via: +// +// ActionsHostedRunnerImageArgs{...} +type ActionsHostedRunnerImageInput interface { + pulumi.Input + + ToActionsHostedRunnerImageOutput() ActionsHostedRunnerImageOutput + ToActionsHostedRunnerImageOutputWithContext(context.Context) ActionsHostedRunnerImageOutput +} + +type ActionsHostedRunnerImageArgs struct { + // The image ID. For GitHub-owned images, use numeric IDs like "2306" for Ubuntu Latest 24.04. To get available images, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/images/github-owned`. + Id pulumi.StringInput `pulumi:"id"` + // The size of the image in gigabytes. + SizeGb pulumi.IntPtrInput `pulumi:"sizeGb"` + // The image source. Valid values are "github", "partner", or "custom". Defaults to "github". + Source pulumi.StringPtrInput `pulumi:"source"` +} + +func (ActionsHostedRunnerImageArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ActionsHostedRunnerImage)(nil)).Elem() +} + +func (i ActionsHostedRunnerImageArgs) ToActionsHostedRunnerImageOutput() ActionsHostedRunnerImageOutput { + return i.ToActionsHostedRunnerImageOutputWithContext(context.Background()) +} + +func (i ActionsHostedRunnerImageArgs) ToActionsHostedRunnerImageOutputWithContext(ctx context.Context) ActionsHostedRunnerImageOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsHostedRunnerImageOutput) +} + +func (i ActionsHostedRunnerImageArgs) ToActionsHostedRunnerImagePtrOutput() ActionsHostedRunnerImagePtrOutput { + return i.ToActionsHostedRunnerImagePtrOutputWithContext(context.Background()) +} + +func (i ActionsHostedRunnerImageArgs) ToActionsHostedRunnerImagePtrOutputWithContext(ctx context.Context) ActionsHostedRunnerImagePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsHostedRunnerImageOutput).ToActionsHostedRunnerImagePtrOutputWithContext(ctx) +} + +// ActionsHostedRunnerImagePtrInput is an input type that accepts ActionsHostedRunnerImageArgs, ActionsHostedRunnerImagePtr and ActionsHostedRunnerImagePtrOutput values. +// You can construct a concrete instance of `ActionsHostedRunnerImagePtrInput` via: +// +// ActionsHostedRunnerImageArgs{...} +// +// or: +// +// nil +type ActionsHostedRunnerImagePtrInput interface { + pulumi.Input + + ToActionsHostedRunnerImagePtrOutput() ActionsHostedRunnerImagePtrOutput + ToActionsHostedRunnerImagePtrOutputWithContext(context.Context) ActionsHostedRunnerImagePtrOutput +} + +type actionsHostedRunnerImagePtrType ActionsHostedRunnerImageArgs + +func ActionsHostedRunnerImagePtr(v *ActionsHostedRunnerImageArgs) ActionsHostedRunnerImagePtrInput { + return (*actionsHostedRunnerImagePtrType)(v) +} + +func (*actionsHostedRunnerImagePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsHostedRunnerImage)(nil)).Elem() +} + +func (i *actionsHostedRunnerImagePtrType) ToActionsHostedRunnerImagePtrOutput() ActionsHostedRunnerImagePtrOutput { + return i.ToActionsHostedRunnerImagePtrOutputWithContext(context.Background()) +} + +func (i *actionsHostedRunnerImagePtrType) ToActionsHostedRunnerImagePtrOutputWithContext(ctx context.Context) ActionsHostedRunnerImagePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsHostedRunnerImagePtrOutput) +} + +type ActionsHostedRunnerImageOutput struct{ *pulumi.OutputState } + +func (ActionsHostedRunnerImageOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ActionsHostedRunnerImage)(nil)).Elem() +} + +func (o ActionsHostedRunnerImageOutput) ToActionsHostedRunnerImageOutput() ActionsHostedRunnerImageOutput { + return o +} + +func (o ActionsHostedRunnerImageOutput) ToActionsHostedRunnerImageOutputWithContext(ctx context.Context) ActionsHostedRunnerImageOutput { + return o +} + +func (o ActionsHostedRunnerImageOutput) ToActionsHostedRunnerImagePtrOutput() ActionsHostedRunnerImagePtrOutput { + return o.ToActionsHostedRunnerImagePtrOutputWithContext(context.Background()) +} + +func (o ActionsHostedRunnerImageOutput) ToActionsHostedRunnerImagePtrOutputWithContext(ctx context.Context) ActionsHostedRunnerImagePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v ActionsHostedRunnerImage) *ActionsHostedRunnerImage { + return &v + }).(ActionsHostedRunnerImagePtrOutput) +} + +// The image ID. For GitHub-owned images, use numeric IDs like "2306" for Ubuntu Latest 24.04. To get available images, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/images/github-owned`. +func (o ActionsHostedRunnerImageOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v ActionsHostedRunnerImage) string { return v.Id }).(pulumi.StringOutput) +} + +// The size of the image in gigabytes. +func (o ActionsHostedRunnerImageOutput) SizeGb() pulumi.IntPtrOutput { + return o.ApplyT(func(v ActionsHostedRunnerImage) *int { return v.SizeGb }).(pulumi.IntPtrOutput) +} + +// The image source. Valid values are "github", "partner", or "custom". Defaults to "github". +func (o ActionsHostedRunnerImageOutput) Source() pulumi.StringPtrOutput { + return o.ApplyT(func(v ActionsHostedRunnerImage) *string { return v.Source }).(pulumi.StringPtrOutput) +} + +type ActionsHostedRunnerImagePtrOutput struct{ *pulumi.OutputState } + +func (ActionsHostedRunnerImagePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsHostedRunnerImage)(nil)).Elem() +} + +func (o ActionsHostedRunnerImagePtrOutput) ToActionsHostedRunnerImagePtrOutput() ActionsHostedRunnerImagePtrOutput { + return o +} + +func (o ActionsHostedRunnerImagePtrOutput) ToActionsHostedRunnerImagePtrOutputWithContext(ctx context.Context) ActionsHostedRunnerImagePtrOutput { + return o +} + +func (o ActionsHostedRunnerImagePtrOutput) Elem() ActionsHostedRunnerImageOutput { + return o.ApplyT(func(v *ActionsHostedRunnerImage) ActionsHostedRunnerImage { + if v != nil { + return *v + } + var ret ActionsHostedRunnerImage + return ret + }).(ActionsHostedRunnerImageOutput) +} + +// The image ID. For GitHub-owned images, use numeric IDs like "2306" for Ubuntu Latest 24.04. To get available images, use the GitHub API: `GET /orgs/{org}/actions/hosted-runners/images/github-owned`. +func (o ActionsHostedRunnerImagePtrOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsHostedRunnerImage) *string { + if v == nil { + return nil + } + return &v.Id + }).(pulumi.StringPtrOutput) +} + +// The size of the image in gigabytes. +func (o ActionsHostedRunnerImagePtrOutput) SizeGb() pulumi.IntPtrOutput { + return o.ApplyT(func(v *ActionsHostedRunnerImage) *int { + if v == nil { + return nil + } + return v.SizeGb + }).(pulumi.IntPtrOutput) +} + +// The image source. Valid values are "github", "partner", or "custom". Defaults to "github". +func (o ActionsHostedRunnerImagePtrOutput) Source() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ActionsHostedRunnerImage) *string { + if v == nil { + return nil + } + return v.Source + }).(pulumi.StringPtrOutput) +} + +type ActionsHostedRunnerMachineSizeDetail struct { + // Number of CPU cores. + CpuCores *int `pulumi:"cpuCores"` + // Machine size identifier. + Id *string `pulumi:"id"` + // Amount of memory in gigabytes. + MemoryGb *int `pulumi:"memoryGb"` + // Amount of storage in gigabytes. + StorageGb *int `pulumi:"storageGb"` +} + +// ActionsHostedRunnerMachineSizeDetailInput is an input type that accepts ActionsHostedRunnerMachineSizeDetailArgs and ActionsHostedRunnerMachineSizeDetailOutput values. +// You can construct a concrete instance of `ActionsHostedRunnerMachineSizeDetailInput` via: +// +// ActionsHostedRunnerMachineSizeDetailArgs{...} +type ActionsHostedRunnerMachineSizeDetailInput interface { + pulumi.Input + + ToActionsHostedRunnerMachineSizeDetailOutput() ActionsHostedRunnerMachineSizeDetailOutput + ToActionsHostedRunnerMachineSizeDetailOutputWithContext(context.Context) ActionsHostedRunnerMachineSizeDetailOutput +} + +type ActionsHostedRunnerMachineSizeDetailArgs struct { + // Number of CPU cores. + CpuCores pulumi.IntPtrInput `pulumi:"cpuCores"` + // Machine size identifier. + Id pulumi.StringPtrInput `pulumi:"id"` + // Amount of memory in gigabytes. + MemoryGb pulumi.IntPtrInput `pulumi:"memoryGb"` + // Amount of storage in gigabytes. + StorageGb pulumi.IntPtrInput `pulumi:"storageGb"` +} + +func (ActionsHostedRunnerMachineSizeDetailArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ActionsHostedRunnerMachineSizeDetail)(nil)).Elem() +} + +func (i ActionsHostedRunnerMachineSizeDetailArgs) ToActionsHostedRunnerMachineSizeDetailOutput() ActionsHostedRunnerMachineSizeDetailOutput { + return i.ToActionsHostedRunnerMachineSizeDetailOutputWithContext(context.Background()) +} + +func (i ActionsHostedRunnerMachineSizeDetailArgs) ToActionsHostedRunnerMachineSizeDetailOutputWithContext(ctx context.Context) ActionsHostedRunnerMachineSizeDetailOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsHostedRunnerMachineSizeDetailOutput) +} + +// ActionsHostedRunnerMachineSizeDetailArrayInput is an input type that accepts ActionsHostedRunnerMachineSizeDetailArray and ActionsHostedRunnerMachineSizeDetailArrayOutput values. +// You can construct a concrete instance of `ActionsHostedRunnerMachineSizeDetailArrayInput` via: +// +// ActionsHostedRunnerMachineSizeDetailArray{ ActionsHostedRunnerMachineSizeDetailArgs{...} } +type ActionsHostedRunnerMachineSizeDetailArrayInput interface { + pulumi.Input + + ToActionsHostedRunnerMachineSizeDetailArrayOutput() ActionsHostedRunnerMachineSizeDetailArrayOutput + ToActionsHostedRunnerMachineSizeDetailArrayOutputWithContext(context.Context) ActionsHostedRunnerMachineSizeDetailArrayOutput +} + +type ActionsHostedRunnerMachineSizeDetailArray []ActionsHostedRunnerMachineSizeDetailInput + +func (ActionsHostedRunnerMachineSizeDetailArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]ActionsHostedRunnerMachineSizeDetail)(nil)).Elem() +} + +func (i ActionsHostedRunnerMachineSizeDetailArray) ToActionsHostedRunnerMachineSizeDetailArrayOutput() ActionsHostedRunnerMachineSizeDetailArrayOutput { + return i.ToActionsHostedRunnerMachineSizeDetailArrayOutputWithContext(context.Background()) +} + +func (i ActionsHostedRunnerMachineSizeDetailArray) ToActionsHostedRunnerMachineSizeDetailArrayOutputWithContext(ctx context.Context) ActionsHostedRunnerMachineSizeDetailArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsHostedRunnerMachineSizeDetailArrayOutput) +} + +type ActionsHostedRunnerMachineSizeDetailOutput struct{ *pulumi.OutputState } + +func (ActionsHostedRunnerMachineSizeDetailOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ActionsHostedRunnerMachineSizeDetail)(nil)).Elem() +} + +func (o ActionsHostedRunnerMachineSizeDetailOutput) ToActionsHostedRunnerMachineSizeDetailOutput() ActionsHostedRunnerMachineSizeDetailOutput { + return o +} + +func (o ActionsHostedRunnerMachineSizeDetailOutput) ToActionsHostedRunnerMachineSizeDetailOutputWithContext(ctx context.Context) ActionsHostedRunnerMachineSizeDetailOutput { + return o +} + +// Number of CPU cores. +func (o ActionsHostedRunnerMachineSizeDetailOutput) CpuCores() pulumi.IntPtrOutput { + return o.ApplyT(func(v ActionsHostedRunnerMachineSizeDetail) *int { return v.CpuCores }).(pulumi.IntPtrOutput) +} + +// Machine size identifier. +func (o ActionsHostedRunnerMachineSizeDetailOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v ActionsHostedRunnerMachineSizeDetail) *string { return v.Id }).(pulumi.StringPtrOutput) +} + +// Amount of memory in gigabytes. +func (o ActionsHostedRunnerMachineSizeDetailOutput) MemoryGb() pulumi.IntPtrOutput { + return o.ApplyT(func(v ActionsHostedRunnerMachineSizeDetail) *int { return v.MemoryGb }).(pulumi.IntPtrOutput) +} + +// Amount of storage in gigabytes. +func (o ActionsHostedRunnerMachineSizeDetailOutput) StorageGb() pulumi.IntPtrOutput { + return o.ApplyT(func(v ActionsHostedRunnerMachineSizeDetail) *int { return v.StorageGb }).(pulumi.IntPtrOutput) +} + +type ActionsHostedRunnerMachineSizeDetailArrayOutput struct{ *pulumi.OutputState } + +func (ActionsHostedRunnerMachineSizeDetailArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]ActionsHostedRunnerMachineSizeDetail)(nil)).Elem() +} + +func (o ActionsHostedRunnerMachineSizeDetailArrayOutput) ToActionsHostedRunnerMachineSizeDetailArrayOutput() ActionsHostedRunnerMachineSizeDetailArrayOutput { + return o +} + +func (o ActionsHostedRunnerMachineSizeDetailArrayOutput) ToActionsHostedRunnerMachineSizeDetailArrayOutputWithContext(ctx context.Context) ActionsHostedRunnerMachineSizeDetailArrayOutput { + return o +} + +func (o ActionsHostedRunnerMachineSizeDetailArrayOutput) Index(i pulumi.IntInput) ActionsHostedRunnerMachineSizeDetailOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) ActionsHostedRunnerMachineSizeDetail { + return vs[0].([]ActionsHostedRunnerMachineSizeDetail)[vs[1].(int)] + }).(ActionsHostedRunnerMachineSizeDetailOutput) +} + +type ActionsHostedRunnerPublicIp struct { + // Whether this IP range is enabled. + Enabled *bool `pulumi:"enabled"` + // Subnet length. + Length *int `pulumi:"length"` + // IP address prefix. + Prefix *string `pulumi:"prefix"` +} + +// ActionsHostedRunnerPublicIpInput is an input type that accepts ActionsHostedRunnerPublicIpArgs and ActionsHostedRunnerPublicIpOutput values. +// You can construct a concrete instance of `ActionsHostedRunnerPublicIpInput` via: +// +// ActionsHostedRunnerPublicIpArgs{...} +type ActionsHostedRunnerPublicIpInput interface { + pulumi.Input + + ToActionsHostedRunnerPublicIpOutput() ActionsHostedRunnerPublicIpOutput + ToActionsHostedRunnerPublicIpOutputWithContext(context.Context) ActionsHostedRunnerPublicIpOutput +} + +type ActionsHostedRunnerPublicIpArgs struct { + // Whether this IP range is enabled. + Enabled pulumi.BoolPtrInput `pulumi:"enabled"` + // Subnet length. + Length pulumi.IntPtrInput `pulumi:"length"` + // IP address prefix. + Prefix pulumi.StringPtrInput `pulumi:"prefix"` +} + +func (ActionsHostedRunnerPublicIpArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ActionsHostedRunnerPublicIp)(nil)).Elem() +} + +func (i ActionsHostedRunnerPublicIpArgs) ToActionsHostedRunnerPublicIpOutput() ActionsHostedRunnerPublicIpOutput { + return i.ToActionsHostedRunnerPublicIpOutputWithContext(context.Background()) +} + +func (i ActionsHostedRunnerPublicIpArgs) ToActionsHostedRunnerPublicIpOutputWithContext(ctx context.Context) ActionsHostedRunnerPublicIpOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsHostedRunnerPublicIpOutput) +} + +// ActionsHostedRunnerPublicIpArrayInput is an input type that accepts ActionsHostedRunnerPublicIpArray and ActionsHostedRunnerPublicIpArrayOutput values. +// You can construct a concrete instance of `ActionsHostedRunnerPublicIpArrayInput` via: +// +// ActionsHostedRunnerPublicIpArray{ ActionsHostedRunnerPublicIpArgs{...} } +type ActionsHostedRunnerPublicIpArrayInput interface { + pulumi.Input + + ToActionsHostedRunnerPublicIpArrayOutput() ActionsHostedRunnerPublicIpArrayOutput + ToActionsHostedRunnerPublicIpArrayOutputWithContext(context.Context) ActionsHostedRunnerPublicIpArrayOutput +} + +type ActionsHostedRunnerPublicIpArray []ActionsHostedRunnerPublicIpInput + +func (ActionsHostedRunnerPublicIpArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]ActionsHostedRunnerPublicIp)(nil)).Elem() +} + +func (i ActionsHostedRunnerPublicIpArray) ToActionsHostedRunnerPublicIpArrayOutput() ActionsHostedRunnerPublicIpArrayOutput { + return i.ToActionsHostedRunnerPublicIpArrayOutputWithContext(context.Background()) +} + +func (i ActionsHostedRunnerPublicIpArray) ToActionsHostedRunnerPublicIpArrayOutputWithContext(ctx context.Context) ActionsHostedRunnerPublicIpArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsHostedRunnerPublicIpArrayOutput) +} + +type ActionsHostedRunnerPublicIpOutput struct{ *pulumi.OutputState } + +func (ActionsHostedRunnerPublicIpOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ActionsHostedRunnerPublicIp)(nil)).Elem() +} + +func (o ActionsHostedRunnerPublicIpOutput) ToActionsHostedRunnerPublicIpOutput() ActionsHostedRunnerPublicIpOutput { + return o +} + +func (o ActionsHostedRunnerPublicIpOutput) ToActionsHostedRunnerPublicIpOutputWithContext(ctx context.Context) ActionsHostedRunnerPublicIpOutput { + return o +} + +// Whether this IP range is enabled. +func (o ActionsHostedRunnerPublicIpOutput) Enabled() pulumi.BoolPtrOutput { + return o.ApplyT(func(v ActionsHostedRunnerPublicIp) *bool { return v.Enabled }).(pulumi.BoolPtrOutput) +} + +// Subnet length. +func (o ActionsHostedRunnerPublicIpOutput) Length() pulumi.IntPtrOutput { + return o.ApplyT(func(v ActionsHostedRunnerPublicIp) *int { return v.Length }).(pulumi.IntPtrOutput) +} + +// IP address prefix. +func (o ActionsHostedRunnerPublicIpOutput) Prefix() pulumi.StringPtrOutput { + return o.ApplyT(func(v ActionsHostedRunnerPublicIp) *string { return v.Prefix }).(pulumi.StringPtrOutput) +} + +type ActionsHostedRunnerPublicIpArrayOutput struct{ *pulumi.OutputState } + +func (ActionsHostedRunnerPublicIpArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]ActionsHostedRunnerPublicIp)(nil)).Elem() +} + +func (o ActionsHostedRunnerPublicIpArrayOutput) ToActionsHostedRunnerPublicIpArrayOutput() ActionsHostedRunnerPublicIpArrayOutput { + return o +} + +func (o ActionsHostedRunnerPublicIpArrayOutput) ToActionsHostedRunnerPublicIpArrayOutputWithContext(ctx context.Context) ActionsHostedRunnerPublicIpArrayOutput { + return o +} + +func (o ActionsHostedRunnerPublicIpArrayOutput) Index(i pulumi.IntInput) ActionsHostedRunnerPublicIpOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) ActionsHostedRunnerPublicIp { + return vs[0].([]ActionsHostedRunnerPublicIp)[vs[1].(int)] + }).(ActionsHostedRunnerPublicIpOutput) +} + +type ActionsOrganizationPermissionsAllowedActionsConfig struct { + // Whether GitHub-owned actions are allowed in the organization. + GithubOwnedAllowed bool `pulumi:"githubOwnedAllowed"` + // Specifies a list of string-matching patterns to allow specific action(s). Wildcards, tags, and SHAs are allowed. For example, monalisa/octocat@*, monalisa/octocat@v2, monalisa/*." + PatternsAlloweds []string `pulumi:"patternsAlloweds"` + // Whether actions in GitHub Marketplace from verified creators are allowed. Set to true to allow all GitHub Marketplace actions by verified creators. + VerifiedAllowed *bool `pulumi:"verifiedAllowed"` +} + +// ActionsOrganizationPermissionsAllowedActionsConfigInput is an input type that accepts ActionsOrganizationPermissionsAllowedActionsConfigArgs and ActionsOrganizationPermissionsAllowedActionsConfigOutput values. +// You can construct a concrete instance of `ActionsOrganizationPermissionsAllowedActionsConfigInput` via: +// +// ActionsOrganizationPermissionsAllowedActionsConfigArgs{...} +type ActionsOrganizationPermissionsAllowedActionsConfigInput interface { + pulumi.Input + + ToActionsOrganizationPermissionsAllowedActionsConfigOutput() ActionsOrganizationPermissionsAllowedActionsConfigOutput + ToActionsOrganizationPermissionsAllowedActionsConfigOutputWithContext(context.Context) ActionsOrganizationPermissionsAllowedActionsConfigOutput +} + +type ActionsOrganizationPermissionsAllowedActionsConfigArgs struct { + // Whether GitHub-owned actions are allowed in the organization. + GithubOwnedAllowed pulumi.BoolInput `pulumi:"githubOwnedAllowed"` + // Specifies a list of string-matching patterns to allow specific action(s). Wildcards, tags, and SHAs are allowed. For example, monalisa/octocat@*, monalisa/octocat@v2, monalisa/*." + PatternsAlloweds pulumi.StringArrayInput `pulumi:"patternsAlloweds"` + // Whether actions in GitHub Marketplace from verified creators are allowed. Set to true to allow all GitHub Marketplace actions by verified creators. + VerifiedAllowed pulumi.BoolPtrInput `pulumi:"verifiedAllowed"` +} + +func (ActionsOrganizationPermissionsAllowedActionsConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ActionsOrganizationPermissionsAllowedActionsConfig)(nil)).Elem() +} + +func (i ActionsOrganizationPermissionsAllowedActionsConfigArgs) ToActionsOrganizationPermissionsAllowedActionsConfigOutput() ActionsOrganizationPermissionsAllowedActionsConfigOutput { + return i.ToActionsOrganizationPermissionsAllowedActionsConfigOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationPermissionsAllowedActionsConfigArgs) ToActionsOrganizationPermissionsAllowedActionsConfigOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsAllowedActionsConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationPermissionsAllowedActionsConfigOutput) +} + +func (i ActionsOrganizationPermissionsAllowedActionsConfigArgs) ToActionsOrganizationPermissionsAllowedActionsConfigPtrOutput() ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput { + return i.ToActionsOrganizationPermissionsAllowedActionsConfigPtrOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationPermissionsAllowedActionsConfigArgs) ToActionsOrganizationPermissionsAllowedActionsConfigPtrOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationPermissionsAllowedActionsConfigOutput).ToActionsOrganizationPermissionsAllowedActionsConfigPtrOutputWithContext(ctx) +} + +// ActionsOrganizationPermissionsAllowedActionsConfigPtrInput is an input type that accepts ActionsOrganizationPermissionsAllowedActionsConfigArgs, ActionsOrganizationPermissionsAllowedActionsConfigPtr and ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput values. +// You can construct a concrete instance of `ActionsOrganizationPermissionsAllowedActionsConfigPtrInput` via: +// +// ActionsOrganizationPermissionsAllowedActionsConfigArgs{...} +// +// or: +// +// nil +type ActionsOrganizationPermissionsAllowedActionsConfigPtrInput interface { + pulumi.Input + + ToActionsOrganizationPermissionsAllowedActionsConfigPtrOutput() ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput + ToActionsOrganizationPermissionsAllowedActionsConfigPtrOutputWithContext(context.Context) ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput +} + +type actionsOrganizationPermissionsAllowedActionsConfigPtrType ActionsOrganizationPermissionsAllowedActionsConfigArgs + +func ActionsOrganizationPermissionsAllowedActionsConfigPtr(v *ActionsOrganizationPermissionsAllowedActionsConfigArgs) ActionsOrganizationPermissionsAllowedActionsConfigPtrInput { + return (*actionsOrganizationPermissionsAllowedActionsConfigPtrType)(v) +} + +func (*actionsOrganizationPermissionsAllowedActionsConfigPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationPermissionsAllowedActionsConfig)(nil)).Elem() +} + +func (i *actionsOrganizationPermissionsAllowedActionsConfigPtrType) ToActionsOrganizationPermissionsAllowedActionsConfigPtrOutput() ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput { + return i.ToActionsOrganizationPermissionsAllowedActionsConfigPtrOutputWithContext(context.Background()) +} + +func (i *actionsOrganizationPermissionsAllowedActionsConfigPtrType) ToActionsOrganizationPermissionsAllowedActionsConfigPtrOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput) +} + +type ActionsOrganizationPermissionsAllowedActionsConfigOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationPermissionsAllowedActionsConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ActionsOrganizationPermissionsAllowedActionsConfig)(nil)).Elem() +} + +func (o ActionsOrganizationPermissionsAllowedActionsConfigOutput) ToActionsOrganizationPermissionsAllowedActionsConfigOutput() ActionsOrganizationPermissionsAllowedActionsConfigOutput { + return o +} + +func (o ActionsOrganizationPermissionsAllowedActionsConfigOutput) ToActionsOrganizationPermissionsAllowedActionsConfigOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsAllowedActionsConfigOutput { + return o +} + +func (o ActionsOrganizationPermissionsAllowedActionsConfigOutput) ToActionsOrganizationPermissionsAllowedActionsConfigPtrOutput() ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput { + return o.ToActionsOrganizationPermissionsAllowedActionsConfigPtrOutputWithContext(context.Background()) +} + +func (o ActionsOrganizationPermissionsAllowedActionsConfigOutput) ToActionsOrganizationPermissionsAllowedActionsConfigPtrOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v ActionsOrganizationPermissionsAllowedActionsConfig) *ActionsOrganizationPermissionsAllowedActionsConfig { + return &v + }).(ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput) +} + +// Whether GitHub-owned actions are allowed in the organization. +func (o ActionsOrganizationPermissionsAllowedActionsConfigOutput) GithubOwnedAllowed() pulumi.BoolOutput { + return o.ApplyT(func(v ActionsOrganizationPermissionsAllowedActionsConfig) bool { return v.GithubOwnedAllowed }).(pulumi.BoolOutput) +} + +// Specifies a list of string-matching patterns to allow specific action(s). Wildcards, tags, and SHAs are allowed. For example, monalisa/octocat@*, monalisa/octocat@v2, monalisa/*." +func (o ActionsOrganizationPermissionsAllowedActionsConfigOutput) PatternsAlloweds() pulumi.StringArrayOutput { + return o.ApplyT(func(v ActionsOrganizationPermissionsAllowedActionsConfig) []string { return v.PatternsAlloweds }).(pulumi.StringArrayOutput) +} + +// Whether actions in GitHub Marketplace from verified creators are allowed. Set to true to allow all GitHub Marketplace actions by verified creators. +func (o ActionsOrganizationPermissionsAllowedActionsConfigOutput) VerifiedAllowed() pulumi.BoolPtrOutput { + return o.ApplyT(func(v ActionsOrganizationPermissionsAllowedActionsConfig) *bool { return v.VerifiedAllowed }).(pulumi.BoolPtrOutput) +} + +type ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationPermissionsAllowedActionsConfig)(nil)).Elem() +} + +func (o ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput) ToActionsOrganizationPermissionsAllowedActionsConfigPtrOutput() ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput { + return o +} + +func (o ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput) ToActionsOrganizationPermissionsAllowedActionsConfigPtrOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput { + return o +} + +func (o ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput) Elem() ActionsOrganizationPermissionsAllowedActionsConfigOutput { + return o.ApplyT(func(v *ActionsOrganizationPermissionsAllowedActionsConfig) ActionsOrganizationPermissionsAllowedActionsConfig { + if v != nil { + return *v + } + var ret ActionsOrganizationPermissionsAllowedActionsConfig + return ret + }).(ActionsOrganizationPermissionsAllowedActionsConfigOutput) +} + +// Whether GitHub-owned actions are allowed in the organization. +func (o ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput) GithubOwnedAllowed() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ActionsOrganizationPermissionsAllowedActionsConfig) *bool { + if v == nil { + return nil + } + return &v.GithubOwnedAllowed + }).(pulumi.BoolPtrOutput) +} + +// Specifies a list of string-matching patterns to allow specific action(s). Wildcards, tags, and SHAs are allowed. For example, monalisa/octocat@*, monalisa/octocat@v2, monalisa/*." +func (o ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput) PatternsAlloweds() pulumi.StringArrayOutput { + return o.ApplyT(func(v *ActionsOrganizationPermissionsAllowedActionsConfig) []string { + if v == nil { + return nil + } + return v.PatternsAlloweds + }).(pulumi.StringArrayOutput) +} + +// Whether actions in GitHub Marketplace from verified creators are allowed. Set to true to allow all GitHub Marketplace actions by verified creators. +func (o ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput) VerifiedAllowed() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ActionsOrganizationPermissionsAllowedActionsConfig) *bool { + if v == nil { + return nil + } + return v.VerifiedAllowed + }).(pulumi.BoolPtrOutput) +} + +type ActionsOrganizationPermissionsEnabledRepositoriesConfig struct { + // List of repository IDs to enable for GitHub Actions. + RepositoryIds []int `pulumi:"repositoryIds"` +} + +// ActionsOrganizationPermissionsEnabledRepositoriesConfigInput is an input type that accepts ActionsOrganizationPermissionsEnabledRepositoriesConfigArgs and ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput values. +// You can construct a concrete instance of `ActionsOrganizationPermissionsEnabledRepositoriesConfigInput` via: +// +// ActionsOrganizationPermissionsEnabledRepositoriesConfigArgs{...} +type ActionsOrganizationPermissionsEnabledRepositoriesConfigInput interface { + pulumi.Input + + ToActionsOrganizationPermissionsEnabledRepositoriesConfigOutput() ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput + ToActionsOrganizationPermissionsEnabledRepositoriesConfigOutputWithContext(context.Context) ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput +} + +type ActionsOrganizationPermissionsEnabledRepositoriesConfigArgs struct { + // List of repository IDs to enable for GitHub Actions. + RepositoryIds pulumi.IntArrayInput `pulumi:"repositoryIds"` +} + +func (ActionsOrganizationPermissionsEnabledRepositoriesConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ActionsOrganizationPermissionsEnabledRepositoriesConfig)(nil)).Elem() +} + +func (i ActionsOrganizationPermissionsEnabledRepositoriesConfigArgs) ToActionsOrganizationPermissionsEnabledRepositoriesConfigOutput() ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput { + return i.ToActionsOrganizationPermissionsEnabledRepositoriesConfigOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationPermissionsEnabledRepositoriesConfigArgs) ToActionsOrganizationPermissionsEnabledRepositoriesConfigOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput) +} + +func (i ActionsOrganizationPermissionsEnabledRepositoriesConfigArgs) ToActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput() ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput { + return i.ToActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutputWithContext(context.Background()) +} + +func (i ActionsOrganizationPermissionsEnabledRepositoriesConfigArgs) ToActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput).ToActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutputWithContext(ctx) +} + +// ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrInput is an input type that accepts ActionsOrganizationPermissionsEnabledRepositoriesConfigArgs, ActionsOrganizationPermissionsEnabledRepositoriesConfigPtr and ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput values. +// You can construct a concrete instance of `ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrInput` via: +// +// ActionsOrganizationPermissionsEnabledRepositoriesConfigArgs{...} +// +// or: +// +// nil +type ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrInput interface { + pulumi.Input + + ToActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput() ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput + ToActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutputWithContext(context.Context) ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput +} + +type actionsOrganizationPermissionsEnabledRepositoriesConfigPtrType ActionsOrganizationPermissionsEnabledRepositoriesConfigArgs + +func ActionsOrganizationPermissionsEnabledRepositoriesConfigPtr(v *ActionsOrganizationPermissionsEnabledRepositoriesConfigArgs) ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrInput { + return (*actionsOrganizationPermissionsEnabledRepositoriesConfigPtrType)(v) +} + +func (*actionsOrganizationPermissionsEnabledRepositoriesConfigPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationPermissionsEnabledRepositoriesConfig)(nil)).Elem() +} + +func (i *actionsOrganizationPermissionsEnabledRepositoriesConfigPtrType) ToActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput() ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput { + return i.ToActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutputWithContext(context.Background()) +} + +func (i *actionsOrganizationPermissionsEnabledRepositoriesConfigPtrType) ToActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput) +} + +type ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ActionsOrganizationPermissionsEnabledRepositoriesConfig)(nil)).Elem() +} + +func (o ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput) ToActionsOrganizationPermissionsEnabledRepositoriesConfigOutput() ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput { + return o +} + +func (o ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput) ToActionsOrganizationPermissionsEnabledRepositoriesConfigOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput { + return o +} + +func (o ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput) ToActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput() ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput { + return o.ToActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutputWithContext(context.Background()) +} + +func (o ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput) ToActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v ActionsOrganizationPermissionsEnabledRepositoriesConfig) *ActionsOrganizationPermissionsEnabledRepositoriesConfig { + return &v + }).(ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput) +} + +// List of repository IDs to enable for GitHub Actions. +func (o ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput) RepositoryIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v ActionsOrganizationPermissionsEnabledRepositoriesConfig) []int { return v.RepositoryIds }).(pulumi.IntArrayOutput) +} + +type ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput struct{ *pulumi.OutputState } + +func (ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsOrganizationPermissionsEnabledRepositoriesConfig)(nil)).Elem() +} + +func (o ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput) ToActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput() ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput { + return o +} + +func (o ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput) ToActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutputWithContext(ctx context.Context) ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput { + return o +} + +func (o ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput) Elem() ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput { + return o.ApplyT(func(v *ActionsOrganizationPermissionsEnabledRepositoriesConfig) ActionsOrganizationPermissionsEnabledRepositoriesConfig { + if v != nil { + return *v + } + var ret ActionsOrganizationPermissionsEnabledRepositoriesConfig + return ret + }).(ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput) +} + +// List of repository IDs to enable for GitHub Actions. +func (o ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput) RepositoryIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v *ActionsOrganizationPermissionsEnabledRepositoriesConfig) []int { + if v == nil { + return nil + } + return v.RepositoryIds + }).(pulumi.IntArrayOutput) +} + +type ActionsRepositoryPermissionsAllowedActionsConfig struct { + // Whether GitHub-owned actions are allowed in the repository. + GithubOwnedAllowed bool `pulumi:"githubOwnedAllowed"` + // Specifies a list of string-matching patterns to allow specific action(s). Wildcards, tags, and SHAs are allowed. For example, monalisa/octocat@*, monalisa/octocat@v2, monalisa/*." + PatternsAlloweds []string `pulumi:"patternsAlloweds"` + // Whether actions in GitHub Marketplace from verified creators are allowed. Set to true to allow all GitHub Marketplace actions by verified creators. + VerifiedAllowed *bool `pulumi:"verifiedAllowed"` +} + +// ActionsRepositoryPermissionsAllowedActionsConfigInput is an input type that accepts ActionsRepositoryPermissionsAllowedActionsConfigArgs and ActionsRepositoryPermissionsAllowedActionsConfigOutput values. +// You can construct a concrete instance of `ActionsRepositoryPermissionsAllowedActionsConfigInput` via: +// +// ActionsRepositoryPermissionsAllowedActionsConfigArgs{...} +type ActionsRepositoryPermissionsAllowedActionsConfigInput interface { + pulumi.Input + + ToActionsRepositoryPermissionsAllowedActionsConfigOutput() ActionsRepositoryPermissionsAllowedActionsConfigOutput + ToActionsRepositoryPermissionsAllowedActionsConfigOutputWithContext(context.Context) ActionsRepositoryPermissionsAllowedActionsConfigOutput +} + +type ActionsRepositoryPermissionsAllowedActionsConfigArgs struct { + // Whether GitHub-owned actions are allowed in the repository. + GithubOwnedAllowed pulumi.BoolInput `pulumi:"githubOwnedAllowed"` + // Specifies a list of string-matching patterns to allow specific action(s). Wildcards, tags, and SHAs are allowed. For example, monalisa/octocat@*, monalisa/octocat@v2, monalisa/*." + PatternsAlloweds pulumi.StringArrayInput `pulumi:"patternsAlloweds"` + // Whether actions in GitHub Marketplace from verified creators are allowed. Set to true to allow all GitHub Marketplace actions by verified creators. + VerifiedAllowed pulumi.BoolPtrInput `pulumi:"verifiedAllowed"` +} + +func (ActionsRepositoryPermissionsAllowedActionsConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ActionsRepositoryPermissionsAllowedActionsConfig)(nil)).Elem() +} + +func (i ActionsRepositoryPermissionsAllowedActionsConfigArgs) ToActionsRepositoryPermissionsAllowedActionsConfigOutput() ActionsRepositoryPermissionsAllowedActionsConfigOutput { + return i.ToActionsRepositoryPermissionsAllowedActionsConfigOutputWithContext(context.Background()) +} + +func (i ActionsRepositoryPermissionsAllowedActionsConfigArgs) ToActionsRepositoryPermissionsAllowedActionsConfigOutputWithContext(ctx context.Context) ActionsRepositoryPermissionsAllowedActionsConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsRepositoryPermissionsAllowedActionsConfigOutput) +} + +func (i ActionsRepositoryPermissionsAllowedActionsConfigArgs) ToActionsRepositoryPermissionsAllowedActionsConfigPtrOutput() ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput { + return i.ToActionsRepositoryPermissionsAllowedActionsConfigPtrOutputWithContext(context.Background()) +} + +func (i ActionsRepositoryPermissionsAllowedActionsConfigArgs) ToActionsRepositoryPermissionsAllowedActionsConfigPtrOutputWithContext(ctx context.Context) ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsRepositoryPermissionsAllowedActionsConfigOutput).ToActionsRepositoryPermissionsAllowedActionsConfigPtrOutputWithContext(ctx) +} + +// ActionsRepositoryPermissionsAllowedActionsConfigPtrInput is an input type that accepts ActionsRepositoryPermissionsAllowedActionsConfigArgs, ActionsRepositoryPermissionsAllowedActionsConfigPtr and ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput values. +// You can construct a concrete instance of `ActionsRepositoryPermissionsAllowedActionsConfigPtrInput` via: +// +// ActionsRepositoryPermissionsAllowedActionsConfigArgs{...} +// +// or: +// +// nil +type ActionsRepositoryPermissionsAllowedActionsConfigPtrInput interface { + pulumi.Input + + ToActionsRepositoryPermissionsAllowedActionsConfigPtrOutput() ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput + ToActionsRepositoryPermissionsAllowedActionsConfigPtrOutputWithContext(context.Context) ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput +} + +type actionsRepositoryPermissionsAllowedActionsConfigPtrType ActionsRepositoryPermissionsAllowedActionsConfigArgs + +func ActionsRepositoryPermissionsAllowedActionsConfigPtr(v *ActionsRepositoryPermissionsAllowedActionsConfigArgs) ActionsRepositoryPermissionsAllowedActionsConfigPtrInput { + return (*actionsRepositoryPermissionsAllowedActionsConfigPtrType)(v) +} + +func (*actionsRepositoryPermissionsAllowedActionsConfigPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsRepositoryPermissionsAllowedActionsConfig)(nil)).Elem() +} + +func (i *actionsRepositoryPermissionsAllowedActionsConfigPtrType) ToActionsRepositoryPermissionsAllowedActionsConfigPtrOutput() ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput { + return i.ToActionsRepositoryPermissionsAllowedActionsConfigPtrOutputWithContext(context.Background()) +} + +func (i *actionsRepositoryPermissionsAllowedActionsConfigPtrType) ToActionsRepositoryPermissionsAllowedActionsConfigPtrOutputWithContext(ctx context.Context) ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput) +} + +type ActionsRepositoryPermissionsAllowedActionsConfigOutput struct{ *pulumi.OutputState } + +func (ActionsRepositoryPermissionsAllowedActionsConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ActionsRepositoryPermissionsAllowedActionsConfig)(nil)).Elem() +} + +func (o ActionsRepositoryPermissionsAllowedActionsConfigOutput) ToActionsRepositoryPermissionsAllowedActionsConfigOutput() ActionsRepositoryPermissionsAllowedActionsConfigOutput { + return o +} + +func (o ActionsRepositoryPermissionsAllowedActionsConfigOutput) ToActionsRepositoryPermissionsAllowedActionsConfigOutputWithContext(ctx context.Context) ActionsRepositoryPermissionsAllowedActionsConfigOutput { + return o +} + +func (o ActionsRepositoryPermissionsAllowedActionsConfigOutput) ToActionsRepositoryPermissionsAllowedActionsConfigPtrOutput() ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput { + return o.ToActionsRepositoryPermissionsAllowedActionsConfigPtrOutputWithContext(context.Background()) +} + +func (o ActionsRepositoryPermissionsAllowedActionsConfigOutput) ToActionsRepositoryPermissionsAllowedActionsConfigPtrOutputWithContext(ctx context.Context) ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v ActionsRepositoryPermissionsAllowedActionsConfig) *ActionsRepositoryPermissionsAllowedActionsConfig { + return &v + }).(ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput) +} + +// Whether GitHub-owned actions are allowed in the repository. +func (o ActionsRepositoryPermissionsAllowedActionsConfigOutput) GithubOwnedAllowed() pulumi.BoolOutput { + return o.ApplyT(func(v ActionsRepositoryPermissionsAllowedActionsConfig) bool { return v.GithubOwnedAllowed }).(pulumi.BoolOutput) +} + +// Specifies a list of string-matching patterns to allow specific action(s). Wildcards, tags, and SHAs are allowed. For example, monalisa/octocat@*, monalisa/octocat@v2, monalisa/*." +func (o ActionsRepositoryPermissionsAllowedActionsConfigOutput) PatternsAlloweds() pulumi.StringArrayOutput { + return o.ApplyT(func(v ActionsRepositoryPermissionsAllowedActionsConfig) []string { return v.PatternsAlloweds }).(pulumi.StringArrayOutput) +} + +// Whether actions in GitHub Marketplace from verified creators are allowed. Set to true to allow all GitHub Marketplace actions by verified creators. +func (o ActionsRepositoryPermissionsAllowedActionsConfigOutput) VerifiedAllowed() pulumi.BoolPtrOutput { + return o.ApplyT(func(v ActionsRepositoryPermissionsAllowedActionsConfig) *bool { return v.VerifiedAllowed }).(pulumi.BoolPtrOutput) +} + +type ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput struct{ *pulumi.OutputState } + +func (ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ActionsRepositoryPermissionsAllowedActionsConfig)(nil)).Elem() +} + +func (o ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput) ToActionsRepositoryPermissionsAllowedActionsConfigPtrOutput() ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput { + return o +} + +func (o ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput) ToActionsRepositoryPermissionsAllowedActionsConfigPtrOutputWithContext(ctx context.Context) ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput { + return o +} + +func (o ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput) Elem() ActionsRepositoryPermissionsAllowedActionsConfigOutput { + return o.ApplyT(func(v *ActionsRepositoryPermissionsAllowedActionsConfig) ActionsRepositoryPermissionsAllowedActionsConfig { + if v != nil { + return *v + } + var ret ActionsRepositoryPermissionsAllowedActionsConfig + return ret + }).(ActionsRepositoryPermissionsAllowedActionsConfigOutput) +} + +// Whether GitHub-owned actions are allowed in the repository. +func (o ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput) GithubOwnedAllowed() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ActionsRepositoryPermissionsAllowedActionsConfig) *bool { + if v == nil { + return nil + } + return &v.GithubOwnedAllowed + }).(pulumi.BoolPtrOutput) +} + +// Specifies a list of string-matching patterns to allow specific action(s). Wildcards, tags, and SHAs are allowed. For example, monalisa/octocat@*, monalisa/octocat@v2, monalisa/*." +func (o ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput) PatternsAlloweds() pulumi.StringArrayOutput { + return o.ApplyT(func(v *ActionsRepositoryPermissionsAllowedActionsConfig) []string { + if v == nil { + return nil + } + return v.PatternsAlloweds + }).(pulumi.StringArrayOutput) +} + +// Whether actions in GitHub Marketplace from verified creators are allowed. Set to true to allow all GitHub Marketplace actions by verified creators. +func (o ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput) VerifiedAllowed() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *ActionsRepositoryPermissionsAllowedActionsConfig) *bool { + if v == nil { + return nil + } + return v.VerifiedAllowed + }).(pulumi.BoolPtrOutput) +} + +type BranchProtectionRequiredPullRequestReview struct { + // Dismiss approved reviews automatically when a new commit is pushed. Defaults to `false`. + DismissStaleReviews *bool `pulumi:"dismissStaleReviews"` + // The list of actor Names/IDs with dismissal access. If not empty, `restrictDismissals` is ignored. Actor names must either begin with a "/" for users or the organization name followed by a "/" for teams. + DismissalRestrictions []string `pulumi:"dismissalRestrictions"` + // The list of actor Names/IDs that are allowed to bypass pull request requirements. Actor names must either begin with a "/" for users or the organization name followed by a "/" for teams. + PullRequestBypassers []string `pulumi:"pullRequestBypassers"` + // Require an approved review in pull requests including files with a designated code owner. Defaults to `false`. + RequireCodeOwnerReviews *bool `pulumi:"requireCodeOwnerReviews"` + // Require that The most recent push must be approved by someone other than the last pusher. Defaults to `false` + RequireLastPushApproval *bool `pulumi:"requireLastPushApproval"` + // Require x number of approvals to satisfy branch protection requirements. If this is specified it must be a number between 0-6. This requirement matches GitHub's API, see the upstream [documentation](https://developer.github.com/v3/repos/branches/#parameters-1) for more information. + // (https://developer.github.com/v3/repos/branches/#parameters-1) for more information. + RequiredApprovingReviewCount *int `pulumi:"requiredApprovingReviewCount"` + // Restrict pull request review dismissals. + RestrictDismissals *bool `pulumi:"restrictDismissals"` +} + +// BranchProtectionRequiredPullRequestReviewInput is an input type that accepts BranchProtectionRequiredPullRequestReviewArgs and BranchProtectionRequiredPullRequestReviewOutput values. +// You can construct a concrete instance of `BranchProtectionRequiredPullRequestReviewInput` via: +// +// BranchProtectionRequiredPullRequestReviewArgs{...} +type BranchProtectionRequiredPullRequestReviewInput interface { + pulumi.Input + + ToBranchProtectionRequiredPullRequestReviewOutput() BranchProtectionRequiredPullRequestReviewOutput + ToBranchProtectionRequiredPullRequestReviewOutputWithContext(context.Context) BranchProtectionRequiredPullRequestReviewOutput +} + +type BranchProtectionRequiredPullRequestReviewArgs struct { + // Dismiss approved reviews automatically when a new commit is pushed. Defaults to `false`. + DismissStaleReviews pulumi.BoolPtrInput `pulumi:"dismissStaleReviews"` + // The list of actor Names/IDs with dismissal access. If not empty, `restrictDismissals` is ignored. Actor names must either begin with a "/" for users or the organization name followed by a "/" for teams. + DismissalRestrictions pulumi.StringArrayInput `pulumi:"dismissalRestrictions"` + // The list of actor Names/IDs that are allowed to bypass pull request requirements. Actor names must either begin with a "/" for users or the organization name followed by a "/" for teams. + PullRequestBypassers pulumi.StringArrayInput `pulumi:"pullRequestBypassers"` + // Require an approved review in pull requests including files with a designated code owner. Defaults to `false`. + RequireCodeOwnerReviews pulumi.BoolPtrInput `pulumi:"requireCodeOwnerReviews"` + // Require that The most recent push must be approved by someone other than the last pusher. Defaults to `false` + RequireLastPushApproval pulumi.BoolPtrInput `pulumi:"requireLastPushApproval"` + // Require x number of approvals to satisfy branch protection requirements. If this is specified it must be a number between 0-6. This requirement matches GitHub's API, see the upstream [documentation](https://developer.github.com/v3/repos/branches/#parameters-1) for more information. + // (https://developer.github.com/v3/repos/branches/#parameters-1) for more information. + RequiredApprovingReviewCount pulumi.IntPtrInput `pulumi:"requiredApprovingReviewCount"` + // Restrict pull request review dismissals. + RestrictDismissals pulumi.BoolPtrInput `pulumi:"restrictDismissals"` +} + +func (BranchProtectionRequiredPullRequestReviewArgs) ElementType() reflect.Type { + return reflect.TypeOf((*BranchProtectionRequiredPullRequestReview)(nil)).Elem() +} + +func (i BranchProtectionRequiredPullRequestReviewArgs) ToBranchProtectionRequiredPullRequestReviewOutput() BranchProtectionRequiredPullRequestReviewOutput { + return i.ToBranchProtectionRequiredPullRequestReviewOutputWithContext(context.Background()) +} + +func (i BranchProtectionRequiredPullRequestReviewArgs) ToBranchProtectionRequiredPullRequestReviewOutputWithContext(ctx context.Context) BranchProtectionRequiredPullRequestReviewOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionRequiredPullRequestReviewOutput) +} + +// BranchProtectionRequiredPullRequestReviewArrayInput is an input type that accepts BranchProtectionRequiredPullRequestReviewArray and BranchProtectionRequiredPullRequestReviewArrayOutput values. +// You can construct a concrete instance of `BranchProtectionRequiredPullRequestReviewArrayInput` via: +// +// BranchProtectionRequiredPullRequestReviewArray{ BranchProtectionRequiredPullRequestReviewArgs{...} } +type BranchProtectionRequiredPullRequestReviewArrayInput interface { + pulumi.Input + + ToBranchProtectionRequiredPullRequestReviewArrayOutput() BranchProtectionRequiredPullRequestReviewArrayOutput + ToBranchProtectionRequiredPullRequestReviewArrayOutputWithContext(context.Context) BranchProtectionRequiredPullRequestReviewArrayOutput +} + +type BranchProtectionRequiredPullRequestReviewArray []BranchProtectionRequiredPullRequestReviewInput + +func (BranchProtectionRequiredPullRequestReviewArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]BranchProtectionRequiredPullRequestReview)(nil)).Elem() +} + +func (i BranchProtectionRequiredPullRequestReviewArray) ToBranchProtectionRequiredPullRequestReviewArrayOutput() BranchProtectionRequiredPullRequestReviewArrayOutput { + return i.ToBranchProtectionRequiredPullRequestReviewArrayOutputWithContext(context.Background()) +} + +func (i BranchProtectionRequiredPullRequestReviewArray) ToBranchProtectionRequiredPullRequestReviewArrayOutputWithContext(ctx context.Context) BranchProtectionRequiredPullRequestReviewArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionRequiredPullRequestReviewArrayOutput) +} + +type BranchProtectionRequiredPullRequestReviewOutput struct{ *pulumi.OutputState } + +func (BranchProtectionRequiredPullRequestReviewOutput) ElementType() reflect.Type { + return reflect.TypeOf((*BranchProtectionRequiredPullRequestReview)(nil)).Elem() +} + +func (o BranchProtectionRequiredPullRequestReviewOutput) ToBranchProtectionRequiredPullRequestReviewOutput() BranchProtectionRequiredPullRequestReviewOutput { + return o +} + +func (o BranchProtectionRequiredPullRequestReviewOutput) ToBranchProtectionRequiredPullRequestReviewOutputWithContext(ctx context.Context) BranchProtectionRequiredPullRequestReviewOutput { + return o +} + +// Dismiss approved reviews automatically when a new commit is pushed. Defaults to `false`. +func (o BranchProtectionRequiredPullRequestReviewOutput) DismissStaleReviews() pulumi.BoolPtrOutput { + return o.ApplyT(func(v BranchProtectionRequiredPullRequestReview) *bool { return v.DismissStaleReviews }).(pulumi.BoolPtrOutput) +} + +// The list of actor Names/IDs with dismissal access. If not empty, `restrictDismissals` is ignored. Actor names must either begin with a "/" for users or the organization name followed by a "/" for teams. +func (o BranchProtectionRequiredPullRequestReviewOutput) DismissalRestrictions() pulumi.StringArrayOutput { + return o.ApplyT(func(v BranchProtectionRequiredPullRequestReview) []string { return v.DismissalRestrictions }).(pulumi.StringArrayOutput) +} + +// The list of actor Names/IDs that are allowed to bypass pull request requirements. Actor names must either begin with a "/" for users or the organization name followed by a "/" for teams. +func (o BranchProtectionRequiredPullRequestReviewOutput) PullRequestBypassers() pulumi.StringArrayOutput { + return o.ApplyT(func(v BranchProtectionRequiredPullRequestReview) []string { return v.PullRequestBypassers }).(pulumi.StringArrayOutput) +} + +// Require an approved review in pull requests including files with a designated code owner. Defaults to `false`. +func (o BranchProtectionRequiredPullRequestReviewOutput) RequireCodeOwnerReviews() pulumi.BoolPtrOutput { + return o.ApplyT(func(v BranchProtectionRequiredPullRequestReview) *bool { return v.RequireCodeOwnerReviews }).(pulumi.BoolPtrOutput) +} + +// Require that The most recent push must be approved by someone other than the last pusher. Defaults to `false` +func (o BranchProtectionRequiredPullRequestReviewOutput) RequireLastPushApproval() pulumi.BoolPtrOutput { + return o.ApplyT(func(v BranchProtectionRequiredPullRequestReview) *bool { return v.RequireLastPushApproval }).(pulumi.BoolPtrOutput) +} + +// Require x number of approvals to satisfy branch protection requirements. If this is specified it must be a number between 0-6. This requirement matches GitHub's API, see the upstream [documentation](https://developer.github.com/v3/repos/branches/#parameters-1) for more information. +// (https://developer.github.com/v3/repos/branches/#parameters-1) for more information. +func (o BranchProtectionRequiredPullRequestReviewOutput) RequiredApprovingReviewCount() pulumi.IntPtrOutput { + return o.ApplyT(func(v BranchProtectionRequiredPullRequestReview) *int { return v.RequiredApprovingReviewCount }).(pulumi.IntPtrOutput) +} + +// Restrict pull request review dismissals. +func (o BranchProtectionRequiredPullRequestReviewOutput) RestrictDismissals() pulumi.BoolPtrOutput { + return o.ApplyT(func(v BranchProtectionRequiredPullRequestReview) *bool { return v.RestrictDismissals }).(pulumi.BoolPtrOutput) +} + +type BranchProtectionRequiredPullRequestReviewArrayOutput struct{ *pulumi.OutputState } + +func (BranchProtectionRequiredPullRequestReviewArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]BranchProtectionRequiredPullRequestReview)(nil)).Elem() +} + +func (o BranchProtectionRequiredPullRequestReviewArrayOutput) ToBranchProtectionRequiredPullRequestReviewArrayOutput() BranchProtectionRequiredPullRequestReviewArrayOutput { + return o +} + +func (o BranchProtectionRequiredPullRequestReviewArrayOutput) ToBranchProtectionRequiredPullRequestReviewArrayOutputWithContext(ctx context.Context) BranchProtectionRequiredPullRequestReviewArrayOutput { + return o +} + +func (o BranchProtectionRequiredPullRequestReviewArrayOutput) Index(i pulumi.IntInput) BranchProtectionRequiredPullRequestReviewOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) BranchProtectionRequiredPullRequestReview { + return vs[0].([]BranchProtectionRequiredPullRequestReview)[vs[1].(int)] + }).(BranchProtectionRequiredPullRequestReviewOutput) +} + +type BranchProtectionRequiredStatusCheck struct { + // The list of status checks to require in order to merge into this branch. No status checks are required by default. + // + // > Note: This attribute can contain multiple string patterns. + // If specified, usual value is the [job name](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idname). Otherwise, the [job id](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idname) is defaulted to. + // For workflows that use matrixes, append the matrix name to the value using the following pattern `([, ])`. Matrixes should be specified based on the order of matrix properties in the workflow file. See GitHub Documentation for more information. + // For workflows that use reusable workflows, the pattern is ` / `. This can extend multiple levels. + Contexts []string `pulumi:"contexts"` + // Require branches to be up to date before merging. Defaults to `false`. + Strict *bool `pulumi:"strict"` +} + +// BranchProtectionRequiredStatusCheckInput is an input type that accepts BranchProtectionRequiredStatusCheckArgs and BranchProtectionRequiredStatusCheckOutput values. +// You can construct a concrete instance of `BranchProtectionRequiredStatusCheckInput` via: +// +// BranchProtectionRequiredStatusCheckArgs{...} +type BranchProtectionRequiredStatusCheckInput interface { + pulumi.Input + + ToBranchProtectionRequiredStatusCheckOutput() BranchProtectionRequiredStatusCheckOutput + ToBranchProtectionRequiredStatusCheckOutputWithContext(context.Context) BranchProtectionRequiredStatusCheckOutput +} + +type BranchProtectionRequiredStatusCheckArgs struct { + // The list of status checks to require in order to merge into this branch. No status checks are required by default. + // + // > Note: This attribute can contain multiple string patterns. + // If specified, usual value is the [job name](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idname). Otherwise, the [job id](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idname) is defaulted to. + // For workflows that use matrixes, append the matrix name to the value using the following pattern `([, ])`. Matrixes should be specified based on the order of matrix properties in the workflow file. See GitHub Documentation for more information. + // For workflows that use reusable workflows, the pattern is ` / `. This can extend multiple levels. + Contexts pulumi.StringArrayInput `pulumi:"contexts"` + // Require branches to be up to date before merging. Defaults to `false`. + Strict pulumi.BoolPtrInput `pulumi:"strict"` +} + +func (BranchProtectionRequiredStatusCheckArgs) ElementType() reflect.Type { + return reflect.TypeOf((*BranchProtectionRequiredStatusCheck)(nil)).Elem() +} + +func (i BranchProtectionRequiredStatusCheckArgs) ToBranchProtectionRequiredStatusCheckOutput() BranchProtectionRequiredStatusCheckOutput { + return i.ToBranchProtectionRequiredStatusCheckOutputWithContext(context.Background()) +} + +func (i BranchProtectionRequiredStatusCheckArgs) ToBranchProtectionRequiredStatusCheckOutputWithContext(ctx context.Context) BranchProtectionRequiredStatusCheckOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionRequiredStatusCheckOutput) +} + +// BranchProtectionRequiredStatusCheckArrayInput is an input type that accepts BranchProtectionRequiredStatusCheckArray and BranchProtectionRequiredStatusCheckArrayOutput values. +// You can construct a concrete instance of `BranchProtectionRequiredStatusCheckArrayInput` via: +// +// BranchProtectionRequiredStatusCheckArray{ BranchProtectionRequiredStatusCheckArgs{...} } +type BranchProtectionRequiredStatusCheckArrayInput interface { + pulumi.Input + + ToBranchProtectionRequiredStatusCheckArrayOutput() BranchProtectionRequiredStatusCheckArrayOutput + ToBranchProtectionRequiredStatusCheckArrayOutputWithContext(context.Context) BranchProtectionRequiredStatusCheckArrayOutput +} + +type BranchProtectionRequiredStatusCheckArray []BranchProtectionRequiredStatusCheckInput + +func (BranchProtectionRequiredStatusCheckArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]BranchProtectionRequiredStatusCheck)(nil)).Elem() +} + +func (i BranchProtectionRequiredStatusCheckArray) ToBranchProtectionRequiredStatusCheckArrayOutput() BranchProtectionRequiredStatusCheckArrayOutput { + return i.ToBranchProtectionRequiredStatusCheckArrayOutputWithContext(context.Background()) +} + +func (i BranchProtectionRequiredStatusCheckArray) ToBranchProtectionRequiredStatusCheckArrayOutputWithContext(ctx context.Context) BranchProtectionRequiredStatusCheckArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionRequiredStatusCheckArrayOutput) +} + +type BranchProtectionRequiredStatusCheckOutput struct{ *pulumi.OutputState } + +func (BranchProtectionRequiredStatusCheckOutput) ElementType() reflect.Type { + return reflect.TypeOf((*BranchProtectionRequiredStatusCheck)(nil)).Elem() +} + +func (o BranchProtectionRequiredStatusCheckOutput) ToBranchProtectionRequiredStatusCheckOutput() BranchProtectionRequiredStatusCheckOutput { + return o +} + +func (o BranchProtectionRequiredStatusCheckOutput) ToBranchProtectionRequiredStatusCheckOutputWithContext(ctx context.Context) BranchProtectionRequiredStatusCheckOutput { + return o +} + +// The list of status checks to require in order to merge into this branch. No status checks are required by default. +// +// > Note: This attribute can contain multiple string patterns. +// If specified, usual value is the [job name](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idname). Otherwise, the [job id](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idname) is defaulted to. +// For workflows that use matrixes, append the matrix name to the value using the following pattern `([, ])`. Matrixes should be specified based on the order of matrix properties in the workflow file. See GitHub Documentation for more information. +// For workflows that use reusable workflows, the pattern is ` / `. This can extend multiple levels. +func (o BranchProtectionRequiredStatusCheckOutput) Contexts() pulumi.StringArrayOutput { + return o.ApplyT(func(v BranchProtectionRequiredStatusCheck) []string { return v.Contexts }).(pulumi.StringArrayOutput) +} + +// Require branches to be up to date before merging. Defaults to `false`. +func (o BranchProtectionRequiredStatusCheckOutput) Strict() pulumi.BoolPtrOutput { + return o.ApplyT(func(v BranchProtectionRequiredStatusCheck) *bool { return v.Strict }).(pulumi.BoolPtrOutput) +} + +type BranchProtectionRequiredStatusCheckArrayOutput struct{ *pulumi.OutputState } + +func (BranchProtectionRequiredStatusCheckArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]BranchProtectionRequiredStatusCheck)(nil)).Elem() +} + +func (o BranchProtectionRequiredStatusCheckArrayOutput) ToBranchProtectionRequiredStatusCheckArrayOutput() BranchProtectionRequiredStatusCheckArrayOutput { + return o +} + +func (o BranchProtectionRequiredStatusCheckArrayOutput) ToBranchProtectionRequiredStatusCheckArrayOutputWithContext(ctx context.Context) BranchProtectionRequiredStatusCheckArrayOutput { + return o +} + +func (o BranchProtectionRequiredStatusCheckArrayOutput) Index(i pulumi.IntInput) BranchProtectionRequiredStatusCheckOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) BranchProtectionRequiredStatusCheck { + return vs[0].([]BranchProtectionRequiredStatusCheck)[vs[1].(int)] + }).(BranchProtectionRequiredStatusCheckOutput) +} + +type BranchProtectionRestrictPush struct { + // Boolean, setting this to `false` allows people, teams, or apps to create new branches matching this rule. Defaults to `true`. + BlocksCreations *bool `pulumi:"blocksCreations"` + // A list of actor Names/IDs that may push to the branch. Actor names must either begin with a "/" for users or the organization name followed by a "/" for teams. Organization administrators, repository administrators, and users with the Maintain role on the repository can always push when all other requirements have passed. + PushAllowances []string `pulumi:"pushAllowances"` +} + +// BranchProtectionRestrictPushInput is an input type that accepts BranchProtectionRestrictPushArgs and BranchProtectionRestrictPushOutput values. +// You can construct a concrete instance of `BranchProtectionRestrictPushInput` via: +// +// BranchProtectionRestrictPushArgs{...} +type BranchProtectionRestrictPushInput interface { + pulumi.Input + + ToBranchProtectionRestrictPushOutput() BranchProtectionRestrictPushOutput + ToBranchProtectionRestrictPushOutputWithContext(context.Context) BranchProtectionRestrictPushOutput +} + +type BranchProtectionRestrictPushArgs struct { + // Boolean, setting this to `false` allows people, teams, or apps to create new branches matching this rule. Defaults to `true`. + BlocksCreations pulumi.BoolPtrInput `pulumi:"blocksCreations"` + // A list of actor Names/IDs that may push to the branch. Actor names must either begin with a "/" for users or the organization name followed by a "/" for teams. Organization administrators, repository administrators, and users with the Maintain role on the repository can always push when all other requirements have passed. + PushAllowances pulumi.StringArrayInput `pulumi:"pushAllowances"` +} + +func (BranchProtectionRestrictPushArgs) ElementType() reflect.Type { + return reflect.TypeOf((*BranchProtectionRestrictPush)(nil)).Elem() +} + +func (i BranchProtectionRestrictPushArgs) ToBranchProtectionRestrictPushOutput() BranchProtectionRestrictPushOutput { + return i.ToBranchProtectionRestrictPushOutputWithContext(context.Background()) +} + +func (i BranchProtectionRestrictPushArgs) ToBranchProtectionRestrictPushOutputWithContext(ctx context.Context) BranchProtectionRestrictPushOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionRestrictPushOutput) +} + +// BranchProtectionRestrictPushArrayInput is an input type that accepts BranchProtectionRestrictPushArray and BranchProtectionRestrictPushArrayOutput values. +// You can construct a concrete instance of `BranchProtectionRestrictPushArrayInput` via: +// +// BranchProtectionRestrictPushArray{ BranchProtectionRestrictPushArgs{...} } +type BranchProtectionRestrictPushArrayInput interface { + pulumi.Input + + ToBranchProtectionRestrictPushArrayOutput() BranchProtectionRestrictPushArrayOutput + ToBranchProtectionRestrictPushArrayOutputWithContext(context.Context) BranchProtectionRestrictPushArrayOutput +} + +type BranchProtectionRestrictPushArray []BranchProtectionRestrictPushInput + +func (BranchProtectionRestrictPushArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]BranchProtectionRestrictPush)(nil)).Elem() +} + +func (i BranchProtectionRestrictPushArray) ToBranchProtectionRestrictPushArrayOutput() BranchProtectionRestrictPushArrayOutput { + return i.ToBranchProtectionRestrictPushArrayOutputWithContext(context.Background()) +} + +func (i BranchProtectionRestrictPushArray) ToBranchProtectionRestrictPushArrayOutputWithContext(ctx context.Context) BranchProtectionRestrictPushArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionRestrictPushArrayOutput) +} + +type BranchProtectionRestrictPushOutput struct{ *pulumi.OutputState } + +func (BranchProtectionRestrictPushOutput) ElementType() reflect.Type { + return reflect.TypeOf((*BranchProtectionRestrictPush)(nil)).Elem() +} + +func (o BranchProtectionRestrictPushOutput) ToBranchProtectionRestrictPushOutput() BranchProtectionRestrictPushOutput { + return o +} + +func (o BranchProtectionRestrictPushOutput) ToBranchProtectionRestrictPushOutputWithContext(ctx context.Context) BranchProtectionRestrictPushOutput { + return o +} + +// Boolean, setting this to `false` allows people, teams, or apps to create new branches matching this rule. Defaults to `true`. +func (o BranchProtectionRestrictPushOutput) BlocksCreations() pulumi.BoolPtrOutput { + return o.ApplyT(func(v BranchProtectionRestrictPush) *bool { return v.BlocksCreations }).(pulumi.BoolPtrOutput) +} + +// A list of actor Names/IDs that may push to the branch. Actor names must either begin with a "/" for users or the organization name followed by a "/" for teams. Organization administrators, repository administrators, and users with the Maintain role on the repository can always push when all other requirements have passed. +func (o BranchProtectionRestrictPushOutput) PushAllowances() pulumi.StringArrayOutput { + return o.ApplyT(func(v BranchProtectionRestrictPush) []string { return v.PushAllowances }).(pulumi.StringArrayOutput) +} + +type BranchProtectionRestrictPushArrayOutput struct{ *pulumi.OutputState } + +func (BranchProtectionRestrictPushArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]BranchProtectionRestrictPush)(nil)).Elem() +} + +func (o BranchProtectionRestrictPushArrayOutput) ToBranchProtectionRestrictPushArrayOutput() BranchProtectionRestrictPushArrayOutput { + return o +} + +func (o BranchProtectionRestrictPushArrayOutput) ToBranchProtectionRestrictPushArrayOutputWithContext(ctx context.Context) BranchProtectionRestrictPushArrayOutput { + return o +} + +func (o BranchProtectionRestrictPushArrayOutput) Index(i pulumi.IntInput) BranchProtectionRestrictPushOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) BranchProtectionRestrictPush { + return vs[0].([]BranchProtectionRestrictPush)[vs[1].(int)] + }).(BranchProtectionRestrictPushOutput) +} + +type BranchProtectionV3RequiredPullRequestReviews struct { + // Allow specific users, teams, or apps to bypass pull request requirements. See Bypass Pull Request Allowances below for details. + BypassPullRequestAllowances *BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances `pulumi:"bypassPullRequestAllowances"` + // Dismiss approved reviews automatically when a new commit is pushed. Defaults to `false`. + DismissStaleReviews *bool `pulumi:"dismissStaleReviews"` + // The list of app slugs with dismissal access. + DismissalApps []string `pulumi:"dismissalApps"` + // The list of team slugs with dismissal access. + // Always use `slug` of the team, **not** its name. Each team already **has** to have access to the repository. + DismissalTeams []string `pulumi:"dismissalTeams"` + // The list of user logins with dismissal access + DismissalUsers []string `pulumi:"dismissalUsers"` + // Deprecated: Use enforceAdmins instead + IncludeAdmins *bool `pulumi:"includeAdmins"` + // Require an approved review in pull requests including files with a designated code owner. Defaults to `false`. + RequireCodeOwnerReviews *bool `pulumi:"requireCodeOwnerReviews"` + // Require that the most recent push must be approved by someone other than the last pusher. Defaults to `false` + RequireLastPushApproval *bool `pulumi:"requireLastPushApproval"` + // Require x number of approvals to satisfy branch protection requirements. If this is specified it must be a number between 0-6. This requirement matches GitHub's API, see the upstream [documentation](https://developer.github.com/v3/repos/branches/#parameters-1) for more information. + RequiredApprovingReviewCount *int `pulumi:"requiredApprovingReviewCount"` +} + +// BranchProtectionV3RequiredPullRequestReviewsInput is an input type that accepts BranchProtectionV3RequiredPullRequestReviewsArgs and BranchProtectionV3RequiredPullRequestReviewsOutput values. +// You can construct a concrete instance of `BranchProtectionV3RequiredPullRequestReviewsInput` via: +// +// BranchProtectionV3RequiredPullRequestReviewsArgs{...} +type BranchProtectionV3RequiredPullRequestReviewsInput interface { + pulumi.Input + + ToBranchProtectionV3RequiredPullRequestReviewsOutput() BranchProtectionV3RequiredPullRequestReviewsOutput + ToBranchProtectionV3RequiredPullRequestReviewsOutputWithContext(context.Context) BranchProtectionV3RequiredPullRequestReviewsOutput +} + +type BranchProtectionV3RequiredPullRequestReviewsArgs struct { + // Allow specific users, teams, or apps to bypass pull request requirements. See Bypass Pull Request Allowances below for details. + BypassPullRequestAllowances BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrInput `pulumi:"bypassPullRequestAllowances"` + // Dismiss approved reviews automatically when a new commit is pushed. Defaults to `false`. + DismissStaleReviews pulumi.BoolPtrInput `pulumi:"dismissStaleReviews"` + // The list of app slugs with dismissal access. + DismissalApps pulumi.StringArrayInput `pulumi:"dismissalApps"` + // The list of team slugs with dismissal access. + // Always use `slug` of the team, **not** its name. Each team already **has** to have access to the repository. + DismissalTeams pulumi.StringArrayInput `pulumi:"dismissalTeams"` + // The list of user logins with dismissal access + DismissalUsers pulumi.StringArrayInput `pulumi:"dismissalUsers"` + // Deprecated: Use enforceAdmins instead + IncludeAdmins pulumi.BoolPtrInput `pulumi:"includeAdmins"` + // Require an approved review in pull requests including files with a designated code owner. Defaults to `false`. + RequireCodeOwnerReviews pulumi.BoolPtrInput `pulumi:"requireCodeOwnerReviews"` + // Require that the most recent push must be approved by someone other than the last pusher. Defaults to `false` + RequireLastPushApproval pulumi.BoolPtrInput `pulumi:"requireLastPushApproval"` + // Require x number of approvals to satisfy branch protection requirements. If this is specified it must be a number between 0-6. This requirement matches GitHub's API, see the upstream [documentation](https://developer.github.com/v3/repos/branches/#parameters-1) for more information. + RequiredApprovingReviewCount pulumi.IntPtrInput `pulumi:"requiredApprovingReviewCount"` +} + +func (BranchProtectionV3RequiredPullRequestReviewsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*BranchProtectionV3RequiredPullRequestReviews)(nil)).Elem() +} + +func (i BranchProtectionV3RequiredPullRequestReviewsArgs) ToBranchProtectionV3RequiredPullRequestReviewsOutput() BranchProtectionV3RequiredPullRequestReviewsOutput { + return i.ToBranchProtectionV3RequiredPullRequestReviewsOutputWithContext(context.Background()) +} + +func (i BranchProtectionV3RequiredPullRequestReviewsArgs) ToBranchProtectionV3RequiredPullRequestReviewsOutputWithContext(ctx context.Context) BranchProtectionV3RequiredPullRequestReviewsOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionV3RequiredPullRequestReviewsOutput) +} + +func (i BranchProtectionV3RequiredPullRequestReviewsArgs) ToBranchProtectionV3RequiredPullRequestReviewsPtrOutput() BranchProtectionV3RequiredPullRequestReviewsPtrOutput { + return i.ToBranchProtectionV3RequiredPullRequestReviewsPtrOutputWithContext(context.Background()) +} + +func (i BranchProtectionV3RequiredPullRequestReviewsArgs) ToBranchProtectionV3RequiredPullRequestReviewsPtrOutputWithContext(ctx context.Context) BranchProtectionV3RequiredPullRequestReviewsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionV3RequiredPullRequestReviewsOutput).ToBranchProtectionV3RequiredPullRequestReviewsPtrOutputWithContext(ctx) +} + +// BranchProtectionV3RequiredPullRequestReviewsPtrInput is an input type that accepts BranchProtectionV3RequiredPullRequestReviewsArgs, BranchProtectionV3RequiredPullRequestReviewsPtr and BranchProtectionV3RequiredPullRequestReviewsPtrOutput values. +// You can construct a concrete instance of `BranchProtectionV3RequiredPullRequestReviewsPtrInput` via: +// +// BranchProtectionV3RequiredPullRequestReviewsArgs{...} +// +// or: +// +// nil +type BranchProtectionV3RequiredPullRequestReviewsPtrInput interface { + pulumi.Input + + ToBranchProtectionV3RequiredPullRequestReviewsPtrOutput() BranchProtectionV3RequiredPullRequestReviewsPtrOutput + ToBranchProtectionV3RequiredPullRequestReviewsPtrOutputWithContext(context.Context) BranchProtectionV3RequiredPullRequestReviewsPtrOutput +} + +type branchProtectionV3RequiredPullRequestReviewsPtrType BranchProtectionV3RequiredPullRequestReviewsArgs + +func BranchProtectionV3RequiredPullRequestReviewsPtr(v *BranchProtectionV3RequiredPullRequestReviewsArgs) BranchProtectionV3RequiredPullRequestReviewsPtrInput { + return (*branchProtectionV3RequiredPullRequestReviewsPtrType)(v) +} + +func (*branchProtectionV3RequiredPullRequestReviewsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**BranchProtectionV3RequiredPullRequestReviews)(nil)).Elem() +} + +func (i *branchProtectionV3RequiredPullRequestReviewsPtrType) ToBranchProtectionV3RequiredPullRequestReviewsPtrOutput() BranchProtectionV3RequiredPullRequestReviewsPtrOutput { + return i.ToBranchProtectionV3RequiredPullRequestReviewsPtrOutputWithContext(context.Background()) +} + +func (i *branchProtectionV3RequiredPullRequestReviewsPtrType) ToBranchProtectionV3RequiredPullRequestReviewsPtrOutputWithContext(ctx context.Context) BranchProtectionV3RequiredPullRequestReviewsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionV3RequiredPullRequestReviewsPtrOutput) +} + +type BranchProtectionV3RequiredPullRequestReviewsOutput struct{ *pulumi.OutputState } + +func (BranchProtectionV3RequiredPullRequestReviewsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*BranchProtectionV3RequiredPullRequestReviews)(nil)).Elem() +} + +func (o BranchProtectionV3RequiredPullRequestReviewsOutput) ToBranchProtectionV3RequiredPullRequestReviewsOutput() BranchProtectionV3RequiredPullRequestReviewsOutput { + return o +} + +func (o BranchProtectionV3RequiredPullRequestReviewsOutput) ToBranchProtectionV3RequiredPullRequestReviewsOutputWithContext(ctx context.Context) BranchProtectionV3RequiredPullRequestReviewsOutput { + return o +} + +func (o BranchProtectionV3RequiredPullRequestReviewsOutput) ToBranchProtectionV3RequiredPullRequestReviewsPtrOutput() BranchProtectionV3RequiredPullRequestReviewsPtrOutput { + return o.ToBranchProtectionV3RequiredPullRequestReviewsPtrOutputWithContext(context.Background()) +} + +func (o BranchProtectionV3RequiredPullRequestReviewsOutput) ToBranchProtectionV3RequiredPullRequestReviewsPtrOutputWithContext(ctx context.Context) BranchProtectionV3RequiredPullRequestReviewsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v BranchProtectionV3RequiredPullRequestReviews) *BranchProtectionV3RequiredPullRequestReviews { + return &v + }).(BranchProtectionV3RequiredPullRequestReviewsPtrOutput) +} + +// Allow specific users, teams, or apps to bypass pull request requirements. See Bypass Pull Request Allowances below for details. +func (o BranchProtectionV3RequiredPullRequestReviewsOutput) BypassPullRequestAllowances() BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput { + return o.ApplyT(func(v BranchProtectionV3RequiredPullRequestReviews) *BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances { + return v.BypassPullRequestAllowances + }).(BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput) +} + +// Dismiss approved reviews automatically when a new commit is pushed. Defaults to `false`. +func (o BranchProtectionV3RequiredPullRequestReviewsOutput) DismissStaleReviews() pulumi.BoolPtrOutput { + return o.ApplyT(func(v BranchProtectionV3RequiredPullRequestReviews) *bool { return v.DismissStaleReviews }).(pulumi.BoolPtrOutput) +} + +// The list of app slugs with dismissal access. +func (o BranchProtectionV3RequiredPullRequestReviewsOutput) DismissalApps() pulumi.StringArrayOutput { + return o.ApplyT(func(v BranchProtectionV3RequiredPullRequestReviews) []string { return v.DismissalApps }).(pulumi.StringArrayOutput) +} + +// The list of team slugs with dismissal access. +// Always use `slug` of the team, **not** its name. Each team already **has** to have access to the repository. +func (o BranchProtectionV3RequiredPullRequestReviewsOutput) DismissalTeams() pulumi.StringArrayOutput { + return o.ApplyT(func(v BranchProtectionV3RequiredPullRequestReviews) []string { return v.DismissalTeams }).(pulumi.StringArrayOutput) +} + +// The list of user logins with dismissal access +func (o BranchProtectionV3RequiredPullRequestReviewsOutput) DismissalUsers() pulumi.StringArrayOutput { + return o.ApplyT(func(v BranchProtectionV3RequiredPullRequestReviews) []string { return v.DismissalUsers }).(pulumi.StringArrayOutput) +} + +// Deprecated: Use enforceAdmins instead +func (o BranchProtectionV3RequiredPullRequestReviewsOutput) IncludeAdmins() pulumi.BoolPtrOutput { + return o.ApplyT(func(v BranchProtectionV3RequiredPullRequestReviews) *bool { return v.IncludeAdmins }).(pulumi.BoolPtrOutput) +} + +// Require an approved review in pull requests including files with a designated code owner. Defaults to `false`. +func (o BranchProtectionV3RequiredPullRequestReviewsOutput) RequireCodeOwnerReviews() pulumi.BoolPtrOutput { + return o.ApplyT(func(v BranchProtectionV3RequiredPullRequestReviews) *bool { return v.RequireCodeOwnerReviews }).(pulumi.BoolPtrOutput) +} + +// Require that the most recent push must be approved by someone other than the last pusher. Defaults to `false` +func (o BranchProtectionV3RequiredPullRequestReviewsOutput) RequireLastPushApproval() pulumi.BoolPtrOutput { + return o.ApplyT(func(v BranchProtectionV3RequiredPullRequestReviews) *bool { return v.RequireLastPushApproval }).(pulumi.BoolPtrOutput) +} + +// Require x number of approvals to satisfy branch protection requirements. If this is specified it must be a number between 0-6. This requirement matches GitHub's API, see the upstream [documentation](https://developer.github.com/v3/repos/branches/#parameters-1) for more information. +func (o BranchProtectionV3RequiredPullRequestReviewsOutput) RequiredApprovingReviewCount() pulumi.IntPtrOutput { + return o.ApplyT(func(v BranchProtectionV3RequiredPullRequestReviews) *int { return v.RequiredApprovingReviewCount }).(pulumi.IntPtrOutput) +} + +type BranchProtectionV3RequiredPullRequestReviewsPtrOutput struct{ *pulumi.OutputState } + +func (BranchProtectionV3RequiredPullRequestReviewsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**BranchProtectionV3RequiredPullRequestReviews)(nil)).Elem() +} + +func (o BranchProtectionV3RequiredPullRequestReviewsPtrOutput) ToBranchProtectionV3RequiredPullRequestReviewsPtrOutput() BranchProtectionV3RequiredPullRequestReviewsPtrOutput { + return o +} + +func (o BranchProtectionV3RequiredPullRequestReviewsPtrOutput) ToBranchProtectionV3RequiredPullRequestReviewsPtrOutputWithContext(ctx context.Context) BranchProtectionV3RequiredPullRequestReviewsPtrOutput { + return o +} + +func (o BranchProtectionV3RequiredPullRequestReviewsPtrOutput) Elem() BranchProtectionV3RequiredPullRequestReviewsOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredPullRequestReviews) BranchProtectionV3RequiredPullRequestReviews { + if v != nil { + return *v + } + var ret BranchProtectionV3RequiredPullRequestReviews + return ret + }).(BranchProtectionV3RequiredPullRequestReviewsOutput) +} + +// Allow specific users, teams, or apps to bypass pull request requirements. See Bypass Pull Request Allowances below for details. +func (o BranchProtectionV3RequiredPullRequestReviewsPtrOutput) BypassPullRequestAllowances() BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredPullRequestReviews) *BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances { + if v == nil { + return nil + } + return v.BypassPullRequestAllowances + }).(BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput) +} + +// Dismiss approved reviews automatically when a new commit is pushed. Defaults to `false`. +func (o BranchProtectionV3RequiredPullRequestReviewsPtrOutput) DismissStaleReviews() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredPullRequestReviews) *bool { + if v == nil { + return nil + } + return v.DismissStaleReviews + }).(pulumi.BoolPtrOutput) +} + +// The list of app slugs with dismissal access. +func (o BranchProtectionV3RequiredPullRequestReviewsPtrOutput) DismissalApps() pulumi.StringArrayOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredPullRequestReviews) []string { + if v == nil { + return nil + } + return v.DismissalApps + }).(pulumi.StringArrayOutput) +} + +// The list of team slugs with dismissal access. +// Always use `slug` of the team, **not** its name. Each team already **has** to have access to the repository. +func (o BranchProtectionV3RequiredPullRequestReviewsPtrOutput) DismissalTeams() pulumi.StringArrayOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredPullRequestReviews) []string { + if v == nil { + return nil + } + return v.DismissalTeams + }).(pulumi.StringArrayOutput) +} + +// The list of user logins with dismissal access +func (o BranchProtectionV3RequiredPullRequestReviewsPtrOutput) DismissalUsers() pulumi.StringArrayOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredPullRequestReviews) []string { + if v == nil { + return nil + } + return v.DismissalUsers + }).(pulumi.StringArrayOutput) +} + +// Deprecated: Use enforceAdmins instead +func (o BranchProtectionV3RequiredPullRequestReviewsPtrOutput) IncludeAdmins() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredPullRequestReviews) *bool { + if v == nil { + return nil + } + return v.IncludeAdmins + }).(pulumi.BoolPtrOutput) +} + +// Require an approved review in pull requests including files with a designated code owner. Defaults to `false`. +func (o BranchProtectionV3RequiredPullRequestReviewsPtrOutput) RequireCodeOwnerReviews() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredPullRequestReviews) *bool { + if v == nil { + return nil + } + return v.RequireCodeOwnerReviews + }).(pulumi.BoolPtrOutput) +} + +// Require that the most recent push must be approved by someone other than the last pusher. Defaults to `false` +func (o BranchProtectionV3RequiredPullRequestReviewsPtrOutput) RequireLastPushApproval() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredPullRequestReviews) *bool { + if v == nil { + return nil + } + return v.RequireLastPushApproval + }).(pulumi.BoolPtrOutput) +} + +// Require x number of approvals to satisfy branch protection requirements. If this is specified it must be a number between 0-6. This requirement matches GitHub's API, see the upstream [documentation](https://developer.github.com/v3/repos/branches/#parameters-1) for more information. +func (o BranchProtectionV3RequiredPullRequestReviewsPtrOutput) RequiredApprovingReviewCount() pulumi.IntPtrOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredPullRequestReviews) *int { + if v == nil { + return nil + } + return v.RequiredApprovingReviewCount + }).(pulumi.IntPtrOutput) +} + +type BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances struct { + // The list of app slugs allowed to bypass pull request requirements. + Apps []string `pulumi:"apps"` + // The list of team slugs allowed to bypass pull request requirements. + Teams []string `pulumi:"teams"` + // The list of user logins allowed to bypass pull request requirements. + Users []string `pulumi:"users"` +} + +// BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesInput is an input type that accepts BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesArgs and BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput values. +// You can construct a concrete instance of `BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesInput` via: +// +// BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesArgs{...} +type BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesInput interface { + pulumi.Input + + ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput() BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput + ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutputWithContext(context.Context) BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput +} + +type BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesArgs struct { + // The list of app slugs allowed to bypass pull request requirements. + Apps pulumi.StringArrayInput `pulumi:"apps"` + // The list of team slugs allowed to bypass pull request requirements. + Teams pulumi.StringArrayInput `pulumi:"teams"` + // The list of user logins allowed to bypass pull request requirements. + Users pulumi.StringArrayInput `pulumi:"users"` +} + +func (BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances)(nil)).Elem() +} + +func (i BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesArgs) ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput() BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput { + return i.ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutputWithContext(context.Background()) +} + +func (i BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesArgs) ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutputWithContext(ctx context.Context) BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput) +} + +func (i BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesArgs) ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput() BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput { + return i.ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutputWithContext(context.Background()) +} + +func (i BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesArgs) ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutputWithContext(ctx context.Context) BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput).ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutputWithContext(ctx) +} + +// BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrInput is an input type that accepts BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesArgs, BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtr and BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput values. +// You can construct a concrete instance of `BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrInput` via: +// +// BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesArgs{...} +// +// or: +// +// nil +type BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrInput interface { + pulumi.Input + + ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput() BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput + ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutputWithContext(context.Context) BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput +} + +type branchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrType BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesArgs + +func BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtr(v *BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesArgs) BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrInput { + return (*branchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrType)(v) +} + +func (*branchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances)(nil)).Elem() +} + +func (i *branchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrType) ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput() BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput { + return i.ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutputWithContext(context.Background()) +} + +func (i *branchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrType) ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutputWithContext(ctx context.Context) BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput) +} + +type BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput struct{ *pulumi.OutputState } + +func (BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput) ElementType() reflect.Type { + return reflect.TypeOf((*BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances)(nil)).Elem() +} + +func (o BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput) ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput() BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput { + return o +} + +func (o BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput) ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutputWithContext(ctx context.Context) BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput { + return o +} + +func (o BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput) ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput() BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput { + return o.ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutputWithContext(context.Background()) +} + +func (o BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput) ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutputWithContext(ctx context.Context) BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances) *BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances { + return &v + }).(BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput) +} + +// The list of app slugs allowed to bypass pull request requirements. +func (o BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput) Apps() pulumi.StringArrayOutput { + return o.ApplyT(func(v BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances) []string { + return v.Apps + }).(pulumi.StringArrayOutput) +} + +// The list of team slugs allowed to bypass pull request requirements. +func (o BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput) Teams() pulumi.StringArrayOutput { + return o.ApplyT(func(v BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances) []string { + return v.Teams + }).(pulumi.StringArrayOutput) +} + +// The list of user logins allowed to bypass pull request requirements. +func (o BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput) Users() pulumi.StringArrayOutput { + return o.ApplyT(func(v BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances) []string { + return v.Users + }).(pulumi.StringArrayOutput) +} + +type BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput struct{ *pulumi.OutputState } + +func (BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances)(nil)).Elem() +} + +func (o BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput) ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput() BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput { + return o +} + +func (o BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput) ToBranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutputWithContext(ctx context.Context) BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput { + return o +} + +func (o BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput) Elem() BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances) BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances { + if v != nil { + return *v + } + var ret BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances + return ret + }).(BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput) +} + +// The list of app slugs allowed to bypass pull request requirements. +func (o BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput) Apps() pulumi.StringArrayOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances) []string { + if v == nil { + return nil + } + return v.Apps + }).(pulumi.StringArrayOutput) +} + +// The list of team slugs allowed to bypass pull request requirements. +func (o BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput) Teams() pulumi.StringArrayOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances) []string { + if v == nil { + return nil + } + return v.Teams + }).(pulumi.StringArrayOutput) +} + +// The list of user logins allowed to bypass pull request requirements. +func (o BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput) Users() pulumi.StringArrayOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowances) []string { + if v == nil { + return nil + } + return v.Users + }).(pulumi.StringArrayOutput) +} + +type BranchProtectionV3RequiredStatusChecks struct { + // The list of status checks to require in order to merge into this branch. No status checks are required by default. Checks should be strings containing the context and appId like so "context:app_id". + Checks []string `pulumi:"checks"` + // [**DEPRECATED**] (Optional) The list of status checks to require in order to merge into this branch. No status checks are required by default. + // + // > Note: This attribute can contain multiple string patterns. + // If specified, usual value is the [job name](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idname). Otherwise, the [job id](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idname) is defaulted to. + // For workflows that use matrixes, append the matrix name to the value using the following pattern `([, ])`. Matrixes should be specified based on the order of matrix properties in the workflow file. See GitHub Documentation for more information. + // For workflows that use reusable workflows, the pattern is ` / `. This can extend multiple levels. + // + // Deprecated: GitHub is deprecating the use of `contexts`. Use a `checks` array instead. + Contexts []string `pulumi:"contexts"` + // Deprecated: Use enforceAdmins instead + IncludeAdmins *bool `pulumi:"includeAdmins"` + // Require branches to be up to date before merging. Defaults to `false`. + Strict *bool `pulumi:"strict"` +} + +// BranchProtectionV3RequiredStatusChecksInput is an input type that accepts BranchProtectionV3RequiredStatusChecksArgs and BranchProtectionV3RequiredStatusChecksOutput values. +// You can construct a concrete instance of `BranchProtectionV3RequiredStatusChecksInput` via: +// +// BranchProtectionV3RequiredStatusChecksArgs{...} +type BranchProtectionV3RequiredStatusChecksInput interface { + pulumi.Input + + ToBranchProtectionV3RequiredStatusChecksOutput() BranchProtectionV3RequiredStatusChecksOutput + ToBranchProtectionV3RequiredStatusChecksOutputWithContext(context.Context) BranchProtectionV3RequiredStatusChecksOutput +} + +type BranchProtectionV3RequiredStatusChecksArgs struct { + // The list of status checks to require in order to merge into this branch. No status checks are required by default. Checks should be strings containing the context and appId like so "context:app_id". + Checks pulumi.StringArrayInput `pulumi:"checks"` + // [**DEPRECATED**] (Optional) The list of status checks to require in order to merge into this branch. No status checks are required by default. + // + // > Note: This attribute can contain multiple string patterns. + // If specified, usual value is the [job name](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idname). Otherwise, the [job id](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idname) is defaulted to. + // For workflows that use matrixes, append the matrix name to the value using the following pattern `([, ])`. Matrixes should be specified based on the order of matrix properties in the workflow file. See GitHub Documentation for more information. + // For workflows that use reusable workflows, the pattern is ` / `. This can extend multiple levels. + // + // Deprecated: GitHub is deprecating the use of `contexts`. Use a `checks` array instead. + Contexts pulumi.StringArrayInput `pulumi:"contexts"` + // Deprecated: Use enforceAdmins instead + IncludeAdmins pulumi.BoolPtrInput `pulumi:"includeAdmins"` + // Require branches to be up to date before merging. Defaults to `false`. + Strict pulumi.BoolPtrInput `pulumi:"strict"` +} + +func (BranchProtectionV3RequiredStatusChecksArgs) ElementType() reflect.Type { + return reflect.TypeOf((*BranchProtectionV3RequiredStatusChecks)(nil)).Elem() +} + +func (i BranchProtectionV3RequiredStatusChecksArgs) ToBranchProtectionV3RequiredStatusChecksOutput() BranchProtectionV3RequiredStatusChecksOutput { + return i.ToBranchProtectionV3RequiredStatusChecksOutputWithContext(context.Background()) +} + +func (i BranchProtectionV3RequiredStatusChecksArgs) ToBranchProtectionV3RequiredStatusChecksOutputWithContext(ctx context.Context) BranchProtectionV3RequiredStatusChecksOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionV3RequiredStatusChecksOutput) +} + +func (i BranchProtectionV3RequiredStatusChecksArgs) ToBranchProtectionV3RequiredStatusChecksPtrOutput() BranchProtectionV3RequiredStatusChecksPtrOutput { + return i.ToBranchProtectionV3RequiredStatusChecksPtrOutputWithContext(context.Background()) +} + +func (i BranchProtectionV3RequiredStatusChecksArgs) ToBranchProtectionV3RequiredStatusChecksPtrOutputWithContext(ctx context.Context) BranchProtectionV3RequiredStatusChecksPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionV3RequiredStatusChecksOutput).ToBranchProtectionV3RequiredStatusChecksPtrOutputWithContext(ctx) +} + +// BranchProtectionV3RequiredStatusChecksPtrInput is an input type that accepts BranchProtectionV3RequiredStatusChecksArgs, BranchProtectionV3RequiredStatusChecksPtr and BranchProtectionV3RequiredStatusChecksPtrOutput values. +// You can construct a concrete instance of `BranchProtectionV3RequiredStatusChecksPtrInput` via: +// +// BranchProtectionV3RequiredStatusChecksArgs{...} +// +// or: +// +// nil +type BranchProtectionV3RequiredStatusChecksPtrInput interface { + pulumi.Input + + ToBranchProtectionV3RequiredStatusChecksPtrOutput() BranchProtectionV3RequiredStatusChecksPtrOutput + ToBranchProtectionV3RequiredStatusChecksPtrOutputWithContext(context.Context) BranchProtectionV3RequiredStatusChecksPtrOutput +} + +type branchProtectionV3RequiredStatusChecksPtrType BranchProtectionV3RequiredStatusChecksArgs + +func BranchProtectionV3RequiredStatusChecksPtr(v *BranchProtectionV3RequiredStatusChecksArgs) BranchProtectionV3RequiredStatusChecksPtrInput { + return (*branchProtectionV3RequiredStatusChecksPtrType)(v) +} + +func (*branchProtectionV3RequiredStatusChecksPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**BranchProtectionV3RequiredStatusChecks)(nil)).Elem() +} + +func (i *branchProtectionV3RequiredStatusChecksPtrType) ToBranchProtectionV3RequiredStatusChecksPtrOutput() BranchProtectionV3RequiredStatusChecksPtrOutput { + return i.ToBranchProtectionV3RequiredStatusChecksPtrOutputWithContext(context.Background()) +} + +func (i *branchProtectionV3RequiredStatusChecksPtrType) ToBranchProtectionV3RequiredStatusChecksPtrOutputWithContext(ctx context.Context) BranchProtectionV3RequiredStatusChecksPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionV3RequiredStatusChecksPtrOutput) +} + +type BranchProtectionV3RequiredStatusChecksOutput struct{ *pulumi.OutputState } + +func (BranchProtectionV3RequiredStatusChecksOutput) ElementType() reflect.Type { + return reflect.TypeOf((*BranchProtectionV3RequiredStatusChecks)(nil)).Elem() +} + +func (o BranchProtectionV3RequiredStatusChecksOutput) ToBranchProtectionV3RequiredStatusChecksOutput() BranchProtectionV3RequiredStatusChecksOutput { + return o +} + +func (o BranchProtectionV3RequiredStatusChecksOutput) ToBranchProtectionV3RequiredStatusChecksOutputWithContext(ctx context.Context) BranchProtectionV3RequiredStatusChecksOutput { + return o +} + +func (o BranchProtectionV3RequiredStatusChecksOutput) ToBranchProtectionV3RequiredStatusChecksPtrOutput() BranchProtectionV3RequiredStatusChecksPtrOutput { + return o.ToBranchProtectionV3RequiredStatusChecksPtrOutputWithContext(context.Background()) +} + +func (o BranchProtectionV3RequiredStatusChecksOutput) ToBranchProtectionV3RequiredStatusChecksPtrOutputWithContext(ctx context.Context) BranchProtectionV3RequiredStatusChecksPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v BranchProtectionV3RequiredStatusChecks) *BranchProtectionV3RequiredStatusChecks { + return &v + }).(BranchProtectionV3RequiredStatusChecksPtrOutput) +} + +// The list of status checks to require in order to merge into this branch. No status checks are required by default. Checks should be strings containing the context and appId like so "context:app_id". +func (o BranchProtectionV3RequiredStatusChecksOutput) Checks() pulumi.StringArrayOutput { + return o.ApplyT(func(v BranchProtectionV3RequiredStatusChecks) []string { return v.Checks }).(pulumi.StringArrayOutput) +} + +// [**DEPRECATED**] (Optional) The list of status checks to require in order to merge into this branch. No status checks are required by default. +// +// > Note: This attribute can contain multiple string patterns. +// If specified, usual value is the [job name](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idname). Otherwise, the [job id](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idname) is defaulted to. +// For workflows that use matrixes, append the matrix name to the value using the following pattern `([, ])`. Matrixes should be specified based on the order of matrix properties in the workflow file. See GitHub Documentation for more information. +// For workflows that use reusable workflows, the pattern is ` / `. This can extend multiple levels. +// +// Deprecated: GitHub is deprecating the use of `contexts`. Use a `checks` array instead. +func (o BranchProtectionV3RequiredStatusChecksOutput) Contexts() pulumi.StringArrayOutput { + return o.ApplyT(func(v BranchProtectionV3RequiredStatusChecks) []string { return v.Contexts }).(pulumi.StringArrayOutput) +} + +// Deprecated: Use enforceAdmins instead +func (o BranchProtectionV3RequiredStatusChecksOutput) IncludeAdmins() pulumi.BoolPtrOutput { + return o.ApplyT(func(v BranchProtectionV3RequiredStatusChecks) *bool { return v.IncludeAdmins }).(pulumi.BoolPtrOutput) +} + +// Require branches to be up to date before merging. Defaults to `false`. +func (o BranchProtectionV3RequiredStatusChecksOutput) Strict() pulumi.BoolPtrOutput { + return o.ApplyT(func(v BranchProtectionV3RequiredStatusChecks) *bool { return v.Strict }).(pulumi.BoolPtrOutput) +} + +type BranchProtectionV3RequiredStatusChecksPtrOutput struct{ *pulumi.OutputState } + +func (BranchProtectionV3RequiredStatusChecksPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**BranchProtectionV3RequiredStatusChecks)(nil)).Elem() +} + +func (o BranchProtectionV3RequiredStatusChecksPtrOutput) ToBranchProtectionV3RequiredStatusChecksPtrOutput() BranchProtectionV3RequiredStatusChecksPtrOutput { + return o +} + +func (o BranchProtectionV3RequiredStatusChecksPtrOutput) ToBranchProtectionV3RequiredStatusChecksPtrOutputWithContext(ctx context.Context) BranchProtectionV3RequiredStatusChecksPtrOutput { + return o +} + +func (o BranchProtectionV3RequiredStatusChecksPtrOutput) Elem() BranchProtectionV3RequiredStatusChecksOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredStatusChecks) BranchProtectionV3RequiredStatusChecks { + if v != nil { + return *v + } + var ret BranchProtectionV3RequiredStatusChecks + return ret + }).(BranchProtectionV3RequiredStatusChecksOutput) +} + +// The list of status checks to require in order to merge into this branch. No status checks are required by default. Checks should be strings containing the context and appId like so "context:app_id". +func (o BranchProtectionV3RequiredStatusChecksPtrOutput) Checks() pulumi.StringArrayOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredStatusChecks) []string { + if v == nil { + return nil + } + return v.Checks + }).(pulumi.StringArrayOutput) +} + +// [**DEPRECATED**] (Optional) The list of status checks to require in order to merge into this branch. No status checks are required by default. +// +// > Note: This attribute can contain multiple string patterns. +// If specified, usual value is the [job name](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idname). Otherwise, the [job id](https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idname) is defaulted to. +// For workflows that use matrixes, append the matrix name to the value using the following pattern `([, ])`. Matrixes should be specified based on the order of matrix properties in the workflow file. See GitHub Documentation for more information. +// For workflows that use reusable workflows, the pattern is ` / `. This can extend multiple levels. +// +// Deprecated: GitHub is deprecating the use of `contexts`. Use a `checks` array instead. +func (o BranchProtectionV3RequiredStatusChecksPtrOutput) Contexts() pulumi.StringArrayOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredStatusChecks) []string { + if v == nil { + return nil + } + return v.Contexts + }).(pulumi.StringArrayOutput) +} + +// Deprecated: Use enforceAdmins instead +func (o BranchProtectionV3RequiredStatusChecksPtrOutput) IncludeAdmins() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredStatusChecks) *bool { + if v == nil { + return nil + } + return v.IncludeAdmins + }).(pulumi.BoolPtrOutput) +} + +// Require branches to be up to date before merging. Defaults to `false`. +func (o BranchProtectionV3RequiredStatusChecksPtrOutput) Strict() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *BranchProtectionV3RequiredStatusChecks) *bool { + if v == nil { + return nil + } + return v.Strict + }).(pulumi.BoolPtrOutput) +} + +type BranchProtectionV3Restrictions struct { + // The list of app slugs with push access. + // + // `restrictions` is only available for organization-owned repositories. + Apps []string `pulumi:"apps"` + // The list of team slugs with push access. + // Always use `slug` of the team, **not** its name. Each team already **has** to have access to the repository. + Teams []string `pulumi:"teams"` + // The list of user logins with push access. + Users []string `pulumi:"users"` +} + +// BranchProtectionV3RestrictionsInput is an input type that accepts BranchProtectionV3RestrictionsArgs and BranchProtectionV3RestrictionsOutput values. +// You can construct a concrete instance of `BranchProtectionV3RestrictionsInput` via: +// +// BranchProtectionV3RestrictionsArgs{...} +type BranchProtectionV3RestrictionsInput interface { + pulumi.Input + + ToBranchProtectionV3RestrictionsOutput() BranchProtectionV3RestrictionsOutput + ToBranchProtectionV3RestrictionsOutputWithContext(context.Context) BranchProtectionV3RestrictionsOutput +} + +type BranchProtectionV3RestrictionsArgs struct { + // The list of app slugs with push access. + // + // `restrictions` is only available for organization-owned repositories. + Apps pulumi.StringArrayInput `pulumi:"apps"` + // The list of team slugs with push access. + // Always use `slug` of the team, **not** its name. Each team already **has** to have access to the repository. + Teams pulumi.StringArrayInput `pulumi:"teams"` + // The list of user logins with push access. + Users pulumi.StringArrayInput `pulumi:"users"` +} + +func (BranchProtectionV3RestrictionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*BranchProtectionV3Restrictions)(nil)).Elem() +} + +func (i BranchProtectionV3RestrictionsArgs) ToBranchProtectionV3RestrictionsOutput() BranchProtectionV3RestrictionsOutput { + return i.ToBranchProtectionV3RestrictionsOutputWithContext(context.Background()) +} + +func (i BranchProtectionV3RestrictionsArgs) ToBranchProtectionV3RestrictionsOutputWithContext(ctx context.Context) BranchProtectionV3RestrictionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionV3RestrictionsOutput) +} + +func (i BranchProtectionV3RestrictionsArgs) ToBranchProtectionV3RestrictionsPtrOutput() BranchProtectionV3RestrictionsPtrOutput { + return i.ToBranchProtectionV3RestrictionsPtrOutputWithContext(context.Background()) +} + +func (i BranchProtectionV3RestrictionsArgs) ToBranchProtectionV3RestrictionsPtrOutputWithContext(ctx context.Context) BranchProtectionV3RestrictionsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionV3RestrictionsOutput).ToBranchProtectionV3RestrictionsPtrOutputWithContext(ctx) +} + +// BranchProtectionV3RestrictionsPtrInput is an input type that accepts BranchProtectionV3RestrictionsArgs, BranchProtectionV3RestrictionsPtr and BranchProtectionV3RestrictionsPtrOutput values. +// You can construct a concrete instance of `BranchProtectionV3RestrictionsPtrInput` via: +// +// BranchProtectionV3RestrictionsArgs{...} +// +// or: +// +// nil +type BranchProtectionV3RestrictionsPtrInput interface { + pulumi.Input + + ToBranchProtectionV3RestrictionsPtrOutput() BranchProtectionV3RestrictionsPtrOutput + ToBranchProtectionV3RestrictionsPtrOutputWithContext(context.Context) BranchProtectionV3RestrictionsPtrOutput +} + +type branchProtectionV3RestrictionsPtrType BranchProtectionV3RestrictionsArgs + +func BranchProtectionV3RestrictionsPtr(v *BranchProtectionV3RestrictionsArgs) BranchProtectionV3RestrictionsPtrInput { + return (*branchProtectionV3RestrictionsPtrType)(v) +} + +func (*branchProtectionV3RestrictionsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**BranchProtectionV3Restrictions)(nil)).Elem() +} + +func (i *branchProtectionV3RestrictionsPtrType) ToBranchProtectionV3RestrictionsPtrOutput() BranchProtectionV3RestrictionsPtrOutput { + return i.ToBranchProtectionV3RestrictionsPtrOutputWithContext(context.Background()) +} + +func (i *branchProtectionV3RestrictionsPtrType) ToBranchProtectionV3RestrictionsPtrOutputWithContext(ctx context.Context) BranchProtectionV3RestrictionsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(BranchProtectionV3RestrictionsPtrOutput) +} + +type BranchProtectionV3RestrictionsOutput struct{ *pulumi.OutputState } + +func (BranchProtectionV3RestrictionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*BranchProtectionV3Restrictions)(nil)).Elem() +} + +func (o BranchProtectionV3RestrictionsOutput) ToBranchProtectionV3RestrictionsOutput() BranchProtectionV3RestrictionsOutput { + return o +} + +func (o BranchProtectionV3RestrictionsOutput) ToBranchProtectionV3RestrictionsOutputWithContext(ctx context.Context) BranchProtectionV3RestrictionsOutput { + return o +} + +func (o BranchProtectionV3RestrictionsOutput) ToBranchProtectionV3RestrictionsPtrOutput() BranchProtectionV3RestrictionsPtrOutput { + return o.ToBranchProtectionV3RestrictionsPtrOutputWithContext(context.Background()) +} + +func (o BranchProtectionV3RestrictionsOutput) ToBranchProtectionV3RestrictionsPtrOutputWithContext(ctx context.Context) BranchProtectionV3RestrictionsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v BranchProtectionV3Restrictions) *BranchProtectionV3Restrictions { + return &v + }).(BranchProtectionV3RestrictionsPtrOutput) +} + +// The list of app slugs with push access. +// +// `restrictions` is only available for organization-owned repositories. +func (o BranchProtectionV3RestrictionsOutput) Apps() pulumi.StringArrayOutput { + return o.ApplyT(func(v BranchProtectionV3Restrictions) []string { return v.Apps }).(pulumi.StringArrayOutput) +} + +// The list of team slugs with push access. +// Always use `slug` of the team, **not** its name. Each team already **has** to have access to the repository. +func (o BranchProtectionV3RestrictionsOutput) Teams() pulumi.StringArrayOutput { + return o.ApplyT(func(v BranchProtectionV3Restrictions) []string { return v.Teams }).(pulumi.StringArrayOutput) +} + +// The list of user logins with push access. +func (o BranchProtectionV3RestrictionsOutput) Users() pulumi.StringArrayOutput { + return o.ApplyT(func(v BranchProtectionV3Restrictions) []string { return v.Users }).(pulumi.StringArrayOutput) +} + +type BranchProtectionV3RestrictionsPtrOutput struct{ *pulumi.OutputState } + +func (BranchProtectionV3RestrictionsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**BranchProtectionV3Restrictions)(nil)).Elem() +} + +func (o BranchProtectionV3RestrictionsPtrOutput) ToBranchProtectionV3RestrictionsPtrOutput() BranchProtectionV3RestrictionsPtrOutput { + return o +} + +func (o BranchProtectionV3RestrictionsPtrOutput) ToBranchProtectionV3RestrictionsPtrOutputWithContext(ctx context.Context) BranchProtectionV3RestrictionsPtrOutput { + return o +} + +func (o BranchProtectionV3RestrictionsPtrOutput) Elem() BranchProtectionV3RestrictionsOutput { + return o.ApplyT(func(v *BranchProtectionV3Restrictions) BranchProtectionV3Restrictions { + if v != nil { + return *v + } + var ret BranchProtectionV3Restrictions + return ret + }).(BranchProtectionV3RestrictionsOutput) +} + +// The list of app slugs with push access. +// +// `restrictions` is only available for organization-owned repositories. +func (o BranchProtectionV3RestrictionsPtrOutput) Apps() pulumi.StringArrayOutput { + return o.ApplyT(func(v *BranchProtectionV3Restrictions) []string { + if v == nil { + return nil + } + return v.Apps + }).(pulumi.StringArrayOutput) +} + +// The list of team slugs with push access. +// Always use `slug` of the team, **not** its name. Each team already **has** to have access to the repository. +func (o BranchProtectionV3RestrictionsPtrOutput) Teams() pulumi.StringArrayOutput { + return o.ApplyT(func(v *BranchProtectionV3Restrictions) []string { + if v == nil { + return nil + } + return v.Teams + }).(pulumi.StringArrayOutput) +} + +// The list of user logins with push access. +func (o BranchProtectionV3RestrictionsPtrOutput) Users() pulumi.StringArrayOutput { + return o.ApplyT(func(v *BranchProtectionV3Restrictions) []string { + if v == nil { + return nil + } + return v.Users + }).(pulumi.StringArrayOutput) +} + +type EnterpriseActionsPermissionsAllowedActionsConfig struct { + // Whether GitHub-owned actions are allowed in the organization. + GithubOwnedAllowed bool `pulumi:"githubOwnedAllowed"` + // Specifies a list of string-matching patterns to allow specific action(s). Wildcards, tags, and SHAs are allowed. For example, monalisa/octocat@*, monalisa/octocat@v2, monalisa/*." + PatternsAlloweds []string `pulumi:"patternsAlloweds"` + // Whether actions in GitHub Marketplace from verified creators are allowed. Set to true to allow all GitHub Marketplace actions by verified creators. + VerifiedAllowed *bool `pulumi:"verifiedAllowed"` +} + +// EnterpriseActionsPermissionsAllowedActionsConfigInput is an input type that accepts EnterpriseActionsPermissionsAllowedActionsConfigArgs and EnterpriseActionsPermissionsAllowedActionsConfigOutput values. +// You can construct a concrete instance of `EnterpriseActionsPermissionsAllowedActionsConfigInput` via: +// +// EnterpriseActionsPermissionsAllowedActionsConfigArgs{...} +type EnterpriseActionsPermissionsAllowedActionsConfigInput interface { + pulumi.Input + + ToEnterpriseActionsPermissionsAllowedActionsConfigOutput() EnterpriseActionsPermissionsAllowedActionsConfigOutput + ToEnterpriseActionsPermissionsAllowedActionsConfigOutputWithContext(context.Context) EnterpriseActionsPermissionsAllowedActionsConfigOutput +} + +type EnterpriseActionsPermissionsAllowedActionsConfigArgs struct { + // Whether GitHub-owned actions are allowed in the organization. + GithubOwnedAllowed pulumi.BoolInput `pulumi:"githubOwnedAllowed"` + // Specifies a list of string-matching patterns to allow specific action(s). Wildcards, tags, and SHAs are allowed. For example, monalisa/octocat@*, monalisa/octocat@v2, monalisa/*." + PatternsAlloweds pulumi.StringArrayInput `pulumi:"patternsAlloweds"` + // Whether actions in GitHub Marketplace from verified creators are allowed. Set to true to allow all GitHub Marketplace actions by verified creators. + VerifiedAllowed pulumi.BoolPtrInput `pulumi:"verifiedAllowed"` +} + +func (EnterpriseActionsPermissionsAllowedActionsConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*EnterpriseActionsPermissionsAllowedActionsConfig)(nil)).Elem() +} + +func (i EnterpriseActionsPermissionsAllowedActionsConfigArgs) ToEnterpriseActionsPermissionsAllowedActionsConfigOutput() EnterpriseActionsPermissionsAllowedActionsConfigOutput { + return i.ToEnterpriseActionsPermissionsAllowedActionsConfigOutputWithContext(context.Background()) +} + +func (i EnterpriseActionsPermissionsAllowedActionsConfigArgs) ToEnterpriseActionsPermissionsAllowedActionsConfigOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsAllowedActionsConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseActionsPermissionsAllowedActionsConfigOutput) +} + +func (i EnterpriseActionsPermissionsAllowedActionsConfigArgs) ToEnterpriseActionsPermissionsAllowedActionsConfigPtrOutput() EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput { + return i.ToEnterpriseActionsPermissionsAllowedActionsConfigPtrOutputWithContext(context.Background()) +} + +func (i EnterpriseActionsPermissionsAllowedActionsConfigArgs) ToEnterpriseActionsPermissionsAllowedActionsConfigPtrOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseActionsPermissionsAllowedActionsConfigOutput).ToEnterpriseActionsPermissionsAllowedActionsConfigPtrOutputWithContext(ctx) +} + +// EnterpriseActionsPermissionsAllowedActionsConfigPtrInput is an input type that accepts EnterpriseActionsPermissionsAllowedActionsConfigArgs, EnterpriseActionsPermissionsAllowedActionsConfigPtr and EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput values. +// You can construct a concrete instance of `EnterpriseActionsPermissionsAllowedActionsConfigPtrInput` via: +// +// EnterpriseActionsPermissionsAllowedActionsConfigArgs{...} +// +// or: +// +// nil +type EnterpriseActionsPermissionsAllowedActionsConfigPtrInput interface { + pulumi.Input + + ToEnterpriseActionsPermissionsAllowedActionsConfigPtrOutput() EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput + ToEnterpriseActionsPermissionsAllowedActionsConfigPtrOutputWithContext(context.Context) EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput +} + +type enterpriseActionsPermissionsAllowedActionsConfigPtrType EnterpriseActionsPermissionsAllowedActionsConfigArgs + +func EnterpriseActionsPermissionsAllowedActionsConfigPtr(v *EnterpriseActionsPermissionsAllowedActionsConfigArgs) EnterpriseActionsPermissionsAllowedActionsConfigPtrInput { + return (*enterpriseActionsPermissionsAllowedActionsConfigPtrType)(v) +} + +func (*enterpriseActionsPermissionsAllowedActionsConfigPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**EnterpriseActionsPermissionsAllowedActionsConfig)(nil)).Elem() +} + +func (i *enterpriseActionsPermissionsAllowedActionsConfigPtrType) ToEnterpriseActionsPermissionsAllowedActionsConfigPtrOutput() EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput { + return i.ToEnterpriseActionsPermissionsAllowedActionsConfigPtrOutputWithContext(context.Background()) +} + +func (i *enterpriseActionsPermissionsAllowedActionsConfigPtrType) ToEnterpriseActionsPermissionsAllowedActionsConfigPtrOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput) +} + +type EnterpriseActionsPermissionsAllowedActionsConfigOutput struct{ *pulumi.OutputState } + +func (EnterpriseActionsPermissionsAllowedActionsConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*EnterpriseActionsPermissionsAllowedActionsConfig)(nil)).Elem() +} + +func (o EnterpriseActionsPermissionsAllowedActionsConfigOutput) ToEnterpriseActionsPermissionsAllowedActionsConfigOutput() EnterpriseActionsPermissionsAllowedActionsConfigOutput { + return o +} + +func (o EnterpriseActionsPermissionsAllowedActionsConfigOutput) ToEnterpriseActionsPermissionsAllowedActionsConfigOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsAllowedActionsConfigOutput { + return o +} + +func (o EnterpriseActionsPermissionsAllowedActionsConfigOutput) ToEnterpriseActionsPermissionsAllowedActionsConfigPtrOutput() EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput { + return o.ToEnterpriseActionsPermissionsAllowedActionsConfigPtrOutputWithContext(context.Background()) +} + +func (o EnterpriseActionsPermissionsAllowedActionsConfigOutput) ToEnterpriseActionsPermissionsAllowedActionsConfigPtrOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v EnterpriseActionsPermissionsAllowedActionsConfig) *EnterpriseActionsPermissionsAllowedActionsConfig { + return &v + }).(EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput) +} + +// Whether GitHub-owned actions are allowed in the organization. +func (o EnterpriseActionsPermissionsAllowedActionsConfigOutput) GithubOwnedAllowed() pulumi.BoolOutput { + return o.ApplyT(func(v EnterpriseActionsPermissionsAllowedActionsConfig) bool { return v.GithubOwnedAllowed }).(pulumi.BoolOutput) +} + +// Specifies a list of string-matching patterns to allow specific action(s). Wildcards, tags, and SHAs are allowed. For example, monalisa/octocat@*, monalisa/octocat@v2, monalisa/*." +func (o EnterpriseActionsPermissionsAllowedActionsConfigOutput) PatternsAlloweds() pulumi.StringArrayOutput { + return o.ApplyT(func(v EnterpriseActionsPermissionsAllowedActionsConfig) []string { return v.PatternsAlloweds }).(pulumi.StringArrayOutput) +} + +// Whether actions in GitHub Marketplace from verified creators are allowed. Set to true to allow all GitHub Marketplace actions by verified creators. +func (o EnterpriseActionsPermissionsAllowedActionsConfigOutput) VerifiedAllowed() pulumi.BoolPtrOutput { + return o.ApplyT(func(v EnterpriseActionsPermissionsAllowedActionsConfig) *bool { return v.VerifiedAllowed }).(pulumi.BoolPtrOutput) +} + +type EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput struct{ *pulumi.OutputState } + +func (EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**EnterpriseActionsPermissionsAllowedActionsConfig)(nil)).Elem() +} + +func (o EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput) ToEnterpriseActionsPermissionsAllowedActionsConfigPtrOutput() EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput { + return o +} + +func (o EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput) ToEnterpriseActionsPermissionsAllowedActionsConfigPtrOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput { + return o +} + +func (o EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput) Elem() EnterpriseActionsPermissionsAllowedActionsConfigOutput { + return o.ApplyT(func(v *EnterpriseActionsPermissionsAllowedActionsConfig) EnterpriseActionsPermissionsAllowedActionsConfig { + if v != nil { + return *v + } + var ret EnterpriseActionsPermissionsAllowedActionsConfig + return ret + }).(EnterpriseActionsPermissionsAllowedActionsConfigOutput) +} + +// Whether GitHub-owned actions are allowed in the organization. +func (o EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput) GithubOwnedAllowed() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *EnterpriseActionsPermissionsAllowedActionsConfig) *bool { + if v == nil { + return nil + } + return &v.GithubOwnedAllowed + }).(pulumi.BoolPtrOutput) +} + +// Specifies a list of string-matching patterns to allow specific action(s). Wildcards, tags, and SHAs are allowed. For example, monalisa/octocat@*, monalisa/octocat@v2, monalisa/*." +func (o EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput) PatternsAlloweds() pulumi.StringArrayOutput { + return o.ApplyT(func(v *EnterpriseActionsPermissionsAllowedActionsConfig) []string { + if v == nil { + return nil + } + return v.PatternsAlloweds + }).(pulumi.StringArrayOutput) +} + +// Whether actions in GitHub Marketplace from verified creators are allowed. Set to true to allow all GitHub Marketplace actions by verified creators. +func (o EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput) VerifiedAllowed() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *EnterpriseActionsPermissionsAllowedActionsConfig) *bool { + if v == nil { + return nil + } + return v.VerifiedAllowed + }).(pulumi.BoolPtrOutput) +} + +type EnterpriseActionsPermissionsEnabledOrganizationsConfig struct { + // List of organization IDs to enable for GitHub Actions. + OrganizationIds []int `pulumi:"organizationIds"` +} + +// EnterpriseActionsPermissionsEnabledOrganizationsConfigInput is an input type that accepts EnterpriseActionsPermissionsEnabledOrganizationsConfigArgs and EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput values. +// You can construct a concrete instance of `EnterpriseActionsPermissionsEnabledOrganizationsConfigInput` via: +// +// EnterpriseActionsPermissionsEnabledOrganizationsConfigArgs{...} +type EnterpriseActionsPermissionsEnabledOrganizationsConfigInput interface { + pulumi.Input + + ToEnterpriseActionsPermissionsEnabledOrganizationsConfigOutput() EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput + ToEnterpriseActionsPermissionsEnabledOrganizationsConfigOutputWithContext(context.Context) EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput +} + +type EnterpriseActionsPermissionsEnabledOrganizationsConfigArgs struct { + // List of organization IDs to enable for GitHub Actions. + OrganizationIds pulumi.IntArrayInput `pulumi:"organizationIds"` +} + +func (EnterpriseActionsPermissionsEnabledOrganizationsConfigArgs) ElementType() reflect.Type { + return reflect.TypeOf((*EnterpriseActionsPermissionsEnabledOrganizationsConfig)(nil)).Elem() +} + +func (i EnterpriseActionsPermissionsEnabledOrganizationsConfigArgs) ToEnterpriseActionsPermissionsEnabledOrganizationsConfigOutput() EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput { + return i.ToEnterpriseActionsPermissionsEnabledOrganizationsConfigOutputWithContext(context.Background()) +} + +func (i EnterpriseActionsPermissionsEnabledOrganizationsConfigArgs) ToEnterpriseActionsPermissionsEnabledOrganizationsConfigOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput) +} + +func (i EnterpriseActionsPermissionsEnabledOrganizationsConfigArgs) ToEnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput() EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput { + return i.ToEnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutputWithContext(context.Background()) +} + +func (i EnterpriseActionsPermissionsEnabledOrganizationsConfigArgs) ToEnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput).ToEnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutputWithContext(ctx) +} + +// EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrInput is an input type that accepts EnterpriseActionsPermissionsEnabledOrganizationsConfigArgs, EnterpriseActionsPermissionsEnabledOrganizationsConfigPtr and EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput values. +// You can construct a concrete instance of `EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrInput` via: +// +// EnterpriseActionsPermissionsEnabledOrganizationsConfigArgs{...} +// +// or: +// +// nil +type EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrInput interface { + pulumi.Input + + ToEnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput() EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput + ToEnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutputWithContext(context.Context) EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput +} + +type enterpriseActionsPermissionsEnabledOrganizationsConfigPtrType EnterpriseActionsPermissionsEnabledOrganizationsConfigArgs + +func EnterpriseActionsPermissionsEnabledOrganizationsConfigPtr(v *EnterpriseActionsPermissionsEnabledOrganizationsConfigArgs) EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrInput { + return (*enterpriseActionsPermissionsEnabledOrganizationsConfigPtrType)(v) +} + +func (*enterpriseActionsPermissionsEnabledOrganizationsConfigPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**EnterpriseActionsPermissionsEnabledOrganizationsConfig)(nil)).Elem() +} + +func (i *enterpriseActionsPermissionsEnabledOrganizationsConfigPtrType) ToEnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput() EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput { + return i.ToEnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutputWithContext(context.Background()) +} + +func (i *enterpriseActionsPermissionsEnabledOrganizationsConfigPtrType) ToEnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput) +} + +type EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput struct{ *pulumi.OutputState } + +func (EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput) ElementType() reflect.Type { + return reflect.TypeOf((*EnterpriseActionsPermissionsEnabledOrganizationsConfig)(nil)).Elem() +} + +func (o EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput) ToEnterpriseActionsPermissionsEnabledOrganizationsConfigOutput() EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput { + return o +} + +func (o EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput) ToEnterpriseActionsPermissionsEnabledOrganizationsConfigOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput { + return o +} + +func (o EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput) ToEnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput() EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput { + return o.ToEnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutputWithContext(context.Background()) +} + +func (o EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput) ToEnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v EnterpriseActionsPermissionsEnabledOrganizationsConfig) *EnterpriseActionsPermissionsEnabledOrganizationsConfig { + return &v + }).(EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput) +} + +// List of organization IDs to enable for GitHub Actions. +func (o EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput) OrganizationIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v EnterpriseActionsPermissionsEnabledOrganizationsConfig) []int { return v.OrganizationIds }).(pulumi.IntArrayOutput) +} + +type EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput struct{ *pulumi.OutputState } + +func (EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**EnterpriseActionsPermissionsEnabledOrganizationsConfig)(nil)).Elem() +} + +func (o EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput) ToEnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput() EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput { + return o +} + +func (o EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput) ToEnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutputWithContext(ctx context.Context) EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput { + return o +} + +func (o EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput) Elem() EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput { + return o.ApplyT(func(v *EnterpriseActionsPermissionsEnabledOrganizationsConfig) EnterpriseActionsPermissionsEnabledOrganizationsConfig { + if v != nil { + return *v + } + var ret EnterpriseActionsPermissionsEnabledOrganizationsConfig + return ret + }).(EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput) +} + +// List of organization IDs to enable for GitHub Actions. +func (o EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput) OrganizationIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v *EnterpriseActionsPermissionsEnabledOrganizationsConfig) []int { + if v == nil { + return nil + } + return v.OrganizationIds + }).(pulumi.IntArrayOutput) +} + +type IssueLabelsLabel struct { + // A 6 character hex code, **without the leading #**, identifying the color of the label. + Color string `pulumi:"color"` + // A short description of the label. + Description *string `pulumi:"description"` + // The name of the label. + Name string `pulumi:"name"` + // The URL to the issue label + Url *string `pulumi:"url"` +} + +// IssueLabelsLabelInput is an input type that accepts IssueLabelsLabelArgs and IssueLabelsLabelOutput values. +// You can construct a concrete instance of `IssueLabelsLabelInput` via: +// +// IssueLabelsLabelArgs{...} +type IssueLabelsLabelInput interface { + pulumi.Input + + ToIssueLabelsLabelOutput() IssueLabelsLabelOutput + ToIssueLabelsLabelOutputWithContext(context.Context) IssueLabelsLabelOutput +} + +type IssueLabelsLabelArgs struct { + // A 6 character hex code, **without the leading #**, identifying the color of the label. + Color pulumi.StringInput `pulumi:"color"` + // A short description of the label. + Description pulumi.StringPtrInput `pulumi:"description"` + // The name of the label. + Name pulumi.StringInput `pulumi:"name"` + // The URL to the issue label + Url pulumi.StringPtrInput `pulumi:"url"` +} + +func (IssueLabelsLabelArgs) ElementType() reflect.Type { + return reflect.TypeOf((*IssueLabelsLabel)(nil)).Elem() +} + +func (i IssueLabelsLabelArgs) ToIssueLabelsLabelOutput() IssueLabelsLabelOutput { + return i.ToIssueLabelsLabelOutputWithContext(context.Background()) +} + +func (i IssueLabelsLabelArgs) ToIssueLabelsLabelOutputWithContext(ctx context.Context) IssueLabelsLabelOutput { + return pulumi.ToOutputWithContext(ctx, i).(IssueLabelsLabelOutput) +} + +// IssueLabelsLabelArrayInput is an input type that accepts IssueLabelsLabelArray and IssueLabelsLabelArrayOutput values. +// You can construct a concrete instance of `IssueLabelsLabelArrayInput` via: +// +// IssueLabelsLabelArray{ IssueLabelsLabelArgs{...} } +type IssueLabelsLabelArrayInput interface { + pulumi.Input + + ToIssueLabelsLabelArrayOutput() IssueLabelsLabelArrayOutput + ToIssueLabelsLabelArrayOutputWithContext(context.Context) IssueLabelsLabelArrayOutput +} + +type IssueLabelsLabelArray []IssueLabelsLabelInput + +func (IssueLabelsLabelArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]IssueLabelsLabel)(nil)).Elem() +} + +func (i IssueLabelsLabelArray) ToIssueLabelsLabelArrayOutput() IssueLabelsLabelArrayOutput { + return i.ToIssueLabelsLabelArrayOutputWithContext(context.Background()) +} + +func (i IssueLabelsLabelArray) ToIssueLabelsLabelArrayOutputWithContext(ctx context.Context) IssueLabelsLabelArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(IssueLabelsLabelArrayOutput) +} + +type IssueLabelsLabelOutput struct{ *pulumi.OutputState } + +func (IssueLabelsLabelOutput) ElementType() reflect.Type { + return reflect.TypeOf((*IssueLabelsLabel)(nil)).Elem() +} + +func (o IssueLabelsLabelOutput) ToIssueLabelsLabelOutput() IssueLabelsLabelOutput { + return o +} + +func (o IssueLabelsLabelOutput) ToIssueLabelsLabelOutputWithContext(ctx context.Context) IssueLabelsLabelOutput { + return o +} + +// A 6 character hex code, **without the leading #**, identifying the color of the label. +func (o IssueLabelsLabelOutput) Color() pulumi.StringOutput { + return o.ApplyT(func(v IssueLabelsLabel) string { return v.Color }).(pulumi.StringOutput) +} + +// A short description of the label. +func (o IssueLabelsLabelOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v IssueLabelsLabel) *string { return v.Description }).(pulumi.StringPtrOutput) +} + +// The name of the label. +func (o IssueLabelsLabelOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v IssueLabelsLabel) string { return v.Name }).(pulumi.StringOutput) +} + +// The URL to the issue label +func (o IssueLabelsLabelOutput) Url() pulumi.StringPtrOutput { + return o.ApplyT(func(v IssueLabelsLabel) *string { return v.Url }).(pulumi.StringPtrOutput) +} + +type IssueLabelsLabelArrayOutput struct{ *pulumi.OutputState } + +func (IssueLabelsLabelArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]IssueLabelsLabel)(nil)).Elem() +} + +func (o IssueLabelsLabelArrayOutput) ToIssueLabelsLabelArrayOutput() IssueLabelsLabelArrayOutput { + return o +} + +func (o IssueLabelsLabelArrayOutput) ToIssueLabelsLabelArrayOutputWithContext(ctx context.Context) IssueLabelsLabelArrayOutput { + return o +} + +func (o IssueLabelsLabelArrayOutput) Index(i pulumi.IntInput) IssueLabelsLabelOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) IssueLabelsLabel { + return vs[0].([]IssueLabelsLabel)[vs[1].(int)] + }).(IssueLabelsLabelOutput) +} + +type OrganizationRulesetBypassActor struct { + // (Number) The ID of the actor that can bypass a ruleset. Some actor types such as `DeployKey` do not have an ID. + ActorId *int `pulumi:"actorId"` + // The type of actor that can bypass a ruleset. Can be one of: `RepositoryRole`, `Team`, `Integration`, `OrganizationAdmin`. + ActorType string `pulumi:"actorType"` + // (String) When the specified actor can bypass the ruleset. pullRequest means that an actor can only bypass rules on pull requests. Can be one of: `always`, `pullRequest`, `exempt`. + // + // ~>Note: at the time of writing this, the following actor types correspond to the following actor IDs: + // + // - `OrganizationAdmin` > `1` + // - `RepositoryRole` (This is the actor type, the following are the base repository roles and their associated IDs.) + BypassMode string `pulumi:"bypassMode"` +} + +// OrganizationRulesetBypassActorInput is an input type that accepts OrganizationRulesetBypassActorArgs and OrganizationRulesetBypassActorOutput values. +// You can construct a concrete instance of `OrganizationRulesetBypassActorInput` via: +// +// OrganizationRulesetBypassActorArgs{...} +type OrganizationRulesetBypassActorInput interface { + pulumi.Input + + ToOrganizationRulesetBypassActorOutput() OrganizationRulesetBypassActorOutput + ToOrganizationRulesetBypassActorOutputWithContext(context.Context) OrganizationRulesetBypassActorOutput +} + +type OrganizationRulesetBypassActorArgs struct { + // (Number) The ID of the actor that can bypass a ruleset. Some actor types such as `DeployKey` do not have an ID. + ActorId pulumi.IntPtrInput `pulumi:"actorId"` + // The type of actor that can bypass a ruleset. Can be one of: `RepositoryRole`, `Team`, `Integration`, `OrganizationAdmin`. + ActorType pulumi.StringInput `pulumi:"actorType"` + // (String) When the specified actor can bypass the ruleset. pullRequest means that an actor can only bypass rules on pull requests. Can be one of: `always`, `pullRequest`, `exempt`. + // + // ~>Note: at the time of writing this, the following actor types correspond to the following actor IDs: + // + // - `OrganizationAdmin` > `1` + // - `RepositoryRole` (This is the actor type, the following are the base repository roles and their associated IDs.) + BypassMode pulumi.StringInput `pulumi:"bypassMode"` +} + +func (OrganizationRulesetBypassActorArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetBypassActor)(nil)).Elem() +} + +func (i OrganizationRulesetBypassActorArgs) ToOrganizationRulesetBypassActorOutput() OrganizationRulesetBypassActorOutput { + return i.ToOrganizationRulesetBypassActorOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetBypassActorArgs) ToOrganizationRulesetBypassActorOutputWithContext(ctx context.Context) OrganizationRulesetBypassActorOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetBypassActorOutput) +} + +// OrganizationRulesetBypassActorArrayInput is an input type that accepts OrganizationRulesetBypassActorArray and OrganizationRulesetBypassActorArrayOutput values. +// You can construct a concrete instance of `OrganizationRulesetBypassActorArrayInput` via: +// +// OrganizationRulesetBypassActorArray{ OrganizationRulesetBypassActorArgs{...} } +type OrganizationRulesetBypassActorArrayInput interface { + pulumi.Input + + ToOrganizationRulesetBypassActorArrayOutput() OrganizationRulesetBypassActorArrayOutput + ToOrganizationRulesetBypassActorArrayOutputWithContext(context.Context) OrganizationRulesetBypassActorArrayOutput +} + +type OrganizationRulesetBypassActorArray []OrganizationRulesetBypassActorInput + +func (OrganizationRulesetBypassActorArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]OrganizationRulesetBypassActor)(nil)).Elem() +} + +func (i OrganizationRulesetBypassActorArray) ToOrganizationRulesetBypassActorArrayOutput() OrganizationRulesetBypassActorArrayOutput { + return i.ToOrganizationRulesetBypassActorArrayOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetBypassActorArray) ToOrganizationRulesetBypassActorArrayOutputWithContext(ctx context.Context) OrganizationRulesetBypassActorArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetBypassActorArrayOutput) +} + +type OrganizationRulesetBypassActorOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetBypassActorOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetBypassActor)(nil)).Elem() +} + +func (o OrganizationRulesetBypassActorOutput) ToOrganizationRulesetBypassActorOutput() OrganizationRulesetBypassActorOutput { + return o +} + +func (o OrganizationRulesetBypassActorOutput) ToOrganizationRulesetBypassActorOutputWithContext(ctx context.Context) OrganizationRulesetBypassActorOutput { + return o +} + +// (Number) The ID of the actor that can bypass a ruleset. Some actor types such as `DeployKey` do not have an ID. +func (o OrganizationRulesetBypassActorOutput) ActorId() pulumi.IntPtrOutput { + return o.ApplyT(func(v OrganizationRulesetBypassActor) *int { return v.ActorId }).(pulumi.IntPtrOutput) +} + +// The type of actor that can bypass a ruleset. Can be one of: `RepositoryRole`, `Team`, `Integration`, `OrganizationAdmin`. +func (o OrganizationRulesetBypassActorOutput) ActorType() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetBypassActor) string { return v.ActorType }).(pulumi.StringOutput) +} + +// (String) When the specified actor can bypass the ruleset. pullRequest means that an actor can only bypass rules on pull requests. Can be one of: `always`, `pullRequest`, `exempt`. +// +// ~>Note: at the time of writing this, the following actor types correspond to the following actor IDs: +// +// - `OrganizationAdmin` > `1` +// - `RepositoryRole` (This is the actor type, the following are the base repository roles and their associated IDs.) +func (o OrganizationRulesetBypassActorOutput) BypassMode() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetBypassActor) string { return v.BypassMode }).(pulumi.StringOutput) +} + +type OrganizationRulesetBypassActorArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetBypassActorArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]OrganizationRulesetBypassActor)(nil)).Elem() +} + +func (o OrganizationRulesetBypassActorArrayOutput) ToOrganizationRulesetBypassActorArrayOutput() OrganizationRulesetBypassActorArrayOutput { + return o +} + +func (o OrganizationRulesetBypassActorArrayOutput) ToOrganizationRulesetBypassActorArrayOutputWithContext(ctx context.Context) OrganizationRulesetBypassActorArrayOutput { + return o +} + +func (o OrganizationRulesetBypassActorArrayOutput) Index(i pulumi.IntInput) OrganizationRulesetBypassActorOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) OrganizationRulesetBypassActor { + return vs[0].([]OrganizationRulesetBypassActor)[vs[1].(int)] + }).(OrganizationRulesetBypassActorOutput) +} + +type OrganizationRulesetConditions struct { + // (Block List, Max: 1) Required for `branch` and `tag` targets. Must NOT be set for `push` targets. (see below for nested schema) + RefName *OrganizationRulesetConditionsRefName `pulumi:"refName"` + // The repository IDs that the ruleset applies to. One of these IDs must match for the condition to pass. + RepositoryIds []int `pulumi:"repositoryIds"` + // Targets repositories that match the specified name patterns. (see below for nested schema) + RepositoryName *OrganizationRulesetConditionsRepositoryName `pulumi:"repositoryName"` + // Targets repositories by custom or system properties. (see below for nested schema) + // + // Exactly one of `repositoryId`, `repositoryName`, or `repositoryProperty` must be set for the rule to target repositories. + // + // > **Note:** For `push` targets, do not include `refName` in conditions. Push rulesets operate on file content, not on refs. + RepositoryProperty *OrganizationRulesetConditionsRepositoryProperty `pulumi:"repositoryProperty"` +} + +// OrganizationRulesetConditionsInput is an input type that accepts OrganizationRulesetConditionsArgs and OrganizationRulesetConditionsOutput values. +// You can construct a concrete instance of `OrganizationRulesetConditionsInput` via: +// +// OrganizationRulesetConditionsArgs{...} +type OrganizationRulesetConditionsInput interface { + pulumi.Input + + ToOrganizationRulesetConditionsOutput() OrganizationRulesetConditionsOutput + ToOrganizationRulesetConditionsOutputWithContext(context.Context) OrganizationRulesetConditionsOutput +} + +type OrganizationRulesetConditionsArgs struct { + // (Block List, Max: 1) Required for `branch` and `tag` targets. Must NOT be set for `push` targets. (see below for nested schema) + RefName OrganizationRulesetConditionsRefNamePtrInput `pulumi:"refName"` + // The repository IDs that the ruleset applies to. One of these IDs must match for the condition to pass. + RepositoryIds pulumi.IntArrayInput `pulumi:"repositoryIds"` + // Targets repositories that match the specified name patterns. (see below for nested schema) + RepositoryName OrganizationRulesetConditionsRepositoryNamePtrInput `pulumi:"repositoryName"` + // Targets repositories by custom or system properties. (see below for nested schema) + // + // Exactly one of `repositoryId`, `repositoryName`, or `repositoryProperty` must be set for the rule to target repositories. + // + // > **Note:** For `push` targets, do not include `refName` in conditions. Push rulesets operate on file content, not on refs. + RepositoryProperty OrganizationRulesetConditionsRepositoryPropertyPtrInput `pulumi:"repositoryProperty"` +} + +func (OrganizationRulesetConditionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetConditions)(nil)).Elem() +} + +func (i OrganizationRulesetConditionsArgs) ToOrganizationRulesetConditionsOutput() OrganizationRulesetConditionsOutput { + return i.ToOrganizationRulesetConditionsOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetConditionsArgs) ToOrganizationRulesetConditionsOutputWithContext(ctx context.Context) OrganizationRulesetConditionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetConditionsOutput) +} + +func (i OrganizationRulesetConditionsArgs) ToOrganizationRulesetConditionsPtrOutput() OrganizationRulesetConditionsPtrOutput { + return i.ToOrganizationRulesetConditionsPtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetConditionsArgs) ToOrganizationRulesetConditionsPtrOutputWithContext(ctx context.Context) OrganizationRulesetConditionsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetConditionsOutput).ToOrganizationRulesetConditionsPtrOutputWithContext(ctx) +} + +// OrganizationRulesetConditionsPtrInput is an input type that accepts OrganizationRulesetConditionsArgs, OrganizationRulesetConditionsPtr and OrganizationRulesetConditionsPtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetConditionsPtrInput` via: +// +// OrganizationRulesetConditionsArgs{...} +// +// or: +// +// nil +type OrganizationRulesetConditionsPtrInput interface { + pulumi.Input + + ToOrganizationRulesetConditionsPtrOutput() OrganizationRulesetConditionsPtrOutput + ToOrganizationRulesetConditionsPtrOutputWithContext(context.Context) OrganizationRulesetConditionsPtrOutput +} + +type organizationRulesetConditionsPtrType OrganizationRulesetConditionsArgs + +func OrganizationRulesetConditionsPtr(v *OrganizationRulesetConditionsArgs) OrganizationRulesetConditionsPtrInput { + return (*organizationRulesetConditionsPtrType)(v) +} + +func (*organizationRulesetConditionsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetConditions)(nil)).Elem() +} + +func (i *organizationRulesetConditionsPtrType) ToOrganizationRulesetConditionsPtrOutput() OrganizationRulesetConditionsPtrOutput { + return i.ToOrganizationRulesetConditionsPtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetConditionsPtrType) ToOrganizationRulesetConditionsPtrOutputWithContext(ctx context.Context) OrganizationRulesetConditionsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetConditionsPtrOutput) +} + +type OrganizationRulesetConditionsOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetConditionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetConditions)(nil)).Elem() +} + +func (o OrganizationRulesetConditionsOutput) ToOrganizationRulesetConditionsOutput() OrganizationRulesetConditionsOutput { + return o +} + +func (o OrganizationRulesetConditionsOutput) ToOrganizationRulesetConditionsOutputWithContext(ctx context.Context) OrganizationRulesetConditionsOutput { + return o +} + +func (o OrganizationRulesetConditionsOutput) ToOrganizationRulesetConditionsPtrOutput() OrganizationRulesetConditionsPtrOutput { + return o.ToOrganizationRulesetConditionsPtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetConditionsOutput) ToOrganizationRulesetConditionsPtrOutputWithContext(ctx context.Context) OrganizationRulesetConditionsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetConditions) *OrganizationRulesetConditions { + return &v + }).(OrganizationRulesetConditionsPtrOutput) +} + +// (Block List, Max: 1) Required for `branch` and `tag` targets. Must NOT be set for `push` targets. (see below for nested schema) +func (o OrganizationRulesetConditionsOutput) RefName() OrganizationRulesetConditionsRefNamePtrOutput { + return o.ApplyT(func(v OrganizationRulesetConditions) *OrganizationRulesetConditionsRefName { return v.RefName }).(OrganizationRulesetConditionsRefNamePtrOutput) +} + +// The repository IDs that the ruleset applies to. One of these IDs must match for the condition to pass. +func (o OrganizationRulesetConditionsOutput) RepositoryIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v OrganizationRulesetConditions) []int { return v.RepositoryIds }).(pulumi.IntArrayOutput) +} + +// Targets repositories that match the specified name patterns. (see below for nested schema) +func (o OrganizationRulesetConditionsOutput) RepositoryName() OrganizationRulesetConditionsRepositoryNamePtrOutput { + return o.ApplyT(func(v OrganizationRulesetConditions) *OrganizationRulesetConditionsRepositoryName { + return v.RepositoryName + }).(OrganizationRulesetConditionsRepositoryNamePtrOutput) +} + +// Targets repositories by custom or system properties. (see below for nested schema) +// +// Exactly one of `repositoryId`, `repositoryName`, or `repositoryProperty` must be set for the rule to target repositories. +// +// > **Note:** For `push` targets, do not include `refName` in conditions. Push rulesets operate on file content, not on refs. +func (o OrganizationRulesetConditionsOutput) RepositoryProperty() OrganizationRulesetConditionsRepositoryPropertyPtrOutput { + return o.ApplyT(func(v OrganizationRulesetConditions) *OrganizationRulesetConditionsRepositoryProperty { + return v.RepositoryProperty + }).(OrganizationRulesetConditionsRepositoryPropertyPtrOutput) +} + +type OrganizationRulesetConditionsPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetConditionsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetConditions)(nil)).Elem() +} + +func (o OrganizationRulesetConditionsPtrOutput) ToOrganizationRulesetConditionsPtrOutput() OrganizationRulesetConditionsPtrOutput { + return o +} + +func (o OrganizationRulesetConditionsPtrOutput) ToOrganizationRulesetConditionsPtrOutputWithContext(ctx context.Context) OrganizationRulesetConditionsPtrOutput { + return o +} + +func (o OrganizationRulesetConditionsPtrOutput) Elem() OrganizationRulesetConditionsOutput { + return o.ApplyT(func(v *OrganizationRulesetConditions) OrganizationRulesetConditions { + if v != nil { + return *v + } + var ret OrganizationRulesetConditions + return ret + }).(OrganizationRulesetConditionsOutput) +} + +// (Block List, Max: 1) Required for `branch` and `tag` targets. Must NOT be set for `push` targets. (see below for nested schema) +func (o OrganizationRulesetConditionsPtrOutput) RefName() OrganizationRulesetConditionsRefNamePtrOutput { + return o.ApplyT(func(v *OrganizationRulesetConditions) *OrganizationRulesetConditionsRefName { + if v == nil { + return nil + } + return v.RefName + }).(OrganizationRulesetConditionsRefNamePtrOutput) +} + +// The repository IDs that the ruleset applies to. One of these IDs must match for the condition to pass. +func (o OrganizationRulesetConditionsPtrOutput) RepositoryIds() pulumi.IntArrayOutput { + return o.ApplyT(func(v *OrganizationRulesetConditions) []int { + if v == nil { + return nil + } + return v.RepositoryIds + }).(pulumi.IntArrayOutput) +} + +// Targets repositories that match the specified name patterns. (see below for nested schema) +func (o OrganizationRulesetConditionsPtrOutput) RepositoryName() OrganizationRulesetConditionsRepositoryNamePtrOutput { + return o.ApplyT(func(v *OrganizationRulesetConditions) *OrganizationRulesetConditionsRepositoryName { + if v == nil { + return nil + } + return v.RepositoryName + }).(OrganizationRulesetConditionsRepositoryNamePtrOutput) +} + +// Targets repositories by custom or system properties. (see below for nested schema) +// +// Exactly one of `repositoryId`, `repositoryName`, or `repositoryProperty` must be set for the rule to target repositories. +// +// > **Note:** For `push` targets, do not include `refName` in conditions. Push rulesets operate on file content, not on refs. +func (o OrganizationRulesetConditionsPtrOutput) RepositoryProperty() OrganizationRulesetConditionsRepositoryPropertyPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetConditions) *OrganizationRulesetConditionsRepositoryProperty { + if v == nil { + return nil + } + return v.RepositoryProperty + }).(OrganizationRulesetConditionsRepositoryPropertyPtrOutput) +} + +type OrganizationRulesetConditionsRefName struct { + // Array of ref names or patterns to exclude. The condition will not pass if any of these patterns match. + Excludes []string `pulumi:"excludes"` + // Array of ref names or patterns to include. One of these patterns must match for the condition to pass. Also accepts `~DEFAULT_BRANCH` to include the default branch or `~ALL` to include all branches. + Includes []string `pulumi:"includes"` +} + +// OrganizationRulesetConditionsRefNameInput is an input type that accepts OrganizationRulesetConditionsRefNameArgs and OrganizationRulesetConditionsRefNameOutput values. +// You can construct a concrete instance of `OrganizationRulesetConditionsRefNameInput` via: +// +// OrganizationRulesetConditionsRefNameArgs{...} +type OrganizationRulesetConditionsRefNameInput interface { + pulumi.Input + + ToOrganizationRulesetConditionsRefNameOutput() OrganizationRulesetConditionsRefNameOutput + ToOrganizationRulesetConditionsRefNameOutputWithContext(context.Context) OrganizationRulesetConditionsRefNameOutput +} + +type OrganizationRulesetConditionsRefNameArgs struct { + // Array of ref names or patterns to exclude. The condition will not pass if any of these patterns match. + Excludes pulumi.StringArrayInput `pulumi:"excludes"` + // Array of ref names or patterns to include. One of these patterns must match for the condition to pass. Also accepts `~DEFAULT_BRANCH` to include the default branch or `~ALL` to include all branches. + Includes pulumi.StringArrayInput `pulumi:"includes"` +} + +func (OrganizationRulesetConditionsRefNameArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetConditionsRefName)(nil)).Elem() +} + +func (i OrganizationRulesetConditionsRefNameArgs) ToOrganizationRulesetConditionsRefNameOutput() OrganizationRulesetConditionsRefNameOutput { + return i.ToOrganizationRulesetConditionsRefNameOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetConditionsRefNameArgs) ToOrganizationRulesetConditionsRefNameOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRefNameOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetConditionsRefNameOutput) +} + +func (i OrganizationRulesetConditionsRefNameArgs) ToOrganizationRulesetConditionsRefNamePtrOutput() OrganizationRulesetConditionsRefNamePtrOutput { + return i.ToOrganizationRulesetConditionsRefNamePtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetConditionsRefNameArgs) ToOrganizationRulesetConditionsRefNamePtrOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRefNamePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetConditionsRefNameOutput).ToOrganizationRulesetConditionsRefNamePtrOutputWithContext(ctx) +} + +// OrganizationRulesetConditionsRefNamePtrInput is an input type that accepts OrganizationRulesetConditionsRefNameArgs, OrganizationRulesetConditionsRefNamePtr and OrganizationRulesetConditionsRefNamePtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetConditionsRefNamePtrInput` via: +// +// OrganizationRulesetConditionsRefNameArgs{...} +// +// or: +// +// nil +type OrganizationRulesetConditionsRefNamePtrInput interface { + pulumi.Input + + ToOrganizationRulesetConditionsRefNamePtrOutput() OrganizationRulesetConditionsRefNamePtrOutput + ToOrganizationRulesetConditionsRefNamePtrOutputWithContext(context.Context) OrganizationRulesetConditionsRefNamePtrOutput +} + +type organizationRulesetConditionsRefNamePtrType OrganizationRulesetConditionsRefNameArgs + +func OrganizationRulesetConditionsRefNamePtr(v *OrganizationRulesetConditionsRefNameArgs) OrganizationRulesetConditionsRefNamePtrInput { + return (*organizationRulesetConditionsRefNamePtrType)(v) +} + +func (*organizationRulesetConditionsRefNamePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetConditionsRefName)(nil)).Elem() +} + +func (i *organizationRulesetConditionsRefNamePtrType) ToOrganizationRulesetConditionsRefNamePtrOutput() OrganizationRulesetConditionsRefNamePtrOutput { + return i.ToOrganizationRulesetConditionsRefNamePtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetConditionsRefNamePtrType) ToOrganizationRulesetConditionsRefNamePtrOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRefNamePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetConditionsRefNamePtrOutput) +} + +type OrganizationRulesetConditionsRefNameOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetConditionsRefNameOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetConditionsRefName)(nil)).Elem() +} + +func (o OrganizationRulesetConditionsRefNameOutput) ToOrganizationRulesetConditionsRefNameOutput() OrganizationRulesetConditionsRefNameOutput { + return o +} + +func (o OrganizationRulesetConditionsRefNameOutput) ToOrganizationRulesetConditionsRefNameOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRefNameOutput { + return o +} + +func (o OrganizationRulesetConditionsRefNameOutput) ToOrganizationRulesetConditionsRefNamePtrOutput() OrganizationRulesetConditionsRefNamePtrOutput { + return o.ToOrganizationRulesetConditionsRefNamePtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetConditionsRefNameOutput) ToOrganizationRulesetConditionsRefNamePtrOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRefNamePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetConditionsRefName) *OrganizationRulesetConditionsRefName { + return &v + }).(OrganizationRulesetConditionsRefNamePtrOutput) +} + +// Array of ref names or patterns to exclude. The condition will not pass if any of these patterns match. +func (o OrganizationRulesetConditionsRefNameOutput) Excludes() pulumi.StringArrayOutput { + return o.ApplyT(func(v OrganizationRulesetConditionsRefName) []string { return v.Excludes }).(pulumi.StringArrayOutput) +} + +// Array of ref names or patterns to include. One of these patterns must match for the condition to pass. Also accepts `~DEFAULT_BRANCH` to include the default branch or `~ALL` to include all branches. +func (o OrganizationRulesetConditionsRefNameOutput) Includes() pulumi.StringArrayOutput { + return o.ApplyT(func(v OrganizationRulesetConditionsRefName) []string { return v.Includes }).(pulumi.StringArrayOutput) +} + +type OrganizationRulesetConditionsRefNamePtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetConditionsRefNamePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetConditionsRefName)(nil)).Elem() +} + +func (o OrganizationRulesetConditionsRefNamePtrOutput) ToOrganizationRulesetConditionsRefNamePtrOutput() OrganizationRulesetConditionsRefNamePtrOutput { + return o +} + +func (o OrganizationRulesetConditionsRefNamePtrOutput) ToOrganizationRulesetConditionsRefNamePtrOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRefNamePtrOutput { + return o +} + +func (o OrganizationRulesetConditionsRefNamePtrOutput) Elem() OrganizationRulesetConditionsRefNameOutput { + return o.ApplyT(func(v *OrganizationRulesetConditionsRefName) OrganizationRulesetConditionsRefName { + if v != nil { + return *v + } + var ret OrganizationRulesetConditionsRefName + return ret + }).(OrganizationRulesetConditionsRefNameOutput) +} + +// Array of ref names or patterns to exclude. The condition will not pass if any of these patterns match. +func (o OrganizationRulesetConditionsRefNamePtrOutput) Excludes() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OrganizationRulesetConditionsRefName) []string { + if v == nil { + return nil + } + return v.Excludes + }).(pulumi.StringArrayOutput) +} + +// Array of ref names or patterns to include. One of these patterns must match for the condition to pass. Also accepts `~DEFAULT_BRANCH` to include the default branch or `~ALL` to include all branches. +func (o OrganizationRulesetConditionsRefNamePtrOutput) Includes() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OrganizationRulesetConditionsRefName) []string { + if v == nil { + return nil + } + return v.Includes + }).(pulumi.StringArrayOutput) +} + +type OrganizationRulesetConditionsRepositoryName struct { + // Array of repository names or patterns to exclude. The condition will not pass if any of these patterns match. + Excludes []string `pulumi:"excludes"` + // Array of repository names or patterns to include. One of these patterns must match for the condition to pass. Also accepts `~ALL` to include all repositories. + Includes []string `pulumi:"includes"` + // Whether renaming of target repositories is prevented. + Protected *bool `pulumi:"protected"` +} + +// OrganizationRulesetConditionsRepositoryNameInput is an input type that accepts OrganizationRulesetConditionsRepositoryNameArgs and OrganizationRulesetConditionsRepositoryNameOutput values. +// You can construct a concrete instance of `OrganizationRulesetConditionsRepositoryNameInput` via: +// +// OrganizationRulesetConditionsRepositoryNameArgs{...} +type OrganizationRulesetConditionsRepositoryNameInput interface { + pulumi.Input + + ToOrganizationRulesetConditionsRepositoryNameOutput() OrganizationRulesetConditionsRepositoryNameOutput + ToOrganizationRulesetConditionsRepositoryNameOutputWithContext(context.Context) OrganizationRulesetConditionsRepositoryNameOutput +} + +type OrganizationRulesetConditionsRepositoryNameArgs struct { + // Array of repository names or patterns to exclude. The condition will not pass if any of these patterns match. + Excludes pulumi.StringArrayInput `pulumi:"excludes"` + // Array of repository names or patterns to include. One of these patterns must match for the condition to pass. Also accepts `~ALL` to include all repositories. + Includes pulumi.StringArrayInput `pulumi:"includes"` + // Whether renaming of target repositories is prevented. + Protected pulumi.BoolPtrInput `pulumi:"protected"` +} + +func (OrganizationRulesetConditionsRepositoryNameArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetConditionsRepositoryName)(nil)).Elem() +} + +func (i OrganizationRulesetConditionsRepositoryNameArgs) ToOrganizationRulesetConditionsRepositoryNameOutput() OrganizationRulesetConditionsRepositoryNameOutput { + return i.ToOrganizationRulesetConditionsRepositoryNameOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetConditionsRepositoryNameArgs) ToOrganizationRulesetConditionsRepositoryNameOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryNameOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetConditionsRepositoryNameOutput) +} + +func (i OrganizationRulesetConditionsRepositoryNameArgs) ToOrganizationRulesetConditionsRepositoryNamePtrOutput() OrganizationRulesetConditionsRepositoryNamePtrOutput { + return i.ToOrganizationRulesetConditionsRepositoryNamePtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetConditionsRepositoryNameArgs) ToOrganizationRulesetConditionsRepositoryNamePtrOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryNamePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetConditionsRepositoryNameOutput).ToOrganizationRulesetConditionsRepositoryNamePtrOutputWithContext(ctx) +} + +// OrganizationRulesetConditionsRepositoryNamePtrInput is an input type that accepts OrganizationRulesetConditionsRepositoryNameArgs, OrganizationRulesetConditionsRepositoryNamePtr and OrganizationRulesetConditionsRepositoryNamePtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetConditionsRepositoryNamePtrInput` via: +// +// OrganizationRulesetConditionsRepositoryNameArgs{...} +// +// or: +// +// nil +type OrganizationRulesetConditionsRepositoryNamePtrInput interface { + pulumi.Input + + ToOrganizationRulesetConditionsRepositoryNamePtrOutput() OrganizationRulesetConditionsRepositoryNamePtrOutput + ToOrganizationRulesetConditionsRepositoryNamePtrOutputWithContext(context.Context) OrganizationRulesetConditionsRepositoryNamePtrOutput +} + +type organizationRulesetConditionsRepositoryNamePtrType OrganizationRulesetConditionsRepositoryNameArgs + +func OrganizationRulesetConditionsRepositoryNamePtr(v *OrganizationRulesetConditionsRepositoryNameArgs) OrganizationRulesetConditionsRepositoryNamePtrInput { + return (*organizationRulesetConditionsRepositoryNamePtrType)(v) +} + +func (*organizationRulesetConditionsRepositoryNamePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetConditionsRepositoryName)(nil)).Elem() +} + +func (i *organizationRulesetConditionsRepositoryNamePtrType) ToOrganizationRulesetConditionsRepositoryNamePtrOutput() OrganizationRulesetConditionsRepositoryNamePtrOutput { + return i.ToOrganizationRulesetConditionsRepositoryNamePtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetConditionsRepositoryNamePtrType) ToOrganizationRulesetConditionsRepositoryNamePtrOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryNamePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetConditionsRepositoryNamePtrOutput) +} + +type OrganizationRulesetConditionsRepositoryNameOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetConditionsRepositoryNameOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetConditionsRepositoryName)(nil)).Elem() +} + +func (o OrganizationRulesetConditionsRepositoryNameOutput) ToOrganizationRulesetConditionsRepositoryNameOutput() OrganizationRulesetConditionsRepositoryNameOutput { + return o +} + +func (o OrganizationRulesetConditionsRepositoryNameOutput) ToOrganizationRulesetConditionsRepositoryNameOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryNameOutput { + return o +} + +func (o OrganizationRulesetConditionsRepositoryNameOutput) ToOrganizationRulesetConditionsRepositoryNamePtrOutput() OrganizationRulesetConditionsRepositoryNamePtrOutput { + return o.ToOrganizationRulesetConditionsRepositoryNamePtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetConditionsRepositoryNameOutput) ToOrganizationRulesetConditionsRepositoryNamePtrOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryNamePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetConditionsRepositoryName) *OrganizationRulesetConditionsRepositoryName { + return &v + }).(OrganizationRulesetConditionsRepositoryNamePtrOutput) +} + +// Array of repository names or patterns to exclude. The condition will not pass if any of these patterns match. +func (o OrganizationRulesetConditionsRepositoryNameOutput) Excludes() pulumi.StringArrayOutput { + return o.ApplyT(func(v OrganizationRulesetConditionsRepositoryName) []string { return v.Excludes }).(pulumi.StringArrayOutput) +} + +// Array of repository names or patterns to include. One of these patterns must match for the condition to pass. Also accepts `~ALL` to include all repositories. +func (o OrganizationRulesetConditionsRepositoryNameOutput) Includes() pulumi.StringArrayOutput { + return o.ApplyT(func(v OrganizationRulesetConditionsRepositoryName) []string { return v.Includes }).(pulumi.StringArrayOutput) +} + +// Whether renaming of target repositories is prevented. +func (o OrganizationRulesetConditionsRepositoryNameOutput) Protected() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetConditionsRepositoryName) *bool { return v.Protected }).(pulumi.BoolPtrOutput) +} + +type OrganizationRulesetConditionsRepositoryNamePtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetConditionsRepositoryNamePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetConditionsRepositoryName)(nil)).Elem() +} + +func (o OrganizationRulesetConditionsRepositoryNamePtrOutput) ToOrganizationRulesetConditionsRepositoryNamePtrOutput() OrganizationRulesetConditionsRepositoryNamePtrOutput { + return o +} + +func (o OrganizationRulesetConditionsRepositoryNamePtrOutput) ToOrganizationRulesetConditionsRepositoryNamePtrOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryNamePtrOutput { + return o +} + +func (o OrganizationRulesetConditionsRepositoryNamePtrOutput) Elem() OrganizationRulesetConditionsRepositoryNameOutput { + return o.ApplyT(func(v *OrganizationRulesetConditionsRepositoryName) OrganizationRulesetConditionsRepositoryName { + if v != nil { + return *v + } + var ret OrganizationRulesetConditionsRepositoryName + return ret + }).(OrganizationRulesetConditionsRepositoryNameOutput) +} + +// Array of repository names or patterns to exclude. The condition will not pass if any of these patterns match. +func (o OrganizationRulesetConditionsRepositoryNamePtrOutput) Excludes() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OrganizationRulesetConditionsRepositoryName) []string { + if v == nil { + return nil + } + return v.Excludes + }).(pulumi.StringArrayOutput) +} + +// Array of repository names or patterns to include. One of these patterns must match for the condition to pass. Also accepts `~ALL` to include all repositories. +func (o OrganizationRulesetConditionsRepositoryNamePtrOutput) Includes() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OrganizationRulesetConditionsRepositoryName) []string { + if v == nil { + return nil + } + return v.Includes + }).(pulumi.StringArrayOutput) +} + +// Whether renaming of target repositories is prevented. +func (o OrganizationRulesetConditionsRepositoryNamePtrOutput) Protected() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetConditionsRepositoryName) *bool { + if v == nil { + return nil + } + return v.Protected + }).(pulumi.BoolPtrOutput) +} + +type OrganizationRulesetConditionsRepositoryProperty struct { + // The repository properties and values to exclude. The ruleset will not apply if any of these properties match. + Excludes []OrganizationRulesetConditionsRepositoryPropertyExclude `pulumi:"excludes"` + // The repository properties and values to include. All of these properties must match for the condition to pass. + Includes []OrganizationRulesetConditionsRepositoryPropertyInclude `pulumi:"includes"` +} + +// OrganizationRulesetConditionsRepositoryPropertyInput is an input type that accepts OrganizationRulesetConditionsRepositoryPropertyArgs and OrganizationRulesetConditionsRepositoryPropertyOutput values. +// You can construct a concrete instance of `OrganizationRulesetConditionsRepositoryPropertyInput` via: +// +// OrganizationRulesetConditionsRepositoryPropertyArgs{...} +type OrganizationRulesetConditionsRepositoryPropertyInput interface { + pulumi.Input + + ToOrganizationRulesetConditionsRepositoryPropertyOutput() OrganizationRulesetConditionsRepositoryPropertyOutput + ToOrganizationRulesetConditionsRepositoryPropertyOutputWithContext(context.Context) OrganizationRulesetConditionsRepositoryPropertyOutput +} + +type OrganizationRulesetConditionsRepositoryPropertyArgs struct { + // The repository properties and values to exclude. The ruleset will not apply if any of these properties match. + Excludes OrganizationRulesetConditionsRepositoryPropertyExcludeArrayInput `pulumi:"excludes"` + // The repository properties and values to include. All of these properties must match for the condition to pass. + Includes OrganizationRulesetConditionsRepositoryPropertyIncludeArrayInput `pulumi:"includes"` +} + +func (OrganizationRulesetConditionsRepositoryPropertyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetConditionsRepositoryProperty)(nil)).Elem() +} + +func (i OrganizationRulesetConditionsRepositoryPropertyArgs) ToOrganizationRulesetConditionsRepositoryPropertyOutput() OrganizationRulesetConditionsRepositoryPropertyOutput { + return i.ToOrganizationRulesetConditionsRepositoryPropertyOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetConditionsRepositoryPropertyArgs) ToOrganizationRulesetConditionsRepositoryPropertyOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryPropertyOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetConditionsRepositoryPropertyOutput) +} + +func (i OrganizationRulesetConditionsRepositoryPropertyArgs) ToOrganizationRulesetConditionsRepositoryPropertyPtrOutput() OrganizationRulesetConditionsRepositoryPropertyPtrOutput { + return i.ToOrganizationRulesetConditionsRepositoryPropertyPtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetConditionsRepositoryPropertyArgs) ToOrganizationRulesetConditionsRepositoryPropertyPtrOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryPropertyPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetConditionsRepositoryPropertyOutput).ToOrganizationRulesetConditionsRepositoryPropertyPtrOutputWithContext(ctx) +} + +// OrganizationRulesetConditionsRepositoryPropertyPtrInput is an input type that accepts OrganizationRulesetConditionsRepositoryPropertyArgs, OrganizationRulesetConditionsRepositoryPropertyPtr and OrganizationRulesetConditionsRepositoryPropertyPtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetConditionsRepositoryPropertyPtrInput` via: +// +// OrganizationRulesetConditionsRepositoryPropertyArgs{...} +// +// or: +// +// nil +type OrganizationRulesetConditionsRepositoryPropertyPtrInput interface { + pulumi.Input + + ToOrganizationRulesetConditionsRepositoryPropertyPtrOutput() OrganizationRulesetConditionsRepositoryPropertyPtrOutput + ToOrganizationRulesetConditionsRepositoryPropertyPtrOutputWithContext(context.Context) OrganizationRulesetConditionsRepositoryPropertyPtrOutput +} + +type organizationRulesetConditionsRepositoryPropertyPtrType OrganizationRulesetConditionsRepositoryPropertyArgs + +func OrganizationRulesetConditionsRepositoryPropertyPtr(v *OrganizationRulesetConditionsRepositoryPropertyArgs) OrganizationRulesetConditionsRepositoryPropertyPtrInput { + return (*organizationRulesetConditionsRepositoryPropertyPtrType)(v) +} + +func (*organizationRulesetConditionsRepositoryPropertyPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetConditionsRepositoryProperty)(nil)).Elem() +} + +func (i *organizationRulesetConditionsRepositoryPropertyPtrType) ToOrganizationRulesetConditionsRepositoryPropertyPtrOutput() OrganizationRulesetConditionsRepositoryPropertyPtrOutput { + return i.ToOrganizationRulesetConditionsRepositoryPropertyPtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetConditionsRepositoryPropertyPtrType) ToOrganizationRulesetConditionsRepositoryPropertyPtrOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryPropertyPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetConditionsRepositoryPropertyPtrOutput) +} + +type OrganizationRulesetConditionsRepositoryPropertyOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetConditionsRepositoryPropertyOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetConditionsRepositoryProperty)(nil)).Elem() +} + +func (o OrganizationRulesetConditionsRepositoryPropertyOutput) ToOrganizationRulesetConditionsRepositoryPropertyOutput() OrganizationRulesetConditionsRepositoryPropertyOutput { + return o +} + +func (o OrganizationRulesetConditionsRepositoryPropertyOutput) ToOrganizationRulesetConditionsRepositoryPropertyOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryPropertyOutput { + return o +} + +func (o OrganizationRulesetConditionsRepositoryPropertyOutput) ToOrganizationRulesetConditionsRepositoryPropertyPtrOutput() OrganizationRulesetConditionsRepositoryPropertyPtrOutput { + return o.ToOrganizationRulesetConditionsRepositoryPropertyPtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetConditionsRepositoryPropertyOutput) ToOrganizationRulesetConditionsRepositoryPropertyPtrOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryPropertyPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetConditionsRepositoryProperty) *OrganizationRulesetConditionsRepositoryProperty { + return &v + }).(OrganizationRulesetConditionsRepositoryPropertyPtrOutput) +} + +// The repository properties and values to exclude. The ruleset will not apply if any of these properties match. +func (o OrganizationRulesetConditionsRepositoryPropertyOutput) Excludes() OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput { + return o.ApplyT(func(v OrganizationRulesetConditionsRepositoryProperty) []OrganizationRulesetConditionsRepositoryPropertyExclude { + return v.Excludes + }).(OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput) +} + +// The repository properties and values to include. All of these properties must match for the condition to pass. +func (o OrganizationRulesetConditionsRepositoryPropertyOutput) Includes() OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput { + return o.ApplyT(func(v OrganizationRulesetConditionsRepositoryProperty) []OrganizationRulesetConditionsRepositoryPropertyInclude { + return v.Includes + }).(OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput) +} + +type OrganizationRulesetConditionsRepositoryPropertyPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetConditionsRepositoryPropertyPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetConditionsRepositoryProperty)(nil)).Elem() +} + +func (o OrganizationRulesetConditionsRepositoryPropertyPtrOutput) ToOrganizationRulesetConditionsRepositoryPropertyPtrOutput() OrganizationRulesetConditionsRepositoryPropertyPtrOutput { + return o +} + +func (o OrganizationRulesetConditionsRepositoryPropertyPtrOutput) ToOrganizationRulesetConditionsRepositoryPropertyPtrOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryPropertyPtrOutput { + return o +} + +func (o OrganizationRulesetConditionsRepositoryPropertyPtrOutput) Elem() OrganizationRulesetConditionsRepositoryPropertyOutput { + return o.ApplyT(func(v *OrganizationRulesetConditionsRepositoryProperty) OrganizationRulesetConditionsRepositoryProperty { + if v != nil { + return *v + } + var ret OrganizationRulesetConditionsRepositoryProperty + return ret + }).(OrganizationRulesetConditionsRepositoryPropertyOutput) +} + +// The repository properties and values to exclude. The ruleset will not apply if any of these properties match. +func (o OrganizationRulesetConditionsRepositoryPropertyPtrOutput) Excludes() OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput { + return o.ApplyT(func(v *OrganizationRulesetConditionsRepositoryProperty) []OrganizationRulesetConditionsRepositoryPropertyExclude { + if v == nil { + return nil + } + return v.Excludes + }).(OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput) +} + +// The repository properties and values to include. All of these properties must match for the condition to pass. +func (o OrganizationRulesetConditionsRepositoryPropertyPtrOutput) Includes() OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput { + return o.ApplyT(func(v *OrganizationRulesetConditionsRepositoryProperty) []OrganizationRulesetConditionsRepositoryPropertyInclude { + if v == nil { + return nil + } + return v.Includes + }).(OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput) +} + +type OrganizationRulesetConditionsRepositoryPropertyExclude struct { + // (String) The name of the ruleset. + Name string `pulumi:"name"` + // The values to match for the repository property. + PropertyValues []string `pulumi:"propertyValues"` + // The source of the repository property. Defaults to 'custom' if not specified. Can be one of: custom, system + Source *string `pulumi:"source"` +} + +// OrganizationRulesetConditionsRepositoryPropertyExcludeInput is an input type that accepts OrganizationRulesetConditionsRepositoryPropertyExcludeArgs and OrganizationRulesetConditionsRepositoryPropertyExcludeOutput values. +// You can construct a concrete instance of `OrganizationRulesetConditionsRepositoryPropertyExcludeInput` via: +// +// OrganizationRulesetConditionsRepositoryPropertyExcludeArgs{...} +type OrganizationRulesetConditionsRepositoryPropertyExcludeInput interface { + pulumi.Input + + ToOrganizationRulesetConditionsRepositoryPropertyExcludeOutput() OrganizationRulesetConditionsRepositoryPropertyExcludeOutput + ToOrganizationRulesetConditionsRepositoryPropertyExcludeOutputWithContext(context.Context) OrganizationRulesetConditionsRepositoryPropertyExcludeOutput +} + +type OrganizationRulesetConditionsRepositoryPropertyExcludeArgs struct { + // (String) The name of the ruleset. + Name pulumi.StringInput `pulumi:"name"` + // The values to match for the repository property. + PropertyValues pulumi.StringArrayInput `pulumi:"propertyValues"` + // The source of the repository property. Defaults to 'custom' if not specified. Can be one of: custom, system + Source pulumi.StringPtrInput `pulumi:"source"` +} + +func (OrganizationRulesetConditionsRepositoryPropertyExcludeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetConditionsRepositoryPropertyExclude)(nil)).Elem() +} + +func (i OrganizationRulesetConditionsRepositoryPropertyExcludeArgs) ToOrganizationRulesetConditionsRepositoryPropertyExcludeOutput() OrganizationRulesetConditionsRepositoryPropertyExcludeOutput { + return i.ToOrganizationRulesetConditionsRepositoryPropertyExcludeOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetConditionsRepositoryPropertyExcludeArgs) ToOrganizationRulesetConditionsRepositoryPropertyExcludeOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryPropertyExcludeOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetConditionsRepositoryPropertyExcludeOutput) +} + +// OrganizationRulesetConditionsRepositoryPropertyExcludeArrayInput is an input type that accepts OrganizationRulesetConditionsRepositoryPropertyExcludeArray and OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput values. +// You can construct a concrete instance of `OrganizationRulesetConditionsRepositoryPropertyExcludeArrayInput` via: +// +// OrganizationRulesetConditionsRepositoryPropertyExcludeArray{ OrganizationRulesetConditionsRepositoryPropertyExcludeArgs{...} } +type OrganizationRulesetConditionsRepositoryPropertyExcludeArrayInput interface { + pulumi.Input + + ToOrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput() OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput + ToOrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutputWithContext(context.Context) OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput +} + +type OrganizationRulesetConditionsRepositoryPropertyExcludeArray []OrganizationRulesetConditionsRepositoryPropertyExcludeInput + +func (OrganizationRulesetConditionsRepositoryPropertyExcludeArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]OrganizationRulesetConditionsRepositoryPropertyExclude)(nil)).Elem() +} + +func (i OrganizationRulesetConditionsRepositoryPropertyExcludeArray) ToOrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput() OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput { + return i.ToOrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetConditionsRepositoryPropertyExcludeArray) ToOrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput) +} + +type OrganizationRulesetConditionsRepositoryPropertyExcludeOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetConditionsRepositoryPropertyExcludeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetConditionsRepositoryPropertyExclude)(nil)).Elem() +} + +func (o OrganizationRulesetConditionsRepositoryPropertyExcludeOutput) ToOrganizationRulesetConditionsRepositoryPropertyExcludeOutput() OrganizationRulesetConditionsRepositoryPropertyExcludeOutput { + return o +} + +func (o OrganizationRulesetConditionsRepositoryPropertyExcludeOutput) ToOrganizationRulesetConditionsRepositoryPropertyExcludeOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryPropertyExcludeOutput { + return o +} + +// (String) The name of the ruleset. +func (o OrganizationRulesetConditionsRepositoryPropertyExcludeOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetConditionsRepositoryPropertyExclude) string { return v.Name }).(pulumi.StringOutput) +} + +// The values to match for the repository property. +func (o OrganizationRulesetConditionsRepositoryPropertyExcludeOutput) PropertyValues() pulumi.StringArrayOutput { + return o.ApplyT(func(v OrganizationRulesetConditionsRepositoryPropertyExclude) []string { return v.PropertyValues }).(pulumi.StringArrayOutput) +} + +// The source of the repository property. Defaults to 'custom' if not specified. Can be one of: custom, system +func (o OrganizationRulesetConditionsRepositoryPropertyExcludeOutput) Source() pulumi.StringPtrOutput { + return o.ApplyT(func(v OrganizationRulesetConditionsRepositoryPropertyExclude) *string { return v.Source }).(pulumi.StringPtrOutput) +} + +type OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]OrganizationRulesetConditionsRepositoryPropertyExclude)(nil)).Elem() +} + +func (o OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput) ToOrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput() OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput { + return o +} + +func (o OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput) ToOrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput { + return o +} + +func (o OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput) Index(i pulumi.IntInput) OrganizationRulesetConditionsRepositoryPropertyExcludeOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) OrganizationRulesetConditionsRepositoryPropertyExclude { + return vs[0].([]OrganizationRulesetConditionsRepositoryPropertyExclude)[vs[1].(int)] + }).(OrganizationRulesetConditionsRepositoryPropertyExcludeOutput) +} + +type OrganizationRulesetConditionsRepositoryPropertyInclude struct { + // (String) The name of the ruleset. + Name string `pulumi:"name"` + // The values to match for the repository property. + PropertyValues []string `pulumi:"propertyValues"` + // The source of the repository property. Defaults to 'custom' if not specified. Can be one of: custom, system + Source *string `pulumi:"source"` +} + +// OrganizationRulesetConditionsRepositoryPropertyIncludeInput is an input type that accepts OrganizationRulesetConditionsRepositoryPropertyIncludeArgs and OrganizationRulesetConditionsRepositoryPropertyIncludeOutput values. +// You can construct a concrete instance of `OrganizationRulesetConditionsRepositoryPropertyIncludeInput` via: +// +// OrganizationRulesetConditionsRepositoryPropertyIncludeArgs{...} +type OrganizationRulesetConditionsRepositoryPropertyIncludeInput interface { + pulumi.Input + + ToOrganizationRulesetConditionsRepositoryPropertyIncludeOutput() OrganizationRulesetConditionsRepositoryPropertyIncludeOutput + ToOrganizationRulesetConditionsRepositoryPropertyIncludeOutputWithContext(context.Context) OrganizationRulesetConditionsRepositoryPropertyIncludeOutput +} + +type OrganizationRulesetConditionsRepositoryPropertyIncludeArgs struct { + // (String) The name of the ruleset. + Name pulumi.StringInput `pulumi:"name"` + // The values to match for the repository property. + PropertyValues pulumi.StringArrayInput `pulumi:"propertyValues"` + // The source of the repository property. Defaults to 'custom' if not specified. Can be one of: custom, system + Source pulumi.StringPtrInput `pulumi:"source"` +} + +func (OrganizationRulesetConditionsRepositoryPropertyIncludeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetConditionsRepositoryPropertyInclude)(nil)).Elem() +} + +func (i OrganizationRulesetConditionsRepositoryPropertyIncludeArgs) ToOrganizationRulesetConditionsRepositoryPropertyIncludeOutput() OrganizationRulesetConditionsRepositoryPropertyIncludeOutput { + return i.ToOrganizationRulesetConditionsRepositoryPropertyIncludeOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetConditionsRepositoryPropertyIncludeArgs) ToOrganizationRulesetConditionsRepositoryPropertyIncludeOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryPropertyIncludeOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetConditionsRepositoryPropertyIncludeOutput) +} + +// OrganizationRulesetConditionsRepositoryPropertyIncludeArrayInput is an input type that accepts OrganizationRulesetConditionsRepositoryPropertyIncludeArray and OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput values. +// You can construct a concrete instance of `OrganizationRulesetConditionsRepositoryPropertyIncludeArrayInput` via: +// +// OrganizationRulesetConditionsRepositoryPropertyIncludeArray{ OrganizationRulesetConditionsRepositoryPropertyIncludeArgs{...} } +type OrganizationRulesetConditionsRepositoryPropertyIncludeArrayInput interface { + pulumi.Input + + ToOrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput() OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput + ToOrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutputWithContext(context.Context) OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput +} + +type OrganizationRulesetConditionsRepositoryPropertyIncludeArray []OrganizationRulesetConditionsRepositoryPropertyIncludeInput + +func (OrganizationRulesetConditionsRepositoryPropertyIncludeArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]OrganizationRulesetConditionsRepositoryPropertyInclude)(nil)).Elem() +} + +func (i OrganizationRulesetConditionsRepositoryPropertyIncludeArray) ToOrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput() OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput { + return i.ToOrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetConditionsRepositoryPropertyIncludeArray) ToOrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput) +} + +type OrganizationRulesetConditionsRepositoryPropertyIncludeOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetConditionsRepositoryPropertyIncludeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetConditionsRepositoryPropertyInclude)(nil)).Elem() +} + +func (o OrganizationRulesetConditionsRepositoryPropertyIncludeOutput) ToOrganizationRulesetConditionsRepositoryPropertyIncludeOutput() OrganizationRulesetConditionsRepositoryPropertyIncludeOutput { + return o +} + +func (o OrganizationRulesetConditionsRepositoryPropertyIncludeOutput) ToOrganizationRulesetConditionsRepositoryPropertyIncludeOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryPropertyIncludeOutput { + return o +} + +// (String) The name of the ruleset. +func (o OrganizationRulesetConditionsRepositoryPropertyIncludeOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetConditionsRepositoryPropertyInclude) string { return v.Name }).(pulumi.StringOutput) +} + +// The values to match for the repository property. +func (o OrganizationRulesetConditionsRepositoryPropertyIncludeOutput) PropertyValues() pulumi.StringArrayOutput { + return o.ApplyT(func(v OrganizationRulesetConditionsRepositoryPropertyInclude) []string { return v.PropertyValues }).(pulumi.StringArrayOutput) +} + +// The source of the repository property. Defaults to 'custom' if not specified. Can be one of: custom, system +func (o OrganizationRulesetConditionsRepositoryPropertyIncludeOutput) Source() pulumi.StringPtrOutput { + return o.ApplyT(func(v OrganizationRulesetConditionsRepositoryPropertyInclude) *string { return v.Source }).(pulumi.StringPtrOutput) +} + +type OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]OrganizationRulesetConditionsRepositoryPropertyInclude)(nil)).Elem() +} + +func (o OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput) ToOrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput() OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput { + return o +} + +func (o OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput) ToOrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutputWithContext(ctx context.Context) OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput { + return o +} + +func (o OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput) Index(i pulumi.IntInput) OrganizationRulesetConditionsRepositoryPropertyIncludeOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) OrganizationRulesetConditionsRepositoryPropertyInclude { + return vs[0].([]OrganizationRulesetConditionsRepositoryPropertyInclude)[vs[1].(int)] + }).(OrganizationRulesetConditionsRepositoryPropertyIncludeOutput) +} + +type OrganizationRulesetRules struct { + // (Block List, Max: 1) Parameters to be used for the branchNamePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. Conflicts with `tagNamePattern` as it only applies to rulesets with target `branch`. (see below for nested schema) + BranchNamePattern *OrganizationRulesetRulesBranchNamePattern `pulumi:"branchNamePattern"` + // (Block List, Max: 1) Parameters to be used for the commitAuthorEmailPattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) + CommitAuthorEmailPattern *OrganizationRulesetRulesCommitAuthorEmailPattern `pulumi:"commitAuthorEmailPattern"` + // (Block List, Max: 1) Parameters to be used for the commitMessagePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) + CommitMessagePattern *OrganizationRulesetRulesCommitMessagePattern `pulumi:"commitMessagePattern"` + // (Block List, Max: 1) Parameters to be used for the committerEmailPattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) + CommitterEmailPattern *OrganizationRulesetRulesCommitterEmailPattern `pulumi:"committerEmailPattern"` + // (Block List, Max: 1) Automatically request Copilot code review for new pull requests if the author has access to Copilot code review and their premium requests quota has not reached the limit. (see below for nested schema) + CopilotCodeReview *OrganizationRulesetRulesCopilotCodeReview `pulumi:"copilotCodeReview"` + // (Boolean) Only allow users with bypass permission to create matching refs. + Creation *bool `pulumi:"creation"` + // (Boolean) Only allow users with bypass permissions to delete matching refs. + Deletion *bool `pulumi:"deletion"` + // (Block List, Max: 1) Prevent commits that include files with specified file extensions from being pushed to the commit graph. This rule only applies to rulesets with target `push`. (see below for nested schema) + FileExtensionRestriction *OrganizationRulesetRulesFileExtensionRestriction `pulumi:"fileExtensionRestriction"` + // (Block List, Max: 1) Prevent commits that include changes to specified file paths from being pushed to the commit graph. This rule only applies to rulesets with target `push`. (see below for nested schema) + FilePathRestriction *OrganizationRulesetRulesFilePathRestriction `pulumi:"filePathRestriction"` + // (Integer) The maximum number of characters allowed in file paths. + MaxFilePathLength *OrganizationRulesetRulesMaxFilePathLength `pulumi:"maxFilePathLength"` + // (Integer) The maximum allowed size, in megabytes (MB), of a file. Valid range is 1-100 MB. + MaxFileSize *OrganizationRulesetRulesMaxFileSize `pulumi:"maxFileSize"` + // (Boolean) Prevent users with push access from force pushing to branches. + NonFastForward *bool `pulumi:"nonFastForward"` + // (Block List, Max: 1) Require all commits be made to a non-target branch and submitted via a pull request before they can be merged. (see below for nested schema) + PullRequest *OrganizationRulesetRulesPullRequest `pulumi:"pullRequest"` + // (Block List, Max: 1) Define which tools must provide code scanning results before the reference is updated. When configured, code scanning must be enabled and have results for both the commit and the reference being updated. Multiple code scanning tools can be specified. (see below for nested schema) + RequiredCodeScanning *OrganizationRulesetRulesRequiredCodeScanning `pulumi:"requiredCodeScanning"` + // (Boolean) Prevent merge commits from being pushed to matching branches. + RequiredLinearHistory *bool `pulumi:"requiredLinearHistory"` + // (Boolean) Commits pushed to matching branches must have verified signatures. + RequiredSignatures *bool `pulumi:"requiredSignatures"` + // (Block List, Max: 1) Choose which status checks must pass before branches can be merged into a branch that matches this rule. When enabled, commits must first be pushed to another branch, then merged or pushed directly to a branch that matches this rule after status checks have passed. (see below for nested schema) + RequiredStatusChecks *OrganizationRulesetRulesRequiredStatusChecks `pulumi:"requiredStatusChecks"` + // (Block List, Max: 1) Define which Actions workflows must pass before changes can be merged into a branch matching the rule. Multiple workflows can be specified. (see below for nested schema) + RequiredWorkflows *OrganizationRulesetRulesRequiredWorkflows `pulumi:"requiredWorkflows"` + // (Block List, Max: 1) Parameters to be used for the tagNamePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. Conflicts with `branchNamePattern` as it only applies to rulesets with target `tag`. (see below for nested schema) + TagNamePattern *OrganizationRulesetRulesTagNamePattern `pulumi:"tagNamePattern"` + // (Boolean) Only allow users with bypass permission to update matching refs. + Update *bool `pulumi:"update"` +} + +// OrganizationRulesetRulesInput is an input type that accepts OrganizationRulesetRulesArgs and OrganizationRulesetRulesOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesInput` via: +// +// OrganizationRulesetRulesArgs{...} +type OrganizationRulesetRulesInput interface { + pulumi.Input + + ToOrganizationRulesetRulesOutput() OrganizationRulesetRulesOutput + ToOrganizationRulesetRulesOutputWithContext(context.Context) OrganizationRulesetRulesOutput +} + +type OrganizationRulesetRulesArgs struct { + // (Block List, Max: 1) Parameters to be used for the branchNamePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. Conflicts with `tagNamePattern` as it only applies to rulesets with target `branch`. (see below for nested schema) + BranchNamePattern OrganizationRulesetRulesBranchNamePatternPtrInput `pulumi:"branchNamePattern"` + // (Block List, Max: 1) Parameters to be used for the commitAuthorEmailPattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) + CommitAuthorEmailPattern OrganizationRulesetRulesCommitAuthorEmailPatternPtrInput `pulumi:"commitAuthorEmailPattern"` + // (Block List, Max: 1) Parameters to be used for the commitMessagePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) + CommitMessagePattern OrganizationRulesetRulesCommitMessagePatternPtrInput `pulumi:"commitMessagePattern"` + // (Block List, Max: 1) Parameters to be used for the committerEmailPattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) + CommitterEmailPattern OrganizationRulesetRulesCommitterEmailPatternPtrInput `pulumi:"committerEmailPattern"` + // (Block List, Max: 1) Automatically request Copilot code review for new pull requests if the author has access to Copilot code review and their premium requests quota has not reached the limit. (see below for nested schema) + CopilotCodeReview OrganizationRulesetRulesCopilotCodeReviewPtrInput `pulumi:"copilotCodeReview"` + // (Boolean) Only allow users with bypass permission to create matching refs. + Creation pulumi.BoolPtrInput `pulumi:"creation"` + // (Boolean) Only allow users with bypass permissions to delete matching refs. + Deletion pulumi.BoolPtrInput `pulumi:"deletion"` + // (Block List, Max: 1) Prevent commits that include files with specified file extensions from being pushed to the commit graph. This rule only applies to rulesets with target `push`. (see below for nested schema) + FileExtensionRestriction OrganizationRulesetRulesFileExtensionRestrictionPtrInput `pulumi:"fileExtensionRestriction"` + // (Block List, Max: 1) Prevent commits that include changes to specified file paths from being pushed to the commit graph. This rule only applies to rulesets with target `push`. (see below for nested schema) + FilePathRestriction OrganizationRulesetRulesFilePathRestrictionPtrInput `pulumi:"filePathRestriction"` + // (Integer) The maximum number of characters allowed in file paths. + MaxFilePathLength OrganizationRulesetRulesMaxFilePathLengthPtrInput `pulumi:"maxFilePathLength"` + // (Integer) The maximum allowed size, in megabytes (MB), of a file. Valid range is 1-100 MB. + MaxFileSize OrganizationRulesetRulesMaxFileSizePtrInput `pulumi:"maxFileSize"` + // (Boolean) Prevent users with push access from force pushing to branches. + NonFastForward pulumi.BoolPtrInput `pulumi:"nonFastForward"` + // (Block List, Max: 1) Require all commits be made to a non-target branch and submitted via a pull request before they can be merged. (see below for nested schema) + PullRequest OrganizationRulesetRulesPullRequestPtrInput `pulumi:"pullRequest"` + // (Block List, Max: 1) Define which tools must provide code scanning results before the reference is updated. When configured, code scanning must be enabled and have results for both the commit and the reference being updated. Multiple code scanning tools can be specified. (see below for nested schema) + RequiredCodeScanning OrganizationRulesetRulesRequiredCodeScanningPtrInput `pulumi:"requiredCodeScanning"` + // (Boolean) Prevent merge commits from being pushed to matching branches. + RequiredLinearHistory pulumi.BoolPtrInput `pulumi:"requiredLinearHistory"` + // (Boolean) Commits pushed to matching branches must have verified signatures. + RequiredSignatures pulumi.BoolPtrInput `pulumi:"requiredSignatures"` + // (Block List, Max: 1) Choose which status checks must pass before branches can be merged into a branch that matches this rule. When enabled, commits must first be pushed to another branch, then merged or pushed directly to a branch that matches this rule after status checks have passed. (see below for nested schema) + RequiredStatusChecks OrganizationRulesetRulesRequiredStatusChecksPtrInput `pulumi:"requiredStatusChecks"` + // (Block List, Max: 1) Define which Actions workflows must pass before changes can be merged into a branch matching the rule. Multiple workflows can be specified. (see below for nested schema) + RequiredWorkflows OrganizationRulesetRulesRequiredWorkflowsPtrInput `pulumi:"requiredWorkflows"` + // (Block List, Max: 1) Parameters to be used for the tagNamePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. Conflicts with `branchNamePattern` as it only applies to rulesets with target `tag`. (see below for nested schema) + TagNamePattern OrganizationRulesetRulesTagNamePatternPtrInput `pulumi:"tagNamePattern"` + // (Boolean) Only allow users with bypass permission to update matching refs. + Update pulumi.BoolPtrInput `pulumi:"update"` +} + +func (OrganizationRulesetRulesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRules)(nil)).Elem() +} + +func (i OrganizationRulesetRulesArgs) ToOrganizationRulesetRulesOutput() OrganizationRulesetRulesOutput { + return i.ToOrganizationRulesetRulesOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesArgs) ToOrganizationRulesetRulesOutputWithContext(ctx context.Context) OrganizationRulesetRulesOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesOutput) +} + +func (i OrganizationRulesetRulesArgs) ToOrganizationRulesetRulesPtrOutput() OrganizationRulesetRulesPtrOutput { + return i.ToOrganizationRulesetRulesPtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesArgs) ToOrganizationRulesetRulesPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesOutput).ToOrganizationRulesetRulesPtrOutputWithContext(ctx) +} + +// OrganizationRulesetRulesPtrInput is an input type that accepts OrganizationRulesetRulesArgs, OrganizationRulesetRulesPtr and OrganizationRulesetRulesPtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesPtrInput` via: +// +// OrganizationRulesetRulesArgs{...} +// +// or: +// +// nil +type OrganizationRulesetRulesPtrInput interface { + pulumi.Input + + ToOrganizationRulesetRulesPtrOutput() OrganizationRulesetRulesPtrOutput + ToOrganizationRulesetRulesPtrOutputWithContext(context.Context) OrganizationRulesetRulesPtrOutput +} + +type organizationRulesetRulesPtrType OrganizationRulesetRulesArgs + +func OrganizationRulesetRulesPtr(v *OrganizationRulesetRulesArgs) OrganizationRulesetRulesPtrInput { + return (*organizationRulesetRulesPtrType)(v) +} + +func (*organizationRulesetRulesPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRules)(nil)).Elem() +} + +func (i *organizationRulesetRulesPtrType) ToOrganizationRulesetRulesPtrOutput() OrganizationRulesetRulesPtrOutput { + return i.ToOrganizationRulesetRulesPtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetRulesPtrType) ToOrganizationRulesetRulesPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesPtrOutput) +} + +type OrganizationRulesetRulesOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRules)(nil)).Elem() +} + +func (o OrganizationRulesetRulesOutput) ToOrganizationRulesetRulesOutput() OrganizationRulesetRulesOutput { + return o +} + +func (o OrganizationRulesetRulesOutput) ToOrganizationRulesetRulesOutputWithContext(ctx context.Context) OrganizationRulesetRulesOutput { + return o +} + +func (o OrganizationRulesetRulesOutput) ToOrganizationRulesetRulesPtrOutput() OrganizationRulesetRulesPtrOutput { + return o.ToOrganizationRulesetRulesPtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetRulesOutput) ToOrganizationRulesetRulesPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetRules) *OrganizationRulesetRules { + return &v + }).(OrganizationRulesetRulesPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the branchNamePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. Conflicts with `tagNamePattern` as it only applies to rulesets with target `branch`. (see below for nested schema) +func (o OrganizationRulesetRulesOutput) BranchNamePattern() OrganizationRulesetRulesBranchNamePatternPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *OrganizationRulesetRulesBranchNamePattern { + return v.BranchNamePattern + }).(OrganizationRulesetRulesBranchNamePatternPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the commitAuthorEmailPattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) +func (o OrganizationRulesetRulesOutput) CommitAuthorEmailPattern() OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *OrganizationRulesetRulesCommitAuthorEmailPattern { + return v.CommitAuthorEmailPattern + }).(OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the commitMessagePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) +func (o OrganizationRulesetRulesOutput) CommitMessagePattern() OrganizationRulesetRulesCommitMessagePatternPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *OrganizationRulesetRulesCommitMessagePattern { + return v.CommitMessagePattern + }).(OrganizationRulesetRulesCommitMessagePatternPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the committerEmailPattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) +func (o OrganizationRulesetRulesOutput) CommitterEmailPattern() OrganizationRulesetRulesCommitterEmailPatternPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *OrganizationRulesetRulesCommitterEmailPattern { + return v.CommitterEmailPattern + }).(OrganizationRulesetRulesCommitterEmailPatternPtrOutput) +} + +// (Block List, Max: 1) Automatically request Copilot code review for new pull requests if the author has access to Copilot code review and their premium requests quota has not reached the limit. (see below for nested schema) +func (o OrganizationRulesetRulesOutput) CopilotCodeReview() OrganizationRulesetRulesCopilotCodeReviewPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *OrganizationRulesetRulesCopilotCodeReview { + return v.CopilotCodeReview + }).(OrganizationRulesetRulesCopilotCodeReviewPtrOutput) +} + +// (Boolean) Only allow users with bypass permission to create matching refs. +func (o OrganizationRulesetRulesOutput) Creation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *bool { return v.Creation }).(pulumi.BoolPtrOutput) +} + +// (Boolean) Only allow users with bypass permissions to delete matching refs. +func (o OrganizationRulesetRulesOutput) Deletion() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *bool { return v.Deletion }).(pulumi.BoolPtrOutput) +} + +// (Block List, Max: 1) Prevent commits that include files with specified file extensions from being pushed to the commit graph. This rule only applies to rulesets with target `push`. (see below for nested schema) +func (o OrganizationRulesetRulesOutput) FileExtensionRestriction() OrganizationRulesetRulesFileExtensionRestrictionPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *OrganizationRulesetRulesFileExtensionRestriction { + return v.FileExtensionRestriction + }).(OrganizationRulesetRulesFileExtensionRestrictionPtrOutput) +} + +// (Block List, Max: 1) Prevent commits that include changes to specified file paths from being pushed to the commit graph. This rule only applies to rulesets with target `push`. (see below for nested schema) +func (o OrganizationRulesetRulesOutput) FilePathRestriction() OrganizationRulesetRulesFilePathRestrictionPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *OrganizationRulesetRulesFilePathRestriction { + return v.FilePathRestriction + }).(OrganizationRulesetRulesFilePathRestrictionPtrOutput) +} + +// (Integer) The maximum number of characters allowed in file paths. +func (o OrganizationRulesetRulesOutput) MaxFilePathLength() OrganizationRulesetRulesMaxFilePathLengthPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *OrganizationRulesetRulesMaxFilePathLength { + return v.MaxFilePathLength + }).(OrganizationRulesetRulesMaxFilePathLengthPtrOutput) +} + +// (Integer) The maximum allowed size, in megabytes (MB), of a file. Valid range is 1-100 MB. +func (o OrganizationRulesetRulesOutput) MaxFileSize() OrganizationRulesetRulesMaxFileSizePtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *OrganizationRulesetRulesMaxFileSize { return v.MaxFileSize }).(OrganizationRulesetRulesMaxFileSizePtrOutput) +} + +// (Boolean) Prevent users with push access from force pushing to branches. +func (o OrganizationRulesetRulesOutput) NonFastForward() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *bool { return v.NonFastForward }).(pulumi.BoolPtrOutput) +} + +// (Block List, Max: 1) Require all commits be made to a non-target branch and submitted via a pull request before they can be merged. (see below for nested schema) +func (o OrganizationRulesetRulesOutput) PullRequest() OrganizationRulesetRulesPullRequestPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *OrganizationRulesetRulesPullRequest { return v.PullRequest }).(OrganizationRulesetRulesPullRequestPtrOutput) +} + +// (Block List, Max: 1) Define which tools must provide code scanning results before the reference is updated. When configured, code scanning must be enabled and have results for both the commit and the reference being updated. Multiple code scanning tools can be specified. (see below for nested schema) +func (o OrganizationRulesetRulesOutput) RequiredCodeScanning() OrganizationRulesetRulesRequiredCodeScanningPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *OrganizationRulesetRulesRequiredCodeScanning { + return v.RequiredCodeScanning + }).(OrganizationRulesetRulesRequiredCodeScanningPtrOutput) +} + +// (Boolean) Prevent merge commits from being pushed to matching branches. +func (o OrganizationRulesetRulesOutput) RequiredLinearHistory() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *bool { return v.RequiredLinearHistory }).(pulumi.BoolPtrOutput) +} + +// (Boolean) Commits pushed to matching branches must have verified signatures. +func (o OrganizationRulesetRulesOutput) RequiredSignatures() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *bool { return v.RequiredSignatures }).(pulumi.BoolPtrOutput) +} + +// (Block List, Max: 1) Choose which status checks must pass before branches can be merged into a branch that matches this rule. When enabled, commits must first be pushed to another branch, then merged or pushed directly to a branch that matches this rule after status checks have passed. (see below for nested schema) +func (o OrganizationRulesetRulesOutput) RequiredStatusChecks() OrganizationRulesetRulesRequiredStatusChecksPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *OrganizationRulesetRulesRequiredStatusChecks { + return v.RequiredStatusChecks + }).(OrganizationRulesetRulesRequiredStatusChecksPtrOutput) +} + +// (Block List, Max: 1) Define which Actions workflows must pass before changes can be merged into a branch matching the rule. Multiple workflows can be specified. (see below for nested schema) +func (o OrganizationRulesetRulesOutput) RequiredWorkflows() OrganizationRulesetRulesRequiredWorkflowsPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *OrganizationRulesetRulesRequiredWorkflows { + return v.RequiredWorkflows + }).(OrganizationRulesetRulesRequiredWorkflowsPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the tagNamePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. Conflicts with `branchNamePattern` as it only applies to rulesets with target `tag`. (see below for nested schema) +func (o OrganizationRulesetRulesOutput) TagNamePattern() OrganizationRulesetRulesTagNamePatternPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *OrganizationRulesetRulesTagNamePattern { return v.TagNamePattern }).(OrganizationRulesetRulesTagNamePatternPtrOutput) +} + +// (Boolean) Only allow users with bypass permission to update matching refs. +func (o OrganizationRulesetRulesOutput) Update() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRules) *bool { return v.Update }).(pulumi.BoolPtrOutput) +} + +type OrganizationRulesetRulesPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRules)(nil)).Elem() +} + +func (o OrganizationRulesetRulesPtrOutput) ToOrganizationRulesetRulesPtrOutput() OrganizationRulesetRulesPtrOutput { + return o +} + +func (o OrganizationRulesetRulesPtrOutput) ToOrganizationRulesetRulesPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesPtrOutput { + return o +} + +func (o OrganizationRulesetRulesPtrOutput) Elem() OrganizationRulesetRulesOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) OrganizationRulesetRules { + if v != nil { + return *v + } + var ret OrganizationRulesetRules + return ret + }).(OrganizationRulesetRulesOutput) +} + +// (Block List, Max: 1) Parameters to be used for the branchNamePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. Conflicts with `tagNamePattern` as it only applies to rulesets with target `branch`. (see below for nested schema) +func (o OrganizationRulesetRulesPtrOutput) BranchNamePattern() OrganizationRulesetRulesBranchNamePatternPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *OrganizationRulesetRulesBranchNamePattern { + if v == nil { + return nil + } + return v.BranchNamePattern + }).(OrganizationRulesetRulesBranchNamePatternPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the commitAuthorEmailPattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) +func (o OrganizationRulesetRulesPtrOutput) CommitAuthorEmailPattern() OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *OrganizationRulesetRulesCommitAuthorEmailPattern { + if v == nil { + return nil + } + return v.CommitAuthorEmailPattern + }).(OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the commitMessagePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) +func (o OrganizationRulesetRulesPtrOutput) CommitMessagePattern() OrganizationRulesetRulesCommitMessagePatternPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *OrganizationRulesetRulesCommitMessagePattern { + if v == nil { + return nil + } + return v.CommitMessagePattern + }).(OrganizationRulesetRulesCommitMessagePatternPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the committerEmailPattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) +func (o OrganizationRulesetRulesPtrOutput) CommitterEmailPattern() OrganizationRulesetRulesCommitterEmailPatternPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *OrganizationRulesetRulesCommitterEmailPattern { + if v == nil { + return nil + } + return v.CommitterEmailPattern + }).(OrganizationRulesetRulesCommitterEmailPatternPtrOutput) +} + +// (Block List, Max: 1) Automatically request Copilot code review for new pull requests if the author has access to Copilot code review and their premium requests quota has not reached the limit. (see below for nested schema) +func (o OrganizationRulesetRulesPtrOutput) CopilotCodeReview() OrganizationRulesetRulesCopilotCodeReviewPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *OrganizationRulesetRulesCopilotCodeReview { + if v == nil { + return nil + } + return v.CopilotCodeReview + }).(OrganizationRulesetRulesCopilotCodeReviewPtrOutput) +} + +// (Boolean) Only allow users with bypass permission to create matching refs. +func (o OrganizationRulesetRulesPtrOutput) Creation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *bool { + if v == nil { + return nil + } + return v.Creation + }).(pulumi.BoolPtrOutput) +} + +// (Boolean) Only allow users with bypass permissions to delete matching refs. +func (o OrganizationRulesetRulesPtrOutput) Deletion() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *bool { + if v == nil { + return nil + } + return v.Deletion + }).(pulumi.BoolPtrOutput) +} + +// (Block List, Max: 1) Prevent commits that include files with specified file extensions from being pushed to the commit graph. This rule only applies to rulesets with target `push`. (see below for nested schema) +func (o OrganizationRulesetRulesPtrOutput) FileExtensionRestriction() OrganizationRulesetRulesFileExtensionRestrictionPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *OrganizationRulesetRulesFileExtensionRestriction { + if v == nil { + return nil + } + return v.FileExtensionRestriction + }).(OrganizationRulesetRulesFileExtensionRestrictionPtrOutput) +} + +// (Block List, Max: 1) Prevent commits that include changes to specified file paths from being pushed to the commit graph. This rule only applies to rulesets with target `push`. (see below for nested schema) +func (o OrganizationRulesetRulesPtrOutput) FilePathRestriction() OrganizationRulesetRulesFilePathRestrictionPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *OrganizationRulesetRulesFilePathRestriction { + if v == nil { + return nil + } + return v.FilePathRestriction + }).(OrganizationRulesetRulesFilePathRestrictionPtrOutput) +} + +// (Integer) The maximum number of characters allowed in file paths. +func (o OrganizationRulesetRulesPtrOutput) MaxFilePathLength() OrganizationRulesetRulesMaxFilePathLengthPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *OrganizationRulesetRulesMaxFilePathLength { + if v == nil { + return nil + } + return v.MaxFilePathLength + }).(OrganizationRulesetRulesMaxFilePathLengthPtrOutput) +} + +// (Integer) The maximum allowed size, in megabytes (MB), of a file. Valid range is 1-100 MB. +func (o OrganizationRulesetRulesPtrOutput) MaxFileSize() OrganizationRulesetRulesMaxFileSizePtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *OrganizationRulesetRulesMaxFileSize { + if v == nil { + return nil + } + return v.MaxFileSize + }).(OrganizationRulesetRulesMaxFileSizePtrOutput) +} + +// (Boolean) Prevent users with push access from force pushing to branches. +func (o OrganizationRulesetRulesPtrOutput) NonFastForward() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *bool { + if v == nil { + return nil + } + return v.NonFastForward + }).(pulumi.BoolPtrOutput) +} + +// (Block List, Max: 1) Require all commits be made to a non-target branch and submitted via a pull request before they can be merged. (see below for nested schema) +func (o OrganizationRulesetRulesPtrOutput) PullRequest() OrganizationRulesetRulesPullRequestPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *OrganizationRulesetRulesPullRequest { + if v == nil { + return nil + } + return v.PullRequest + }).(OrganizationRulesetRulesPullRequestPtrOutput) +} + +// (Block List, Max: 1) Define which tools must provide code scanning results before the reference is updated. When configured, code scanning must be enabled and have results for both the commit and the reference being updated. Multiple code scanning tools can be specified. (see below for nested schema) +func (o OrganizationRulesetRulesPtrOutput) RequiredCodeScanning() OrganizationRulesetRulesRequiredCodeScanningPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *OrganizationRulesetRulesRequiredCodeScanning { + if v == nil { + return nil + } + return v.RequiredCodeScanning + }).(OrganizationRulesetRulesRequiredCodeScanningPtrOutput) +} + +// (Boolean) Prevent merge commits from being pushed to matching branches. +func (o OrganizationRulesetRulesPtrOutput) RequiredLinearHistory() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *bool { + if v == nil { + return nil + } + return v.RequiredLinearHistory + }).(pulumi.BoolPtrOutput) +} + +// (Boolean) Commits pushed to matching branches must have verified signatures. +func (o OrganizationRulesetRulesPtrOutput) RequiredSignatures() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *bool { + if v == nil { + return nil + } + return v.RequiredSignatures + }).(pulumi.BoolPtrOutput) +} + +// (Block List, Max: 1) Choose which status checks must pass before branches can be merged into a branch that matches this rule. When enabled, commits must first be pushed to another branch, then merged or pushed directly to a branch that matches this rule after status checks have passed. (see below for nested schema) +func (o OrganizationRulesetRulesPtrOutput) RequiredStatusChecks() OrganizationRulesetRulesRequiredStatusChecksPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *OrganizationRulesetRulesRequiredStatusChecks { + if v == nil { + return nil + } + return v.RequiredStatusChecks + }).(OrganizationRulesetRulesRequiredStatusChecksPtrOutput) +} + +// (Block List, Max: 1) Define which Actions workflows must pass before changes can be merged into a branch matching the rule. Multiple workflows can be specified. (see below for nested schema) +func (o OrganizationRulesetRulesPtrOutput) RequiredWorkflows() OrganizationRulesetRulesRequiredWorkflowsPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *OrganizationRulesetRulesRequiredWorkflows { + if v == nil { + return nil + } + return v.RequiredWorkflows + }).(OrganizationRulesetRulesRequiredWorkflowsPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the tagNamePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. Conflicts with `branchNamePattern` as it only applies to rulesets with target `tag`. (see below for nested schema) +func (o OrganizationRulesetRulesPtrOutput) TagNamePattern() OrganizationRulesetRulesTagNamePatternPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *OrganizationRulesetRulesTagNamePattern { + if v == nil { + return nil + } + return v.TagNamePattern + }).(OrganizationRulesetRulesTagNamePatternPtrOutput) +} + +// (Boolean) Only allow users with bypass permission to update matching refs. +func (o OrganizationRulesetRulesPtrOutput) Update() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRules) *bool { + if v == nil { + return nil + } + return v.Update + }).(pulumi.BoolPtrOutput) +} + +type OrganizationRulesetRulesBranchNamePattern struct { + // (String) The name of the ruleset. + Name *string `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate *bool `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator string `pulumi:"operator"` + // The pattern to match with. + Pattern string `pulumi:"pattern"` +} + +// OrganizationRulesetRulesBranchNamePatternInput is an input type that accepts OrganizationRulesetRulesBranchNamePatternArgs and OrganizationRulesetRulesBranchNamePatternOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesBranchNamePatternInput` via: +// +// OrganizationRulesetRulesBranchNamePatternArgs{...} +type OrganizationRulesetRulesBranchNamePatternInput interface { + pulumi.Input + + ToOrganizationRulesetRulesBranchNamePatternOutput() OrganizationRulesetRulesBranchNamePatternOutput + ToOrganizationRulesetRulesBranchNamePatternOutputWithContext(context.Context) OrganizationRulesetRulesBranchNamePatternOutput +} + +type OrganizationRulesetRulesBranchNamePatternArgs struct { + // (String) The name of the ruleset. + Name pulumi.StringPtrInput `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate pulumi.BoolPtrInput `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator pulumi.StringInput `pulumi:"operator"` + // The pattern to match with. + Pattern pulumi.StringInput `pulumi:"pattern"` +} + +func (OrganizationRulesetRulesBranchNamePatternArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesBranchNamePattern)(nil)).Elem() +} + +func (i OrganizationRulesetRulesBranchNamePatternArgs) ToOrganizationRulesetRulesBranchNamePatternOutput() OrganizationRulesetRulesBranchNamePatternOutput { + return i.ToOrganizationRulesetRulesBranchNamePatternOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesBranchNamePatternArgs) ToOrganizationRulesetRulesBranchNamePatternOutputWithContext(ctx context.Context) OrganizationRulesetRulesBranchNamePatternOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesBranchNamePatternOutput) +} + +func (i OrganizationRulesetRulesBranchNamePatternArgs) ToOrganizationRulesetRulesBranchNamePatternPtrOutput() OrganizationRulesetRulesBranchNamePatternPtrOutput { + return i.ToOrganizationRulesetRulesBranchNamePatternPtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesBranchNamePatternArgs) ToOrganizationRulesetRulesBranchNamePatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesBranchNamePatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesBranchNamePatternOutput).ToOrganizationRulesetRulesBranchNamePatternPtrOutputWithContext(ctx) +} + +// OrganizationRulesetRulesBranchNamePatternPtrInput is an input type that accepts OrganizationRulesetRulesBranchNamePatternArgs, OrganizationRulesetRulesBranchNamePatternPtr and OrganizationRulesetRulesBranchNamePatternPtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesBranchNamePatternPtrInput` via: +// +// OrganizationRulesetRulesBranchNamePatternArgs{...} +// +// or: +// +// nil +type OrganizationRulesetRulesBranchNamePatternPtrInput interface { + pulumi.Input + + ToOrganizationRulesetRulesBranchNamePatternPtrOutput() OrganizationRulesetRulesBranchNamePatternPtrOutput + ToOrganizationRulesetRulesBranchNamePatternPtrOutputWithContext(context.Context) OrganizationRulesetRulesBranchNamePatternPtrOutput +} + +type organizationRulesetRulesBranchNamePatternPtrType OrganizationRulesetRulesBranchNamePatternArgs + +func OrganizationRulesetRulesBranchNamePatternPtr(v *OrganizationRulesetRulesBranchNamePatternArgs) OrganizationRulesetRulesBranchNamePatternPtrInput { + return (*organizationRulesetRulesBranchNamePatternPtrType)(v) +} + +func (*organizationRulesetRulesBranchNamePatternPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesBranchNamePattern)(nil)).Elem() +} + +func (i *organizationRulesetRulesBranchNamePatternPtrType) ToOrganizationRulesetRulesBranchNamePatternPtrOutput() OrganizationRulesetRulesBranchNamePatternPtrOutput { + return i.ToOrganizationRulesetRulesBranchNamePatternPtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetRulesBranchNamePatternPtrType) ToOrganizationRulesetRulesBranchNamePatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesBranchNamePatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesBranchNamePatternPtrOutput) +} + +type OrganizationRulesetRulesBranchNamePatternOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesBranchNamePatternOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesBranchNamePattern)(nil)).Elem() +} + +func (o OrganizationRulesetRulesBranchNamePatternOutput) ToOrganizationRulesetRulesBranchNamePatternOutput() OrganizationRulesetRulesBranchNamePatternOutput { + return o +} + +func (o OrganizationRulesetRulesBranchNamePatternOutput) ToOrganizationRulesetRulesBranchNamePatternOutputWithContext(ctx context.Context) OrganizationRulesetRulesBranchNamePatternOutput { + return o +} + +func (o OrganizationRulesetRulesBranchNamePatternOutput) ToOrganizationRulesetRulesBranchNamePatternPtrOutput() OrganizationRulesetRulesBranchNamePatternPtrOutput { + return o.ToOrganizationRulesetRulesBranchNamePatternPtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetRulesBranchNamePatternOutput) ToOrganizationRulesetRulesBranchNamePatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesBranchNamePatternPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetRulesBranchNamePattern) *OrganizationRulesetRulesBranchNamePattern { + return &v + }).(OrganizationRulesetRulesBranchNamePatternPtrOutput) +} + +// (String) The name of the ruleset. +func (o OrganizationRulesetRulesBranchNamePatternOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesBranchNamePattern) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o OrganizationRulesetRulesBranchNamePatternOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesBranchNamePattern) *bool { return v.Negate }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o OrganizationRulesetRulesBranchNamePatternOutput) Operator() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetRulesBranchNamePattern) string { return v.Operator }).(pulumi.StringOutput) +} + +// The pattern to match with. +func (o OrganizationRulesetRulesBranchNamePatternOutput) Pattern() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetRulesBranchNamePattern) string { return v.Pattern }).(pulumi.StringOutput) +} + +type OrganizationRulesetRulesBranchNamePatternPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesBranchNamePatternPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesBranchNamePattern)(nil)).Elem() +} + +func (o OrganizationRulesetRulesBranchNamePatternPtrOutput) ToOrganizationRulesetRulesBranchNamePatternPtrOutput() OrganizationRulesetRulesBranchNamePatternPtrOutput { + return o +} + +func (o OrganizationRulesetRulesBranchNamePatternPtrOutput) ToOrganizationRulesetRulesBranchNamePatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesBranchNamePatternPtrOutput { + return o +} + +func (o OrganizationRulesetRulesBranchNamePatternPtrOutput) Elem() OrganizationRulesetRulesBranchNamePatternOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesBranchNamePattern) OrganizationRulesetRulesBranchNamePattern { + if v != nil { + return *v + } + var ret OrganizationRulesetRulesBranchNamePattern + return ret + }).(OrganizationRulesetRulesBranchNamePatternOutput) +} + +// (String) The name of the ruleset. +func (o OrganizationRulesetRulesBranchNamePatternPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesBranchNamePattern) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o OrganizationRulesetRulesBranchNamePatternPtrOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesBranchNamePattern) *bool { + if v == nil { + return nil + } + return v.Negate + }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o OrganizationRulesetRulesBranchNamePatternPtrOutput) Operator() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesBranchNamePattern) *string { + if v == nil { + return nil + } + return &v.Operator + }).(pulumi.StringPtrOutput) +} + +// The pattern to match with. +func (o OrganizationRulesetRulesBranchNamePatternPtrOutput) Pattern() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesBranchNamePattern) *string { + if v == nil { + return nil + } + return &v.Pattern + }).(pulumi.StringPtrOutput) +} + +type OrganizationRulesetRulesCommitAuthorEmailPattern struct { + // (String) The name of the ruleset. + Name *string `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate *bool `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator string `pulumi:"operator"` + // The pattern to match with. + Pattern string `pulumi:"pattern"` +} + +// OrganizationRulesetRulesCommitAuthorEmailPatternInput is an input type that accepts OrganizationRulesetRulesCommitAuthorEmailPatternArgs and OrganizationRulesetRulesCommitAuthorEmailPatternOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesCommitAuthorEmailPatternInput` via: +// +// OrganizationRulesetRulesCommitAuthorEmailPatternArgs{...} +type OrganizationRulesetRulesCommitAuthorEmailPatternInput interface { + pulumi.Input + + ToOrganizationRulesetRulesCommitAuthorEmailPatternOutput() OrganizationRulesetRulesCommitAuthorEmailPatternOutput + ToOrganizationRulesetRulesCommitAuthorEmailPatternOutputWithContext(context.Context) OrganizationRulesetRulesCommitAuthorEmailPatternOutput +} + +type OrganizationRulesetRulesCommitAuthorEmailPatternArgs struct { + // (String) The name of the ruleset. + Name pulumi.StringPtrInput `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate pulumi.BoolPtrInput `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator pulumi.StringInput `pulumi:"operator"` + // The pattern to match with. + Pattern pulumi.StringInput `pulumi:"pattern"` +} + +func (OrganizationRulesetRulesCommitAuthorEmailPatternArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesCommitAuthorEmailPattern)(nil)).Elem() +} + +func (i OrganizationRulesetRulesCommitAuthorEmailPatternArgs) ToOrganizationRulesetRulesCommitAuthorEmailPatternOutput() OrganizationRulesetRulesCommitAuthorEmailPatternOutput { + return i.ToOrganizationRulesetRulesCommitAuthorEmailPatternOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesCommitAuthorEmailPatternArgs) ToOrganizationRulesetRulesCommitAuthorEmailPatternOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitAuthorEmailPatternOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesCommitAuthorEmailPatternOutput) +} + +func (i OrganizationRulesetRulesCommitAuthorEmailPatternArgs) ToOrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput() OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput { + return i.ToOrganizationRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesCommitAuthorEmailPatternArgs) ToOrganizationRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesCommitAuthorEmailPatternOutput).ToOrganizationRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(ctx) +} + +// OrganizationRulesetRulesCommitAuthorEmailPatternPtrInput is an input type that accepts OrganizationRulesetRulesCommitAuthorEmailPatternArgs, OrganizationRulesetRulesCommitAuthorEmailPatternPtr and OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesCommitAuthorEmailPatternPtrInput` via: +// +// OrganizationRulesetRulesCommitAuthorEmailPatternArgs{...} +// +// or: +// +// nil +type OrganizationRulesetRulesCommitAuthorEmailPatternPtrInput interface { + pulumi.Input + + ToOrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput() OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput + ToOrganizationRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(context.Context) OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput +} + +type organizationRulesetRulesCommitAuthorEmailPatternPtrType OrganizationRulesetRulesCommitAuthorEmailPatternArgs + +func OrganizationRulesetRulesCommitAuthorEmailPatternPtr(v *OrganizationRulesetRulesCommitAuthorEmailPatternArgs) OrganizationRulesetRulesCommitAuthorEmailPatternPtrInput { + return (*organizationRulesetRulesCommitAuthorEmailPatternPtrType)(v) +} + +func (*organizationRulesetRulesCommitAuthorEmailPatternPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesCommitAuthorEmailPattern)(nil)).Elem() +} + +func (i *organizationRulesetRulesCommitAuthorEmailPatternPtrType) ToOrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput() OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput { + return i.ToOrganizationRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetRulesCommitAuthorEmailPatternPtrType) ToOrganizationRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput) +} + +type OrganizationRulesetRulesCommitAuthorEmailPatternOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesCommitAuthorEmailPatternOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesCommitAuthorEmailPattern)(nil)).Elem() +} + +func (o OrganizationRulesetRulesCommitAuthorEmailPatternOutput) ToOrganizationRulesetRulesCommitAuthorEmailPatternOutput() OrganizationRulesetRulesCommitAuthorEmailPatternOutput { + return o +} + +func (o OrganizationRulesetRulesCommitAuthorEmailPatternOutput) ToOrganizationRulesetRulesCommitAuthorEmailPatternOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitAuthorEmailPatternOutput { + return o +} + +func (o OrganizationRulesetRulesCommitAuthorEmailPatternOutput) ToOrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput() OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput { + return o.ToOrganizationRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetRulesCommitAuthorEmailPatternOutput) ToOrganizationRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetRulesCommitAuthorEmailPattern) *OrganizationRulesetRulesCommitAuthorEmailPattern { + return &v + }).(OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput) +} + +// (String) The name of the ruleset. +func (o OrganizationRulesetRulesCommitAuthorEmailPatternOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesCommitAuthorEmailPattern) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o OrganizationRulesetRulesCommitAuthorEmailPatternOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesCommitAuthorEmailPattern) *bool { return v.Negate }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o OrganizationRulesetRulesCommitAuthorEmailPatternOutput) Operator() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetRulesCommitAuthorEmailPattern) string { return v.Operator }).(pulumi.StringOutput) +} + +// The pattern to match with. +func (o OrganizationRulesetRulesCommitAuthorEmailPatternOutput) Pattern() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetRulesCommitAuthorEmailPattern) string { return v.Pattern }).(pulumi.StringOutput) +} + +type OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesCommitAuthorEmailPattern)(nil)).Elem() +} + +func (o OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput) ToOrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput() OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput { + return o +} + +func (o OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput) ToOrganizationRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput { + return o +} + +func (o OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput) Elem() OrganizationRulesetRulesCommitAuthorEmailPatternOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCommitAuthorEmailPattern) OrganizationRulesetRulesCommitAuthorEmailPattern { + if v != nil { + return *v + } + var ret OrganizationRulesetRulesCommitAuthorEmailPattern + return ret + }).(OrganizationRulesetRulesCommitAuthorEmailPatternOutput) +} + +// (String) The name of the ruleset. +func (o OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCommitAuthorEmailPattern) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCommitAuthorEmailPattern) *bool { + if v == nil { + return nil + } + return v.Negate + }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput) Operator() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCommitAuthorEmailPattern) *string { + if v == nil { + return nil + } + return &v.Operator + }).(pulumi.StringPtrOutput) +} + +// The pattern to match with. +func (o OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput) Pattern() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCommitAuthorEmailPattern) *string { + if v == nil { + return nil + } + return &v.Pattern + }).(pulumi.StringPtrOutput) +} + +type OrganizationRulesetRulesCommitMessagePattern struct { + // (String) The name of the ruleset. + Name *string `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate *bool `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator string `pulumi:"operator"` + // The pattern to match with. + Pattern string `pulumi:"pattern"` +} + +// OrganizationRulesetRulesCommitMessagePatternInput is an input type that accepts OrganizationRulesetRulesCommitMessagePatternArgs and OrganizationRulesetRulesCommitMessagePatternOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesCommitMessagePatternInput` via: +// +// OrganizationRulesetRulesCommitMessagePatternArgs{...} +type OrganizationRulesetRulesCommitMessagePatternInput interface { + pulumi.Input + + ToOrganizationRulesetRulesCommitMessagePatternOutput() OrganizationRulesetRulesCommitMessagePatternOutput + ToOrganizationRulesetRulesCommitMessagePatternOutputWithContext(context.Context) OrganizationRulesetRulesCommitMessagePatternOutput +} + +type OrganizationRulesetRulesCommitMessagePatternArgs struct { + // (String) The name of the ruleset. + Name pulumi.StringPtrInput `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate pulumi.BoolPtrInput `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator pulumi.StringInput `pulumi:"operator"` + // The pattern to match with. + Pattern pulumi.StringInput `pulumi:"pattern"` +} + +func (OrganizationRulesetRulesCommitMessagePatternArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesCommitMessagePattern)(nil)).Elem() +} + +func (i OrganizationRulesetRulesCommitMessagePatternArgs) ToOrganizationRulesetRulesCommitMessagePatternOutput() OrganizationRulesetRulesCommitMessagePatternOutput { + return i.ToOrganizationRulesetRulesCommitMessagePatternOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesCommitMessagePatternArgs) ToOrganizationRulesetRulesCommitMessagePatternOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitMessagePatternOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesCommitMessagePatternOutput) +} + +func (i OrganizationRulesetRulesCommitMessagePatternArgs) ToOrganizationRulesetRulesCommitMessagePatternPtrOutput() OrganizationRulesetRulesCommitMessagePatternPtrOutput { + return i.ToOrganizationRulesetRulesCommitMessagePatternPtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesCommitMessagePatternArgs) ToOrganizationRulesetRulesCommitMessagePatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitMessagePatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesCommitMessagePatternOutput).ToOrganizationRulesetRulesCommitMessagePatternPtrOutputWithContext(ctx) +} + +// OrganizationRulesetRulesCommitMessagePatternPtrInput is an input type that accepts OrganizationRulesetRulesCommitMessagePatternArgs, OrganizationRulesetRulesCommitMessagePatternPtr and OrganizationRulesetRulesCommitMessagePatternPtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesCommitMessagePatternPtrInput` via: +// +// OrganizationRulesetRulesCommitMessagePatternArgs{...} +// +// or: +// +// nil +type OrganizationRulesetRulesCommitMessagePatternPtrInput interface { + pulumi.Input + + ToOrganizationRulesetRulesCommitMessagePatternPtrOutput() OrganizationRulesetRulesCommitMessagePatternPtrOutput + ToOrganizationRulesetRulesCommitMessagePatternPtrOutputWithContext(context.Context) OrganizationRulesetRulesCommitMessagePatternPtrOutput +} + +type organizationRulesetRulesCommitMessagePatternPtrType OrganizationRulesetRulesCommitMessagePatternArgs + +func OrganizationRulesetRulesCommitMessagePatternPtr(v *OrganizationRulesetRulesCommitMessagePatternArgs) OrganizationRulesetRulesCommitMessagePatternPtrInput { + return (*organizationRulesetRulesCommitMessagePatternPtrType)(v) +} + +func (*organizationRulesetRulesCommitMessagePatternPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesCommitMessagePattern)(nil)).Elem() +} + +func (i *organizationRulesetRulesCommitMessagePatternPtrType) ToOrganizationRulesetRulesCommitMessagePatternPtrOutput() OrganizationRulesetRulesCommitMessagePatternPtrOutput { + return i.ToOrganizationRulesetRulesCommitMessagePatternPtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetRulesCommitMessagePatternPtrType) ToOrganizationRulesetRulesCommitMessagePatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitMessagePatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesCommitMessagePatternPtrOutput) +} + +type OrganizationRulesetRulesCommitMessagePatternOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesCommitMessagePatternOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesCommitMessagePattern)(nil)).Elem() +} + +func (o OrganizationRulesetRulesCommitMessagePatternOutput) ToOrganizationRulesetRulesCommitMessagePatternOutput() OrganizationRulesetRulesCommitMessagePatternOutput { + return o +} + +func (o OrganizationRulesetRulesCommitMessagePatternOutput) ToOrganizationRulesetRulesCommitMessagePatternOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitMessagePatternOutput { + return o +} + +func (o OrganizationRulesetRulesCommitMessagePatternOutput) ToOrganizationRulesetRulesCommitMessagePatternPtrOutput() OrganizationRulesetRulesCommitMessagePatternPtrOutput { + return o.ToOrganizationRulesetRulesCommitMessagePatternPtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetRulesCommitMessagePatternOutput) ToOrganizationRulesetRulesCommitMessagePatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitMessagePatternPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetRulesCommitMessagePattern) *OrganizationRulesetRulesCommitMessagePattern { + return &v + }).(OrganizationRulesetRulesCommitMessagePatternPtrOutput) +} + +// (String) The name of the ruleset. +func (o OrganizationRulesetRulesCommitMessagePatternOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesCommitMessagePattern) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o OrganizationRulesetRulesCommitMessagePatternOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesCommitMessagePattern) *bool { return v.Negate }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o OrganizationRulesetRulesCommitMessagePatternOutput) Operator() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetRulesCommitMessagePattern) string { return v.Operator }).(pulumi.StringOutput) +} + +// The pattern to match with. +func (o OrganizationRulesetRulesCommitMessagePatternOutput) Pattern() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetRulesCommitMessagePattern) string { return v.Pattern }).(pulumi.StringOutput) +} + +type OrganizationRulesetRulesCommitMessagePatternPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesCommitMessagePatternPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesCommitMessagePattern)(nil)).Elem() +} + +func (o OrganizationRulesetRulesCommitMessagePatternPtrOutput) ToOrganizationRulesetRulesCommitMessagePatternPtrOutput() OrganizationRulesetRulesCommitMessagePatternPtrOutput { + return o +} + +func (o OrganizationRulesetRulesCommitMessagePatternPtrOutput) ToOrganizationRulesetRulesCommitMessagePatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitMessagePatternPtrOutput { + return o +} + +func (o OrganizationRulesetRulesCommitMessagePatternPtrOutput) Elem() OrganizationRulesetRulesCommitMessagePatternOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCommitMessagePattern) OrganizationRulesetRulesCommitMessagePattern { + if v != nil { + return *v + } + var ret OrganizationRulesetRulesCommitMessagePattern + return ret + }).(OrganizationRulesetRulesCommitMessagePatternOutput) +} + +// (String) The name of the ruleset. +func (o OrganizationRulesetRulesCommitMessagePatternPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCommitMessagePattern) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o OrganizationRulesetRulesCommitMessagePatternPtrOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCommitMessagePattern) *bool { + if v == nil { + return nil + } + return v.Negate + }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o OrganizationRulesetRulesCommitMessagePatternPtrOutput) Operator() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCommitMessagePattern) *string { + if v == nil { + return nil + } + return &v.Operator + }).(pulumi.StringPtrOutput) +} + +// The pattern to match with. +func (o OrganizationRulesetRulesCommitMessagePatternPtrOutput) Pattern() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCommitMessagePattern) *string { + if v == nil { + return nil + } + return &v.Pattern + }).(pulumi.StringPtrOutput) +} + +type OrganizationRulesetRulesCommitterEmailPattern struct { + // (String) The name of the ruleset. + Name *string `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate *bool `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator string `pulumi:"operator"` + // The pattern to match with. + Pattern string `pulumi:"pattern"` +} + +// OrganizationRulesetRulesCommitterEmailPatternInput is an input type that accepts OrganizationRulesetRulesCommitterEmailPatternArgs and OrganizationRulesetRulesCommitterEmailPatternOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesCommitterEmailPatternInput` via: +// +// OrganizationRulesetRulesCommitterEmailPatternArgs{...} +type OrganizationRulesetRulesCommitterEmailPatternInput interface { + pulumi.Input + + ToOrganizationRulesetRulesCommitterEmailPatternOutput() OrganizationRulesetRulesCommitterEmailPatternOutput + ToOrganizationRulesetRulesCommitterEmailPatternOutputWithContext(context.Context) OrganizationRulesetRulesCommitterEmailPatternOutput +} + +type OrganizationRulesetRulesCommitterEmailPatternArgs struct { + // (String) The name of the ruleset. + Name pulumi.StringPtrInput `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate pulumi.BoolPtrInput `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator pulumi.StringInput `pulumi:"operator"` + // The pattern to match with. + Pattern pulumi.StringInput `pulumi:"pattern"` +} + +func (OrganizationRulesetRulesCommitterEmailPatternArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesCommitterEmailPattern)(nil)).Elem() +} + +func (i OrganizationRulesetRulesCommitterEmailPatternArgs) ToOrganizationRulesetRulesCommitterEmailPatternOutput() OrganizationRulesetRulesCommitterEmailPatternOutput { + return i.ToOrganizationRulesetRulesCommitterEmailPatternOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesCommitterEmailPatternArgs) ToOrganizationRulesetRulesCommitterEmailPatternOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitterEmailPatternOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesCommitterEmailPatternOutput) +} + +func (i OrganizationRulesetRulesCommitterEmailPatternArgs) ToOrganizationRulesetRulesCommitterEmailPatternPtrOutput() OrganizationRulesetRulesCommitterEmailPatternPtrOutput { + return i.ToOrganizationRulesetRulesCommitterEmailPatternPtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesCommitterEmailPatternArgs) ToOrganizationRulesetRulesCommitterEmailPatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitterEmailPatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesCommitterEmailPatternOutput).ToOrganizationRulesetRulesCommitterEmailPatternPtrOutputWithContext(ctx) +} + +// OrganizationRulesetRulesCommitterEmailPatternPtrInput is an input type that accepts OrganizationRulesetRulesCommitterEmailPatternArgs, OrganizationRulesetRulesCommitterEmailPatternPtr and OrganizationRulesetRulesCommitterEmailPatternPtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesCommitterEmailPatternPtrInput` via: +// +// OrganizationRulesetRulesCommitterEmailPatternArgs{...} +// +// or: +// +// nil +type OrganizationRulesetRulesCommitterEmailPatternPtrInput interface { + pulumi.Input + + ToOrganizationRulesetRulesCommitterEmailPatternPtrOutput() OrganizationRulesetRulesCommitterEmailPatternPtrOutput + ToOrganizationRulesetRulesCommitterEmailPatternPtrOutputWithContext(context.Context) OrganizationRulesetRulesCommitterEmailPatternPtrOutput +} + +type organizationRulesetRulesCommitterEmailPatternPtrType OrganizationRulesetRulesCommitterEmailPatternArgs + +func OrganizationRulesetRulesCommitterEmailPatternPtr(v *OrganizationRulesetRulesCommitterEmailPatternArgs) OrganizationRulesetRulesCommitterEmailPatternPtrInput { + return (*organizationRulesetRulesCommitterEmailPatternPtrType)(v) +} + +func (*organizationRulesetRulesCommitterEmailPatternPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesCommitterEmailPattern)(nil)).Elem() +} + +func (i *organizationRulesetRulesCommitterEmailPatternPtrType) ToOrganizationRulesetRulesCommitterEmailPatternPtrOutput() OrganizationRulesetRulesCommitterEmailPatternPtrOutput { + return i.ToOrganizationRulesetRulesCommitterEmailPatternPtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetRulesCommitterEmailPatternPtrType) ToOrganizationRulesetRulesCommitterEmailPatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitterEmailPatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesCommitterEmailPatternPtrOutput) +} + +type OrganizationRulesetRulesCommitterEmailPatternOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesCommitterEmailPatternOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesCommitterEmailPattern)(nil)).Elem() +} + +func (o OrganizationRulesetRulesCommitterEmailPatternOutput) ToOrganizationRulesetRulesCommitterEmailPatternOutput() OrganizationRulesetRulesCommitterEmailPatternOutput { + return o +} + +func (o OrganizationRulesetRulesCommitterEmailPatternOutput) ToOrganizationRulesetRulesCommitterEmailPatternOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitterEmailPatternOutput { + return o +} + +func (o OrganizationRulesetRulesCommitterEmailPatternOutput) ToOrganizationRulesetRulesCommitterEmailPatternPtrOutput() OrganizationRulesetRulesCommitterEmailPatternPtrOutput { + return o.ToOrganizationRulesetRulesCommitterEmailPatternPtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetRulesCommitterEmailPatternOutput) ToOrganizationRulesetRulesCommitterEmailPatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitterEmailPatternPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetRulesCommitterEmailPattern) *OrganizationRulesetRulesCommitterEmailPattern { + return &v + }).(OrganizationRulesetRulesCommitterEmailPatternPtrOutput) +} + +// (String) The name of the ruleset. +func (o OrganizationRulesetRulesCommitterEmailPatternOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesCommitterEmailPattern) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o OrganizationRulesetRulesCommitterEmailPatternOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesCommitterEmailPattern) *bool { return v.Negate }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o OrganizationRulesetRulesCommitterEmailPatternOutput) Operator() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetRulesCommitterEmailPattern) string { return v.Operator }).(pulumi.StringOutput) +} + +// The pattern to match with. +func (o OrganizationRulesetRulesCommitterEmailPatternOutput) Pattern() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetRulesCommitterEmailPattern) string { return v.Pattern }).(pulumi.StringOutput) +} + +type OrganizationRulesetRulesCommitterEmailPatternPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesCommitterEmailPatternPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesCommitterEmailPattern)(nil)).Elem() +} + +func (o OrganizationRulesetRulesCommitterEmailPatternPtrOutput) ToOrganizationRulesetRulesCommitterEmailPatternPtrOutput() OrganizationRulesetRulesCommitterEmailPatternPtrOutput { + return o +} + +func (o OrganizationRulesetRulesCommitterEmailPatternPtrOutput) ToOrganizationRulesetRulesCommitterEmailPatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesCommitterEmailPatternPtrOutput { + return o +} + +func (o OrganizationRulesetRulesCommitterEmailPatternPtrOutput) Elem() OrganizationRulesetRulesCommitterEmailPatternOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCommitterEmailPattern) OrganizationRulesetRulesCommitterEmailPattern { + if v != nil { + return *v + } + var ret OrganizationRulesetRulesCommitterEmailPattern + return ret + }).(OrganizationRulesetRulesCommitterEmailPatternOutput) +} + +// (String) The name of the ruleset. +func (o OrganizationRulesetRulesCommitterEmailPatternPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCommitterEmailPattern) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o OrganizationRulesetRulesCommitterEmailPatternPtrOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCommitterEmailPattern) *bool { + if v == nil { + return nil + } + return v.Negate + }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o OrganizationRulesetRulesCommitterEmailPatternPtrOutput) Operator() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCommitterEmailPattern) *string { + if v == nil { + return nil + } + return &v.Operator + }).(pulumi.StringPtrOutput) +} + +// The pattern to match with. +func (o OrganizationRulesetRulesCommitterEmailPatternPtrOutput) Pattern() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCommitterEmailPattern) *string { + if v == nil { + return nil + } + return &v.Pattern + }).(pulumi.StringPtrOutput) +} + +type OrganizationRulesetRulesCopilotCodeReview struct { + // Copilot automatically reviews draft pull requests before they are marked as ready for review. Defaults to `false`. + ReviewDraftPullRequests *bool `pulumi:"reviewDraftPullRequests"` + // Copilot automatically reviews each new push to the pull request. Defaults to `false`. + ReviewOnPush *bool `pulumi:"reviewOnPush"` +} + +// OrganizationRulesetRulesCopilotCodeReviewInput is an input type that accepts OrganizationRulesetRulesCopilotCodeReviewArgs and OrganizationRulesetRulesCopilotCodeReviewOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesCopilotCodeReviewInput` via: +// +// OrganizationRulesetRulesCopilotCodeReviewArgs{...} +type OrganizationRulesetRulesCopilotCodeReviewInput interface { + pulumi.Input + + ToOrganizationRulesetRulesCopilotCodeReviewOutput() OrganizationRulesetRulesCopilotCodeReviewOutput + ToOrganizationRulesetRulesCopilotCodeReviewOutputWithContext(context.Context) OrganizationRulesetRulesCopilotCodeReviewOutput +} + +type OrganizationRulesetRulesCopilotCodeReviewArgs struct { + // Copilot automatically reviews draft pull requests before they are marked as ready for review. Defaults to `false`. + ReviewDraftPullRequests pulumi.BoolPtrInput `pulumi:"reviewDraftPullRequests"` + // Copilot automatically reviews each new push to the pull request. Defaults to `false`. + ReviewOnPush pulumi.BoolPtrInput `pulumi:"reviewOnPush"` +} + +func (OrganizationRulesetRulesCopilotCodeReviewArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesCopilotCodeReview)(nil)).Elem() +} + +func (i OrganizationRulesetRulesCopilotCodeReviewArgs) ToOrganizationRulesetRulesCopilotCodeReviewOutput() OrganizationRulesetRulesCopilotCodeReviewOutput { + return i.ToOrganizationRulesetRulesCopilotCodeReviewOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesCopilotCodeReviewArgs) ToOrganizationRulesetRulesCopilotCodeReviewOutputWithContext(ctx context.Context) OrganizationRulesetRulesCopilotCodeReviewOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesCopilotCodeReviewOutput) +} + +func (i OrganizationRulesetRulesCopilotCodeReviewArgs) ToOrganizationRulesetRulesCopilotCodeReviewPtrOutput() OrganizationRulesetRulesCopilotCodeReviewPtrOutput { + return i.ToOrganizationRulesetRulesCopilotCodeReviewPtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesCopilotCodeReviewArgs) ToOrganizationRulesetRulesCopilotCodeReviewPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesCopilotCodeReviewPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesCopilotCodeReviewOutput).ToOrganizationRulesetRulesCopilotCodeReviewPtrOutputWithContext(ctx) +} + +// OrganizationRulesetRulesCopilotCodeReviewPtrInput is an input type that accepts OrganizationRulesetRulesCopilotCodeReviewArgs, OrganizationRulesetRulesCopilotCodeReviewPtr and OrganizationRulesetRulesCopilotCodeReviewPtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesCopilotCodeReviewPtrInput` via: +// +// OrganizationRulesetRulesCopilotCodeReviewArgs{...} +// +// or: +// +// nil +type OrganizationRulesetRulesCopilotCodeReviewPtrInput interface { + pulumi.Input + + ToOrganizationRulesetRulesCopilotCodeReviewPtrOutput() OrganizationRulesetRulesCopilotCodeReviewPtrOutput + ToOrganizationRulesetRulesCopilotCodeReviewPtrOutputWithContext(context.Context) OrganizationRulesetRulesCopilotCodeReviewPtrOutput +} + +type organizationRulesetRulesCopilotCodeReviewPtrType OrganizationRulesetRulesCopilotCodeReviewArgs + +func OrganizationRulesetRulesCopilotCodeReviewPtr(v *OrganizationRulesetRulesCopilotCodeReviewArgs) OrganizationRulesetRulesCopilotCodeReviewPtrInput { + return (*organizationRulesetRulesCopilotCodeReviewPtrType)(v) +} + +func (*organizationRulesetRulesCopilotCodeReviewPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesCopilotCodeReview)(nil)).Elem() +} + +func (i *organizationRulesetRulesCopilotCodeReviewPtrType) ToOrganizationRulesetRulesCopilotCodeReviewPtrOutput() OrganizationRulesetRulesCopilotCodeReviewPtrOutput { + return i.ToOrganizationRulesetRulesCopilotCodeReviewPtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetRulesCopilotCodeReviewPtrType) ToOrganizationRulesetRulesCopilotCodeReviewPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesCopilotCodeReviewPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesCopilotCodeReviewPtrOutput) +} + +type OrganizationRulesetRulesCopilotCodeReviewOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesCopilotCodeReviewOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesCopilotCodeReview)(nil)).Elem() +} + +func (o OrganizationRulesetRulesCopilotCodeReviewOutput) ToOrganizationRulesetRulesCopilotCodeReviewOutput() OrganizationRulesetRulesCopilotCodeReviewOutput { + return o +} + +func (o OrganizationRulesetRulesCopilotCodeReviewOutput) ToOrganizationRulesetRulesCopilotCodeReviewOutputWithContext(ctx context.Context) OrganizationRulesetRulesCopilotCodeReviewOutput { + return o +} + +func (o OrganizationRulesetRulesCopilotCodeReviewOutput) ToOrganizationRulesetRulesCopilotCodeReviewPtrOutput() OrganizationRulesetRulesCopilotCodeReviewPtrOutput { + return o.ToOrganizationRulesetRulesCopilotCodeReviewPtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetRulesCopilotCodeReviewOutput) ToOrganizationRulesetRulesCopilotCodeReviewPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesCopilotCodeReviewPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetRulesCopilotCodeReview) *OrganizationRulesetRulesCopilotCodeReview { + return &v + }).(OrganizationRulesetRulesCopilotCodeReviewPtrOutput) +} + +// Copilot automatically reviews draft pull requests before they are marked as ready for review. Defaults to `false`. +func (o OrganizationRulesetRulesCopilotCodeReviewOutput) ReviewDraftPullRequests() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesCopilotCodeReview) *bool { return v.ReviewDraftPullRequests }).(pulumi.BoolPtrOutput) +} + +// Copilot automatically reviews each new push to the pull request. Defaults to `false`. +func (o OrganizationRulesetRulesCopilotCodeReviewOutput) ReviewOnPush() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesCopilotCodeReview) *bool { return v.ReviewOnPush }).(pulumi.BoolPtrOutput) +} + +type OrganizationRulesetRulesCopilotCodeReviewPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesCopilotCodeReviewPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesCopilotCodeReview)(nil)).Elem() +} + +func (o OrganizationRulesetRulesCopilotCodeReviewPtrOutput) ToOrganizationRulesetRulesCopilotCodeReviewPtrOutput() OrganizationRulesetRulesCopilotCodeReviewPtrOutput { + return o +} + +func (o OrganizationRulesetRulesCopilotCodeReviewPtrOutput) ToOrganizationRulesetRulesCopilotCodeReviewPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesCopilotCodeReviewPtrOutput { + return o +} + +func (o OrganizationRulesetRulesCopilotCodeReviewPtrOutput) Elem() OrganizationRulesetRulesCopilotCodeReviewOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCopilotCodeReview) OrganizationRulesetRulesCopilotCodeReview { + if v != nil { + return *v + } + var ret OrganizationRulesetRulesCopilotCodeReview + return ret + }).(OrganizationRulesetRulesCopilotCodeReviewOutput) +} + +// Copilot automatically reviews draft pull requests before they are marked as ready for review. Defaults to `false`. +func (o OrganizationRulesetRulesCopilotCodeReviewPtrOutput) ReviewDraftPullRequests() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCopilotCodeReview) *bool { + if v == nil { + return nil + } + return v.ReviewDraftPullRequests + }).(pulumi.BoolPtrOutput) +} + +// Copilot automatically reviews each new push to the pull request. Defaults to `false`. +func (o OrganizationRulesetRulesCopilotCodeReviewPtrOutput) ReviewOnPush() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesCopilotCodeReview) *bool { + if v == nil { + return nil + } + return v.ReviewOnPush + }).(pulumi.BoolPtrOutput) +} + +type OrganizationRulesetRulesFileExtensionRestriction struct { + // The file extensions that are restricted from being pushed to the commit graph. + RestrictedFileExtensions []string `pulumi:"restrictedFileExtensions"` +} + +// OrganizationRulesetRulesFileExtensionRestrictionInput is an input type that accepts OrganizationRulesetRulesFileExtensionRestrictionArgs and OrganizationRulesetRulesFileExtensionRestrictionOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesFileExtensionRestrictionInput` via: +// +// OrganizationRulesetRulesFileExtensionRestrictionArgs{...} +type OrganizationRulesetRulesFileExtensionRestrictionInput interface { + pulumi.Input + + ToOrganizationRulesetRulesFileExtensionRestrictionOutput() OrganizationRulesetRulesFileExtensionRestrictionOutput + ToOrganizationRulesetRulesFileExtensionRestrictionOutputWithContext(context.Context) OrganizationRulesetRulesFileExtensionRestrictionOutput +} + +type OrganizationRulesetRulesFileExtensionRestrictionArgs struct { + // The file extensions that are restricted from being pushed to the commit graph. + RestrictedFileExtensions pulumi.StringArrayInput `pulumi:"restrictedFileExtensions"` +} + +func (OrganizationRulesetRulesFileExtensionRestrictionArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesFileExtensionRestriction)(nil)).Elem() +} + +func (i OrganizationRulesetRulesFileExtensionRestrictionArgs) ToOrganizationRulesetRulesFileExtensionRestrictionOutput() OrganizationRulesetRulesFileExtensionRestrictionOutput { + return i.ToOrganizationRulesetRulesFileExtensionRestrictionOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesFileExtensionRestrictionArgs) ToOrganizationRulesetRulesFileExtensionRestrictionOutputWithContext(ctx context.Context) OrganizationRulesetRulesFileExtensionRestrictionOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesFileExtensionRestrictionOutput) +} + +func (i OrganizationRulesetRulesFileExtensionRestrictionArgs) ToOrganizationRulesetRulesFileExtensionRestrictionPtrOutput() OrganizationRulesetRulesFileExtensionRestrictionPtrOutput { + return i.ToOrganizationRulesetRulesFileExtensionRestrictionPtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesFileExtensionRestrictionArgs) ToOrganizationRulesetRulesFileExtensionRestrictionPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesFileExtensionRestrictionPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesFileExtensionRestrictionOutput).ToOrganizationRulesetRulesFileExtensionRestrictionPtrOutputWithContext(ctx) +} + +// OrganizationRulesetRulesFileExtensionRestrictionPtrInput is an input type that accepts OrganizationRulesetRulesFileExtensionRestrictionArgs, OrganizationRulesetRulesFileExtensionRestrictionPtr and OrganizationRulesetRulesFileExtensionRestrictionPtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesFileExtensionRestrictionPtrInput` via: +// +// OrganizationRulesetRulesFileExtensionRestrictionArgs{...} +// +// or: +// +// nil +type OrganizationRulesetRulesFileExtensionRestrictionPtrInput interface { + pulumi.Input + + ToOrganizationRulesetRulesFileExtensionRestrictionPtrOutput() OrganizationRulesetRulesFileExtensionRestrictionPtrOutput + ToOrganizationRulesetRulesFileExtensionRestrictionPtrOutputWithContext(context.Context) OrganizationRulesetRulesFileExtensionRestrictionPtrOutput +} + +type organizationRulesetRulesFileExtensionRestrictionPtrType OrganizationRulesetRulesFileExtensionRestrictionArgs + +func OrganizationRulesetRulesFileExtensionRestrictionPtr(v *OrganizationRulesetRulesFileExtensionRestrictionArgs) OrganizationRulesetRulesFileExtensionRestrictionPtrInput { + return (*organizationRulesetRulesFileExtensionRestrictionPtrType)(v) +} + +func (*organizationRulesetRulesFileExtensionRestrictionPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesFileExtensionRestriction)(nil)).Elem() +} + +func (i *organizationRulesetRulesFileExtensionRestrictionPtrType) ToOrganizationRulesetRulesFileExtensionRestrictionPtrOutput() OrganizationRulesetRulesFileExtensionRestrictionPtrOutput { + return i.ToOrganizationRulesetRulesFileExtensionRestrictionPtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetRulesFileExtensionRestrictionPtrType) ToOrganizationRulesetRulesFileExtensionRestrictionPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesFileExtensionRestrictionPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesFileExtensionRestrictionPtrOutput) +} + +type OrganizationRulesetRulesFileExtensionRestrictionOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesFileExtensionRestrictionOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesFileExtensionRestriction)(nil)).Elem() +} + +func (o OrganizationRulesetRulesFileExtensionRestrictionOutput) ToOrganizationRulesetRulesFileExtensionRestrictionOutput() OrganizationRulesetRulesFileExtensionRestrictionOutput { + return o +} + +func (o OrganizationRulesetRulesFileExtensionRestrictionOutput) ToOrganizationRulesetRulesFileExtensionRestrictionOutputWithContext(ctx context.Context) OrganizationRulesetRulesFileExtensionRestrictionOutput { + return o +} + +func (o OrganizationRulesetRulesFileExtensionRestrictionOutput) ToOrganizationRulesetRulesFileExtensionRestrictionPtrOutput() OrganizationRulesetRulesFileExtensionRestrictionPtrOutput { + return o.ToOrganizationRulesetRulesFileExtensionRestrictionPtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetRulesFileExtensionRestrictionOutput) ToOrganizationRulesetRulesFileExtensionRestrictionPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesFileExtensionRestrictionPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetRulesFileExtensionRestriction) *OrganizationRulesetRulesFileExtensionRestriction { + return &v + }).(OrganizationRulesetRulesFileExtensionRestrictionPtrOutput) +} + +// The file extensions that are restricted from being pushed to the commit graph. +func (o OrganizationRulesetRulesFileExtensionRestrictionOutput) RestrictedFileExtensions() pulumi.StringArrayOutput { + return o.ApplyT(func(v OrganizationRulesetRulesFileExtensionRestriction) []string { return v.RestrictedFileExtensions }).(pulumi.StringArrayOutput) +} + +type OrganizationRulesetRulesFileExtensionRestrictionPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesFileExtensionRestrictionPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesFileExtensionRestriction)(nil)).Elem() +} + +func (o OrganizationRulesetRulesFileExtensionRestrictionPtrOutput) ToOrganizationRulesetRulesFileExtensionRestrictionPtrOutput() OrganizationRulesetRulesFileExtensionRestrictionPtrOutput { + return o +} + +func (o OrganizationRulesetRulesFileExtensionRestrictionPtrOutput) ToOrganizationRulesetRulesFileExtensionRestrictionPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesFileExtensionRestrictionPtrOutput { + return o +} + +func (o OrganizationRulesetRulesFileExtensionRestrictionPtrOutput) Elem() OrganizationRulesetRulesFileExtensionRestrictionOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesFileExtensionRestriction) OrganizationRulesetRulesFileExtensionRestriction { + if v != nil { + return *v + } + var ret OrganizationRulesetRulesFileExtensionRestriction + return ret + }).(OrganizationRulesetRulesFileExtensionRestrictionOutput) +} + +// The file extensions that are restricted from being pushed to the commit graph. +func (o OrganizationRulesetRulesFileExtensionRestrictionPtrOutput) RestrictedFileExtensions() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesFileExtensionRestriction) []string { + if v == nil { + return nil + } + return v.RestrictedFileExtensions + }).(pulumi.StringArrayOutput) +} + +type OrganizationRulesetRulesFilePathRestriction struct { + // The file paths that are restricted from being pushed to the commit graph. + RestrictedFilePaths []string `pulumi:"restrictedFilePaths"` +} + +// OrganizationRulesetRulesFilePathRestrictionInput is an input type that accepts OrganizationRulesetRulesFilePathRestrictionArgs and OrganizationRulesetRulesFilePathRestrictionOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesFilePathRestrictionInput` via: +// +// OrganizationRulesetRulesFilePathRestrictionArgs{...} +type OrganizationRulesetRulesFilePathRestrictionInput interface { + pulumi.Input + + ToOrganizationRulesetRulesFilePathRestrictionOutput() OrganizationRulesetRulesFilePathRestrictionOutput + ToOrganizationRulesetRulesFilePathRestrictionOutputWithContext(context.Context) OrganizationRulesetRulesFilePathRestrictionOutput +} + +type OrganizationRulesetRulesFilePathRestrictionArgs struct { + // The file paths that are restricted from being pushed to the commit graph. + RestrictedFilePaths pulumi.StringArrayInput `pulumi:"restrictedFilePaths"` +} + +func (OrganizationRulesetRulesFilePathRestrictionArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesFilePathRestriction)(nil)).Elem() +} + +func (i OrganizationRulesetRulesFilePathRestrictionArgs) ToOrganizationRulesetRulesFilePathRestrictionOutput() OrganizationRulesetRulesFilePathRestrictionOutput { + return i.ToOrganizationRulesetRulesFilePathRestrictionOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesFilePathRestrictionArgs) ToOrganizationRulesetRulesFilePathRestrictionOutputWithContext(ctx context.Context) OrganizationRulesetRulesFilePathRestrictionOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesFilePathRestrictionOutput) +} + +func (i OrganizationRulesetRulesFilePathRestrictionArgs) ToOrganizationRulesetRulesFilePathRestrictionPtrOutput() OrganizationRulesetRulesFilePathRestrictionPtrOutput { + return i.ToOrganizationRulesetRulesFilePathRestrictionPtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesFilePathRestrictionArgs) ToOrganizationRulesetRulesFilePathRestrictionPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesFilePathRestrictionPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesFilePathRestrictionOutput).ToOrganizationRulesetRulesFilePathRestrictionPtrOutputWithContext(ctx) +} + +// OrganizationRulesetRulesFilePathRestrictionPtrInput is an input type that accepts OrganizationRulesetRulesFilePathRestrictionArgs, OrganizationRulesetRulesFilePathRestrictionPtr and OrganizationRulesetRulesFilePathRestrictionPtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesFilePathRestrictionPtrInput` via: +// +// OrganizationRulesetRulesFilePathRestrictionArgs{...} +// +// or: +// +// nil +type OrganizationRulesetRulesFilePathRestrictionPtrInput interface { + pulumi.Input + + ToOrganizationRulesetRulesFilePathRestrictionPtrOutput() OrganizationRulesetRulesFilePathRestrictionPtrOutput + ToOrganizationRulesetRulesFilePathRestrictionPtrOutputWithContext(context.Context) OrganizationRulesetRulesFilePathRestrictionPtrOutput +} + +type organizationRulesetRulesFilePathRestrictionPtrType OrganizationRulesetRulesFilePathRestrictionArgs + +func OrganizationRulesetRulesFilePathRestrictionPtr(v *OrganizationRulesetRulesFilePathRestrictionArgs) OrganizationRulesetRulesFilePathRestrictionPtrInput { + return (*organizationRulesetRulesFilePathRestrictionPtrType)(v) +} + +func (*organizationRulesetRulesFilePathRestrictionPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesFilePathRestriction)(nil)).Elem() +} + +func (i *organizationRulesetRulesFilePathRestrictionPtrType) ToOrganizationRulesetRulesFilePathRestrictionPtrOutput() OrganizationRulesetRulesFilePathRestrictionPtrOutput { + return i.ToOrganizationRulesetRulesFilePathRestrictionPtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetRulesFilePathRestrictionPtrType) ToOrganizationRulesetRulesFilePathRestrictionPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesFilePathRestrictionPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesFilePathRestrictionPtrOutput) +} + +type OrganizationRulesetRulesFilePathRestrictionOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesFilePathRestrictionOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesFilePathRestriction)(nil)).Elem() +} + +func (o OrganizationRulesetRulesFilePathRestrictionOutput) ToOrganizationRulesetRulesFilePathRestrictionOutput() OrganizationRulesetRulesFilePathRestrictionOutput { + return o +} + +func (o OrganizationRulesetRulesFilePathRestrictionOutput) ToOrganizationRulesetRulesFilePathRestrictionOutputWithContext(ctx context.Context) OrganizationRulesetRulesFilePathRestrictionOutput { + return o +} + +func (o OrganizationRulesetRulesFilePathRestrictionOutput) ToOrganizationRulesetRulesFilePathRestrictionPtrOutput() OrganizationRulesetRulesFilePathRestrictionPtrOutput { + return o.ToOrganizationRulesetRulesFilePathRestrictionPtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetRulesFilePathRestrictionOutput) ToOrganizationRulesetRulesFilePathRestrictionPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesFilePathRestrictionPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetRulesFilePathRestriction) *OrganizationRulesetRulesFilePathRestriction { + return &v + }).(OrganizationRulesetRulesFilePathRestrictionPtrOutput) +} + +// The file paths that are restricted from being pushed to the commit graph. +func (o OrganizationRulesetRulesFilePathRestrictionOutput) RestrictedFilePaths() pulumi.StringArrayOutput { + return o.ApplyT(func(v OrganizationRulesetRulesFilePathRestriction) []string { return v.RestrictedFilePaths }).(pulumi.StringArrayOutput) +} + +type OrganizationRulesetRulesFilePathRestrictionPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesFilePathRestrictionPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesFilePathRestriction)(nil)).Elem() +} + +func (o OrganizationRulesetRulesFilePathRestrictionPtrOutput) ToOrganizationRulesetRulesFilePathRestrictionPtrOutput() OrganizationRulesetRulesFilePathRestrictionPtrOutput { + return o +} + +func (o OrganizationRulesetRulesFilePathRestrictionPtrOutput) ToOrganizationRulesetRulesFilePathRestrictionPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesFilePathRestrictionPtrOutput { + return o +} + +func (o OrganizationRulesetRulesFilePathRestrictionPtrOutput) Elem() OrganizationRulesetRulesFilePathRestrictionOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesFilePathRestriction) OrganizationRulesetRulesFilePathRestriction { + if v != nil { + return *v + } + var ret OrganizationRulesetRulesFilePathRestriction + return ret + }).(OrganizationRulesetRulesFilePathRestrictionOutput) +} + +// The file paths that are restricted from being pushed to the commit graph. +func (o OrganizationRulesetRulesFilePathRestrictionPtrOutput) RestrictedFilePaths() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesFilePathRestriction) []string { + if v == nil { + return nil + } + return v.RestrictedFilePaths + }).(pulumi.StringArrayOutput) +} + +type OrganizationRulesetRulesMaxFilePathLength struct { + // The maximum allowed length of a file path. + MaxFilePathLength int `pulumi:"maxFilePathLength"` +} + +// OrganizationRulesetRulesMaxFilePathLengthInput is an input type that accepts OrganizationRulesetRulesMaxFilePathLengthArgs and OrganizationRulesetRulesMaxFilePathLengthOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesMaxFilePathLengthInput` via: +// +// OrganizationRulesetRulesMaxFilePathLengthArgs{...} +type OrganizationRulesetRulesMaxFilePathLengthInput interface { + pulumi.Input + + ToOrganizationRulesetRulesMaxFilePathLengthOutput() OrganizationRulesetRulesMaxFilePathLengthOutput + ToOrganizationRulesetRulesMaxFilePathLengthOutputWithContext(context.Context) OrganizationRulesetRulesMaxFilePathLengthOutput +} + +type OrganizationRulesetRulesMaxFilePathLengthArgs struct { + // The maximum allowed length of a file path. + MaxFilePathLength pulumi.IntInput `pulumi:"maxFilePathLength"` +} + +func (OrganizationRulesetRulesMaxFilePathLengthArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesMaxFilePathLength)(nil)).Elem() +} + +func (i OrganizationRulesetRulesMaxFilePathLengthArgs) ToOrganizationRulesetRulesMaxFilePathLengthOutput() OrganizationRulesetRulesMaxFilePathLengthOutput { + return i.ToOrganizationRulesetRulesMaxFilePathLengthOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesMaxFilePathLengthArgs) ToOrganizationRulesetRulesMaxFilePathLengthOutputWithContext(ctx context.Context) OrganizationRulesetRulesMaxFilePathLengthOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesMaxFilePathLengthOutput) +} + +func (i OrganizationRulesetRulesMaxFilePathLengthArgs) ToOrganizationRulesetRulesMaxFilePathLengthPtrOutput() OrganizationRulesetRulesMaxFilePathLengthPtrOutput { + return i.ToOrganizationRulesetRulesMaxFilePathLengthPtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesMaxFilePathLengthArgs) ToOrganizationRulesetRulesMaxFilePathLengthPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesMaxFilePathLengthPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesMaxFilePathLengthOutput).ToOrganizationRulesetRulesMaxFilePathLengthPtrOutputWithContext(ctx) +} + +// OrganizationRulesetRulesMaxFilePathLengthPtrInput is an input type that accepts OrganizationRulesetRulesMaxFilePathLengthArgs, OrganizationRulesetRulesMaxFilePathLengthPtr and OrganizationRulesetRulesMaxFilePathLengthPtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesMaxFilePathLengthPtrInput` via: +// +// OrganizationRulesetRulesMaxFilePathLengthArgs{...} +// +// or: +// +// nil +type OrganizationRulesetRulesMaxFilePathLengthPtrInput interface { + pulumi.Input + + ToOrganizationRulesetRulesMaxFilePathLengthPtrOutput() OrganizationRulesetRulesMaxFilePathLengthPtrOutput + ToOrganizationRulesetRulesMaxFilePathLengthPtrOutputWithContext(context.Context) OrganizationRulesetRulesMaxFilePathLengthPtrOutput +} + +type organizationRulesetRulesMaxFilePathLengthPtrType OrganizationRulesetRulesMaxFilePathLengthArgs + +func OrganizationRulesetRulesMaxFilePathLengthPtr(v *OrganizationRulesetRulesMaxFilePathLengthArgs) OrganizationRulesetRulesMaxFilePathLengthPtrInput { + return (*organizationRulesetRulesMaxFilePathLengthPtrType)(v) +} + +func (*organizationRulesetRulesMaxFilePathLengthPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesMaxFilePathLength)(nil)).Elem() +} + +func (i *organizationRulesetRulesMaxFilePathLengthPtrType) ToOrganizationRulesetRulesMaxFilePathLengthPtrOutput() OrganizationRulesetRulesMaxFilePathLengthPtrOutput { + return i.ToOrganizationRulesetRulesMaxFilePathLengthPtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetRulesMaxFilePathLengthPtrType) ToOrganizationRulesetRulesMaxFilePathLengthPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesMaxFilePathLengthPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesMaxFilePathLengthPtrOutput) +} + +type OrganizationRulesetRulesMaxFilePathLengthOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesMaxFilePathLengthOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesMaxFilePathLength)(nil)).Elem() +} + +func (o OrganizationRulesetRulesMaxFilePathLengthOutput) ToOrganizationRulesetRulesMaxFilePathLengthOutput() OrganizationRulesetRulesMaxFilePathLengthOutput { + return o +} + +func (o OrganizationRulesetRulesMaxFilePathLengthOutput) ToOrganizationRulesetRulesMaxFilePathLengthOutputWithContext(ctx context.Context) OrganizationRulesetRulesMaxFilePathLengthOutput { + return o +} + +func (o OrganizationRulesetRulesMaxFilePathLengthOutput) ToOrganizationRulesetRulesMaxFilePathLengthPtrOutput() OrganizationRulesetRulesMaxFilePathLengthPtrOutput { + return o.ToOrganizationRulesetRulesMaxFilePathLengthPtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetRulesMaxFilePathLengthOutput) ToOrganizationRulesetRulesMaxFilePathLengthPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesMaxFilePathLengthPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetRulesMaxFilePathLength) *OrganizationRulesetRulesMaxFilePathLength { + return &v + }).(OrganizationRulesetRulesMaxFilePathLengthPtrOutput) +} + +// The maximum allowed length of a file path. +func (o OrganizationRulesetRulesMaxFilePathLengthOutput) MaxFilePathLength() pulumi.IntOutput { + return o.ApplyT(func(v OrganizationRulesetRulesMaxFilePathLength) int { return v.MaxFilePathLength }).(pulumi.IntOutput) +} + +type OrganizationRulesetRulesMaxFilePathLengthPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesMaxFilePathLengthPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesMaxFilePathLength)(nil)).Elem() +} + +func (o OrganizationRulesetRulesMaxFilePathLengthPtrOutput) ToOrganizationRulesetRulesMaxFilePathLengthPtrOutput() OrganizationRulesetRulesMaxFilePathLengthPtrOutput { + return o +} + +func (o OrganizationRulesetRulesMaxFilePathLengthPtrOutput) ToOrganizationRulesetRulesMaxFilePathLengthPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesMaxFilePathLengthPtrOutput { + return o +} + +func (o OrganizationRulesetRulesMaxFilePathLengthPtrOutput) Elem() OrganizationRulesetRulesMaxFilePathLengthOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesMaxFilePathLength) OrganizationRulesetRulesMaxFilePathLength { + if v != nil { + return *v + } + var ret OrganizationRulesetRulesMaxFilePathLength + return ret + }).(OrganizationRulesetRulesMaxFilePathLengthOutput) +} + +// The maximum allowed length of a file path. +func (o OrganizationRulesetRulesMaxFilePathLengthPtrOutput) MaxFilePathLength() pulumi.IntPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesMaxFilePathLength) *int { + if v == nil { + return nil + } + return &v.MaxFilePathLength + }).(pulumi.IntPtrOutput) +} + +type OrganizationRulesetRulesMaxFileSize struct { + // The maximum allowed size of a file in megabytes (MB). Valid range is 1-100 MB. + MaxFileSize int `pulumi:"maxFileSize"` +} + +// OrganizationRulesetRulesMaxFileSizeInput is an input type that accepts OrganizationRulesetRulesMaxFileSizeArgs and OrganizationRulesetRulesMaxFileSizeOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesMaxFileSizeInput` via: +// +// OrganizationRulesetRulesMaxFileSizeArgs{...} +type OrganizationRulesetRulesMaxFileSizeInput interface { + pulumi.Input + + ToOrganizationRulesetRulesMaxFileSizeOutput() OrganizationRulesetRulesMaxFileSizeOutput + ToOrganizationRulesetRulesMaxFileSizeOutputWithContext(context.Context) OrganizationRulesetRulesMaxFileSizeOutput +} + +type OrganizationRulesetRulesMaxFileSizeArgs struct { + // The maximum allowed size of a file in megabytes (MB). Valid range is 1-100 MB. + MaxFileSize pulumi.IntInput `pulumi:"maxFileSize"` +} + +func (OrganizationRulesetRulesMaxFileSizeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesMaxFileSize)(nil)).Elem() +} + +func (i OrganizationRulesetRulesMaxFileSizeArgs) ToOrganizationRulesetRulesMaxFileSizeOutput() OrganizationRulesetRulesMaxFileSizeOutput { + return i.ToOrganizationRulesetRulesMaxFileSizeOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesMaxFileSizeArgs) ToOrganizationRulesetRulesMaxFileSizeOutputWithContext(ctx context.Context) OrganizationRulesetRulesMaxFileSizeOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesMaxFileSizeOutput) +} + +func (i OrganizationRulesetRulesMaxFileSizeArgs) ToOrganizationRulesetRulesMaxFileSizePtrOutput() OrganizationRulesetRulesMaxFileSizePtrOutput { + return i.ToOrganizationRulesetRulesMaxFileSizePtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesMaxFileSizeArgs) ToOrganizationRulesetRulesMaxFileSizePtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesMaxFileSizePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesMaxFileSizeOutput).ToOrganizationRulesetRulesMaxFileSizePtrOutputWithContext(ctx) +} + +// OrganizationRulesetRulesMaxFileSizePtrInput is an input type that accepts OrganizationRulesetRulesMaxFileSizeArgs, OrganizationRulesetRulesMaxFileSizePtr and OrganizationRulesetRulesMaxFileSizePtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesMaxFileSizePtrInput` via: +// +// OrganizationRulesetRulesMaxFileSizeArgs{...} +// +// or: +// +// nil +type OrganizationRulesetRulesMaxFileSizePtrInput interface { + pulumi.Input + + ToOrganizationRulesetRulesMaxFileSizePtrOutput() OrganizationRulesetRulesMaxFileSizePtrOutput + ToOrganizationRulesetRulesMaxFileSizePtrOutputWithContext(context.Context) OrganizationRulesetRulesMaxFileSizePtrOutput +} + +type organizationRulesetRulesMaxFileSizePtrType OrganizationRulesetRulesMaxFileSizeArgs + +func OrganizationRulesetRulesMaxFileSizePtr(v *OrganizationRulesetRulesMaxFileSizeArgs) OrganizationRulesetRulesMaxFileSizePtrInput { + return (*organizationRulesetRulesMaxFileSizePtrType)(v) +} + +func (*organizationRulesetRulesMaxFileSizePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesMaxFileSize)(nil)).Elem() +} + +func (i *organizationRulesetRulesMaxFileSizePtrType) ToOrganizationRulesetRulesMaxFileSizePtrOutput() OrganizationRulesetRulesMaxFileSizePtrOutput { + return i.ToOrganizationRulesetRulesMaxFileSizePtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetRulesMaxFileSizePtrType) ToOrganizationRulesetRulesMaxFileSizePtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesMaxFileSizePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesMaxFileSizePtrOutput) +} + +type OrganizationRulesetRulesMaxFileSizeOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesMaxFileSizeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesMaxFileSize)(nil)).Elem() +} + +func (o OrganizationRulesetRulesMaxFileSizeOutput) ToOrganizationRulesetRulesMaxFileSizeOutput() OrganizationRulesetRulesMaxFileSizeOutput { + return o +} + +func (o OrganizationRulesetRulesMaxFileSizeOutput) ToOrganizationRulesetRulesMaxFileSizeOutputWithContext(ctx context.Context) OrganizationRulesetRulesMaxFileSizeOutput { + return o +} + +func (o OrganizationRulesetRulesMaxFileSizeOutput) ToOrganizationRulesetRulesMaxFileSizePtrOutput() OrganizationRulesetRulesMaxFileSizePtrOutput { + return o.ToOrganizationRulesetRulesMaxFileSizePtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetRulesMaxFileSizeOutput) ToOrganizationRulesetRulesMaxFileSizePtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesMaxFileSizePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetRulesMaxFileSize) *OrganizationRulesetRulesMaxFileSize { + return &v + }).(OrganizationRulesetRulesMaxFileSizePtrOutput) +} + +// The maximum allowed size of a file in megabytes (MB). Valid range is 1-100 MB. +func (o OrganizationRulesetRulesMaxFileSizeOutput) MaxFileSize() pulumi.IntOutput { + return o.ApplyT(func(v OrganizationRulesetRulesMaxFileSize) int { return v.MaxFileSize }).(pulumi.IntOutput) +} + +type OrganizationRulesetRulesMaxFileSizePtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesMaxFileSizePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesMaxFileSize)(nil)).Elem() +} + +func (o OrganizationRulesetRulesMaxFileSizePtrOutput) ToOrganizationRulesetRulesMaxFileSizePtrOutput() OrganizationRulesetRulesMaxFileSizePtrOutput { + return o +} + +func (o OrganizationRulesetRulesMaxFileSizePtrOutput) ToOrganizationRulesetRulesMaxFileSizePtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesMaxFileSizePtrOutput { + return o +} + +func (o OrganizationRulesetRulesMaxFileSizePtrOutput) Elem() OrganizationRulesetRulesMaxFileSizeOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesMaxFileSize) OrganizationRulesetRulesMaxFileSize { + if v != nil { + return *v + } + var ret OrganizationRulesetRulesMaxFileSize + return ret + }).(OrganizationRulesetRulesMaxFileSizeOutput) +} + +// The maximum allowed size of a file in megabytes (MB). Valid range is 1-100 MB. +func (o OrganizationRulesetRulesMaxFileSizePtrOutput) MaxFileSize() pulumi.IntPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesMaxFileSize) *int { + if v == nil { + return nil + } + return &v.MaxFileSize + }).(pulumi.IntPtrOutput) +} + +type OrganizationRulesetRulesPullRequest struct { + // Array of allowed merge methods. Allowed values include `merge`, `squash`, and `rebase`. At least one option must be enabled. + AllowedMergeMethods []string `pulumi:"allowedMergeMethods"` + // New, reviewable commits pushed will dismiss previous pull request review approvals. Defaults to `false`. + DismissStaleReviewsOnPush *bool `pulumi:"dismissStaleReviewsOnPush"` + // Require an approving review in pull requests that modify files that have a designated code owner. Defaults to `false`. + RequireCodeOwnerReview *bool `pulumi:"requireCodeOwnerReview"` + // Whether the most recent reviewable push must be approved by someone other than the person who pushed it. Defaults to `false`. + RequireLastPushApproval *bool `pulumi:"requireLastPushApproval"` + // The number of approving reviews that are required before a pull request can be merged. Defaults to `0`. + RequiredApprovingReviewCount *int `pulumi:"requiredApprovingReviewCount"` + // All conversations on code must be resolved before a pull request can be merged. Defaults to `false`. + RequiredReviewThreadResolution *bool `pulumi:"requiredReviewThreadResolution"` + // Require specific reviewers to approve pull requests targeting matching branches. Note: This feature is in beta and subject to change. + RequiredReviewers []OrganizationRulesetRulesPullRequestRequiredReviewer `pulumi:"requiredReviewers"` +} + +// OrganizationRulesetRulesPullRequestInput is an input type that accepts OrganizationRulesetRulesPullRequestArgs and OrganizationRulesetRulesPullRequestOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesPullRequestInput` via: +// +// OrganizationRulesetRulesPullRequestArgs{...} +type OrganizationRulesetRulesPullRequestInput interface { + pulumi.Input + + ToOrganizationRulesetRulesPullRequestOutput() OrganizationRulesetRulesPullRequestOutput + ToOrganizationRulesetRulesPullRequestOutputWithContext(context.Context) OrganizationRulesetRulesPullRequestOutput +} + +type OrganizationRulesetRulesPullRequestArgs struct { + // Array of allowed merge methods. Allowed values include `merge`, `squash`, and `rebase`. At least one option must be enabled. + AllowedMergeMethods pulumi.StringArrayInput `pulumi:"allowedMergeMethods"` + // New, reviewable commits pushed will dismiss previous pull request review approvals. Defaults to `false`. + DismissStaleReviewsOnPush pulumi.BoolPtrInput `pulumi:"dismissStaleReviewsOnPush"` + // Require an approving review in pull requests that modify files that have a designated code owner. Defaults to `false`. + RequireCodeOwnerReview pulumi.BoolPtrInput `pulumi:"requireCodeOwnerReview"` + // Whether the most recent reviewable push must be approved by someone other than the person who pushed it. Defaults to `false`. + RequireLastPushApproval pulumi.BoolPtrInput `pulumi:"requireLastPushApproval"` + // The number of approving reviews that are required before a pull request can be merged. Defaults to `0`. + RequiredApprovingReviewCount pulumi.IntPtrInput `pulumi:"requiredApprovingReviewCount"` + // All conversations on code must be resolved before a pull request can be merged. Defaults to `false`. + RequiredReviewThreadResolution pulumi.BoolPtrInput `pulumi:"requiredReviewThreadResolution"` + // Require specific reviewers to approve pull requests targeting matching branches. Note: This feature is in beta and subject to change. + RequiredReviewers OrganizationRulesetRulesPullRequestRequiredReviewerArrayInput `pulumi:"requiredReviewers"` +} + +func (OrganizationRulesetRulesPullRequestArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesPullRequest)(nil)).Elem() +} + +func (i OrganizationRulesetRulesPullRequestArgs) ToOrganizationRulesetRulesPullRequestOutput() OrganizationRulesetRulesPullRequestOutput { + return i.ToOrganizationRulesetRulesPullRequestOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesPullRequestArgs) ToOrganizationRulesetRulesPullRequestOutputWithContext(ctx context.Context) OrganizationRulesetRulesPullRequestOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesPullRequestOutput) +} + +func (i OrganizationRulesetRulesPullRequestArgs) ToOrganizationRulesetRulesPullRequestPtrOutput() OrganizationRulesetRulesPullRequestPtrOutput { + return i.ToOrganizationRulesetRulesPullRequestPtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesPullRequestArgs) ToOrganizationRulesetRulesPullRequestPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesPullRequestPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesPullRequestOutput).ToOrganizationRulesetRulesPullRequestPtrOutputWithContext(ctx) +} + +// OrganizationRulesetRulesPullRequestPtrInput is an input type that accepts OrganizationRulesetRulesPullRequestArgs, OrganizationRulesetRulesPullRequestPtr and OrganizationRulesetRulesPullRequestPtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesPullRequestPtrInput` via: +// +// OrganizationRulesetRulesPullRequestArgs{...} +// +// or: +// +// nil +type OrganizationRulesetRulesPullRequestPtrInput interface { + pulumi.Input + + ToOrganizationRulesetRulesPullRequestPtrOutput() OrganizationRulesetRulesPullRequestPtrOutput + ToOrganizationRulesetRulesPullRequestPtrOutputWithContext(context.Context) OrganizationRulesetRulesPullRequestPtrOutput +} + +type organizationRulesetRulesPullRequestPtrType OrganizationRulesetRulesPullRequestArgs + +func OrganizationRulesetRulesPullRequestPtr(v *OrganizationRulesetRulesPullRequestArgs) OrganizationRulesetRulesPullRequestPtrInput { + return (*organizationRulesetRulesPullRequestPtrType)(v) +} + +func (*organizationRulesetRulesPullRequestPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesPullRequest)(nil)).Elem() +} + +func (i *organizationRulesetRulesPullRequestPtrType) ToOrganizationRulesetRulesPullRequestPtrOutput() OrganizationRulesetRulesPullRequestPtrOutput { + return i.ToOrganizationRulesetRulesPullRequestPtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetRulesPullRequestPtrType) ToOrganizationRulesetRulesPullRequestPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesPullRequestPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesPullRequestPtrOutput) +} + +type OrganizationRulesetRulesPullRequestOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesPullRequestOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesPullRequest)(nil)).Elem() +} + +func (o OrganizationRulesetRulesPullRequestOutput) ToOrganizationRulesetRulesPullRequestOutput() OrganizationRulesetRulesPullRequestOutput { + return o +} + +func (o OrganizationRulesetRulesPullRequestOutput) ToOrganizationRulesetRulesPullRequestOutputWithContext(ctx context.Context) OrganizationRulesetRulesPullRequestOutput { + return o +} + +func (o OrganizationRulesetRulesPullRequestOutput) ToOrganizationRulesetRulesPullRequestPtrOutput() OrganizationRulesetRulesPullRequestPtrOutput { + return o.ToOrganizationRulesetRulesPullRequestPtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetRulesPullRequestOutput) ToOrganizationRulesetRulesPullRequestPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesPullRequestPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetRulesPullRequest) *OrganizationRulesetRulesPullRequest { + return &v + }).(OrganizationRulesetRulesPullRequestPtrOutput) +} + +// Array of allowed merge methods. Allowed values include `merge`, `squash`, and `rebase`. At least one option must be enabled. +func (o OrganizationRulesetRulesPullRequestOutput) AllowedMergeMethods() pulumi.StringArrayOutput { + return o.ApplyT(func(v OrganizationRulesetRulesPullRequest) []string { return v.AllowedMergeMethods }).(pulumi.StringArrayOutput) +} + +// New, reviewable commits pushed will dismiss previous pull request review approvals. Defaults to `false`. +func (o OrganizationRulesetRulesPullRequestOutput) DismissStaleReviewsOnPush() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesPullRequest) *bool { return v.DismissStaleReviewsOnPush }).(pulumi.BoolPtrOutput) +} + +// Require an approving review in pull requests that modify files that have a designated code owner. Defaults to `false`. +func (o OrganizationRulesetRulesPullRequestOutput) RequireCodeOwnerReview() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesPullRequest) *bool { return v.RequireCodeOwnerReview }).(pulumi.BoolPtrOutput) +} + +// Whether the most recent reviewable push must be approved by someone other than the person who pushed it. Defaults to `false`. +func (o OrganizationRulesetRulesPullRequestOutput) RequireLastPushApproval() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesPullRequest) *bool { return v.RequireLastPushApproval }).(pulumi.BoolPtrOutput) +} + +// The number of approving reviews that are required before a pull request can be merged. Defaults to `0`. +func (o OrganizationRulesetRulesPullRequestOutput) RequiredApprovingReviewCount() pulumi.IntPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesPullRequest) *int { return v.RequiredApprovingReviewCount }).(pulumi.IntPtrOutput) +} + +// All conversations on code must be resolved before a pull request can be merged. Defaults to `false`. +func (o OrganizationRulesetRulesPullRequestOutput) RequiredReviewThreadResolution() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesPullRequest) *bool { return v.RequiredReviewThreadResolution }).(pulumi.BoolPtrOutput) +} + +// Require specific reviewers to approve pull requests targeting matching branches. Note: This feature is in beta and subject to change. +func (o OrganizationRulesetRulesPullRequestOutput) RequiredReviewers() OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput { + return o.ApplyT(func(v OrganizationRulesetRulesPullRequest) []OrganizationRulesetRulesPullRequestRequiredReviewer { + return v.RequiredReviewers + }).(OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput) +} + +type OrganizationRulesetRulesPullRequestPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesPullRequestPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesPullRequest)(nil)).Elem() +} + +func (o OrganizationRulesetRulesPullRequestPtrOutput) ToOrganizationRulesetRulesPullRequestPtrOutput() OrganizationRulesetRulesPullRequestPtrOutput { + return o +} + +func (o OrganizationRulesetRulesPullRequestPtrOutput) ToOrganizationRulesetRulesPullRequestPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesPullRequestPtrOutput { + return o +} + +func (o OrganizationRulesetRulesPullRequestPtrOutput) Elem() OrganizationRulesetRulesPullRequestOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesPullRequest) OrganizationRulesetRulesPullRequest { + if v != nil { + return *v + } + var ret OrganizationRulesetRulesPullRequest + return ret + }).(OrganizationRulesetRulesPullRequestOutput) +} + +// Array of allowed merge methods. Allowed values include `merge`, `squash`, and `rebase`. At least one option must be enabled. +func (o OrganizationRulesetRulesPullRequestPtrOutput) AllowedMergeMethods() pulumi.StringArrayOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesPullRequest) []string { + if v == nil { + return nil + } + return v.AllowedMergeMethods + }).(pulumi.StringArrayOutput) +} + +// New, reviewable commits pushed will dismiss previous pull request review approvals. Defaults to `false`. +func (o OrganizationRulesetRulesPullRequestPtrOutput) DismissStaleReviewsOnPush() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesPullRequest) *bool { + if v == nil { + return nil + } + return v.DismissStaleReviewsOnPush + }).(pulumi.BoolPtrOutput) +} + +// Require an approving review in pull requests that modify files that have a designated code owner. Defaults to `false`. +func (o OrganizationRulesetRulesPullRequestPtrOutput) RequireCodeOwnerReview() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesPullRequest) *bool { + if v == nil { + return nil + } + return v.RequireCodeOwnerReview + }).(pulumi.BoolPtrOutput) +} + +// Whether the most recent reviewable push must be approved by someone other than the person who pushed it. Defaults to `false`. +func (o OrganizationRulesetRulesPullRequestPtrOutput) RequireLastPushApproval() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesPullRequest) *bool { + if v == nil { + return nil + } + return v.RequireLastPushApproval + }).(pulumi.BoolPtrOutput) +} + +// The number of approving reviews that are required before a pull request can be merged. Defaults to `0`. +func (o OrganizationRulesetRulesPullRequestPtrOutput) RequiredApprovingReviewCount() pulumi.IntPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesPullRequest) *int { + if v == nil { + return nil + } + return v.RequiredApprovingReviewCount + }).(pulumi.IntPtrOutput) +} + +// All conversations on code must be resolved before a pull request can be merged. Defaults to `false`. +func (o OrganizationRulesetRulesPullRequestPtrOutput) RequiredReviewThreadResolution() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesPullRequest) *bool { + if v == nil { + return nil + } + return v.RequiredReviewThreadResolution + }).(pulumi.BoolPtrOutput) +} + +// Require specific reviewers to approve pull requests targeting matching branches. Note: This feature is in beta and subject to change. +func (o OrganizationRulesetRulesPullRequestPtrOutput) RequiredReviewers() OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesPullRequest) []OrganizationRulesetRulesPullRequestRequiredReviewer { + if v == nil { + return nil + } + return v.RequiredReviewers + }).(OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput) +} + +type OrganizationRulesetRulesPullRequestRequiredReviewer struct { + // File patterns (fnmatch syntax) that this reviewer must approve. + FilePatterns []string `pulumi:"filePatterns"` + // Minimum number of approvals required from this reviewer. Set to 0 to make approval optional. + MinimumApprovals int `pulumi:"minimumApprovals"` + // The reviewer that must review matching files. + Reviewer OrganizationRulesetRulesPullRequestRequiredReviewerReviewer `pulumi:"reviewer"` +} + +// OrganizationRulesetRulesPullRequestRequiredReviewerInput is an input type that accepts OrganizationRulesetRulesPullRequestRequiredReviewerArgs and OrganizationRulesetRulesPullRequestRequiredReviewerOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesPullRequestRequiredReviewerInput` via: +// +// OrganizationRulesetRulesPullRequestRequiredReviewerArgs{...} +type OrganizationRulesetRulesPullRequestRequiredReviewerInput interface { + pulumi.Input + + ToOrganizationRulesetRulesPullRequestRequiredReviewerOutput() OrganizationRulesetRulesPullRequestRequiredReviewerOutput + ToOrganizationRulesetRulesPullRequestRequiredReviewerOutputWithContext(context.Context) OrganizationRulesetRulesPullRequestRequiredReviewerOutput +} + +type OrganizationRulesetRulesPullRequestRequiredReviewerArgs struct { + // File patterns (fnmatch syntax) that this reviewer must approve. + FilePatterns pulumi.StringArrayInput `pulumi:"filePatterns"` + // Minimum number of approvals required from this reviewer. Set to 0 to make approval optional. + MinimumApprovals pulumi.IntInput `pulumi:"minimumApprovals"` + // The reviewer that must review matching files. + Reviewer OrganizationRulesetRulesPullRequestRequiredReviewerReviewerInput `pulumi:"reviewer"` +} + +func (OrganizationRulesetRulesPullRequestRequiredReviewerArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesPullRequestRequiredReviewer)(nil)).Elem() +} + +func (i OrganizationRulesetRulesPullRequestRequiredReviewerArgs) ToOrganizationRulesetRulesPullRequestRequiredReviewerOutput() OrganizationRulesetRulesPullRequestRequiredReviewerOutput { + return i.ToOrganizationRulesetRulesPullRequestRequiredReviewerOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesPullRequestRequiredReviewerArgs) ToOrganizationRulesetRulesPullRequestRequiredReviewerOutputWithContext(ctx context.Context) OrganizationRulesetRulesPullRequestRequiredReviewerOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesPullRequestRequiredReviewerOutput) +} + +// OrganizationRulesetRulesPullRequestRequiredReviewerArrayInput is an input type that accepts OrganizationRulesetRulesPullRequestRequiredReviewerArray and OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesPullRequestRequiredReviewerArrayInput` via: +// +// OrganizationRulesetRulesPullRequestRequiredReviewerArray{ OrganizationRulesetRulesPullRequestRequiredReviewerArgs{...} } +type OrganizationRulesetRulesPullRequestRequiredReviewerArrayInput interface { + pulumi.Input + + ToOrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput() OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput + ToOrganizationRulesetRulesPullRequestRequiredReviewerArrayOutputWithContext(context.Context) OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput +} + +type OrganizationRulesetRulesPullRequestRequiredReviewerArray []OrganizationRulesetRulesPullRequestRequiredReviewerInput + +func (OrganizationRulesetRulesPullRequestRequiredReviewerArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]OrganizationRulesetRulesPullRequestRequiredReviewer)(nil)).Elem() +} + +func (i OrganizationRulesetRulesPullRequestRequiredReviewerArray) ToOrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput() OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput { + return i.ToOrganizationRulesetRulesPullRequestRequiredReviewerArrayOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesPullRequestRequiredReviewerArray) ToOrganizationRulesetRulesPullRequestRequiredReviewerArrayOutputWithContext(ctx context.Context) OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput) +} + +type OrganizationRulesetRulesPullRequestRequiredReviewerOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesPullRequestRequiredReviewerOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesPullRequestRequiredReviewer)(nil)).Elem() +} + +func (o OrganizationRulesetRulesPullRequestRequiredReviewerOutput) ToOrganizationRulesetRulesPullRequestRequiredReviewerOutput() OrganizationRulesetRulesPullRequestRequiredReviewerOutput { + return o +} + +func (o OrganizationRulesetRulesPullRequestRequiredReviewerOutput) ToOrganizationRulesetRulesPullRequestRequiredReviewerOutputWithContext(ctx context.Context) OrganizationRulesetRulesPullRequestRequiredReviewerOutput { + return o +} + +// File patterns (fnmatch syntax) that this reviewer must approve. +func (o OrganizationRulesetRulesPullRequestRequiredReviewerOutput) FilePatterns() pulumi.StringArrayOutput { + return o.ApplyT(func(v OrganizationRulesetRulesPullRequestRequiredReviewer) []string { return v.FilePatterns }).(pulumi.StringArrayOutput) +} + +// Minimum number of approvals required from this reviewer. Set to 0 to make approval optional. +func (o OrganizationRulesetRulesPullRequestRequiredReviewerOutput) MinimumApprovals() pulumi.IntOutput { + return o.ApplyT(func(v OrganizationRulesetRulesPullRequestRequiredReviewer) int { return v.MinimumApprovals }).(pulumi.IntOutput) +} + +// The reviewer that must review matching files. +func (o OrganizationRulesetRulesPullRequestRequiredReviewerOutput) Reviewer() OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput { + return o.ApplyT(func(v OrganizationRulesetRulesPullRequestRequiredReviewer) OrganizationRulesetRulesPullRequestRequiredReviewerReviewer { + return v.Reviewer + }).(OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput) +} + +type OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]OrganizationRulesetRulesPullRequestRequiredReviewer)(nil)).Elem() +} + +func (o OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput) ToOrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput() OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput { + return o +} + +func (o OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput) ToOrganizationRulesetRulesPullRequestRequiredReviewerArrayOutputWithContext(ctx context.Context) OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput { + return o +} + +func (o OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput) Index(i pulumi.IntInput) OrganizationRulesetRulesPullRequestRequiredReviewerOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) OrganizationRulesetRulesPullRequestRequiredReviewer { + return vs[0].([]OrganizationRulesetRulesPullRequestRequiredReviewer)[vs[1].(int)] + }).(OrganizationRulesetRulesPullRequestRequiredReviewerOutput) +} + +type OrganizationRulesetRulesPullRequestRequiredReviewerReviewer struct { + // The ID of the reviewer that must review. + Id int `pulumi:"id"` + // The type of reviewer. Currently only `Team` is supported. + Type string `pulumi:"type"` +} + +// OrganizationRulesetRulesPullRequestRequiredReviewerReviewerInput is an input type that accepts OrganizationRulesetRulesPullRequestRequiredReviewerReviewerArgs and OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesPullRequestRequiredReviewerReviewerInput` via: +// +// OrganizationRulesetRulesPullRequestRequiredReviewerReviewerArgs{...} +type OrganizationRulesetRulesPullRequestRequiredReviewerReviewerInput interface { + pulumi.Input + + ToOrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput() OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput + ToOrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutputWithContext(context.Context) OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput +} + +type OrganizationRulesetRulesPullRequestRequiredReviewerReviewerArgs struct { + // The ID of the reviewer that must review. + Id pulumi.IntInput `pulumi:"id"` + // The type of reviewer. Currently only `Team` is supported. + Type pulumi.StringInput `pulumi:"type"` +} + +func (OrganizationRulesetRulesPullRequestRequiredReviewerReviewerArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesPullRequestRequiredReviewerReviewer)(nil)).Elem() +} + +func (i OrganizationRulesetRulesPullRequestRequiredReviewerReviewerArgs) ToOrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput() OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput { + return i.ToOrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesPullRequestRequiredReviewerReviewerArgs) ToOrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutputWithContext(ctx context.Context) OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput) +} + +type OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesPullRequestRequiredReviewerReviewer)(nil)).Elem() +} + +func (o OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput) ToOrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput() OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput { + return o +} + +func (o OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput) ToOrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutputWithContext(ctx context.Context) OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput { + return o +} + +// The ID of the reviewer that must review. +func (o OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput) Id() pulumi.IntOutput { + return o.ApplyT(func(v OrganizationRulesetRulesPullRequestRequiredReviewerReviewer) int { return v.Id }).(pulumi.IntOutput) +} + +// The type of reviewer. Currently only `Team` is supported. +func (o OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetRulesPullRequestRequiredReviewerReviewer) string { return v.Type }).(pulumi.StringOutput) +} + +type OrganizationRulesetRulesRequiredCodeScanning struct { + // Tools that must provide code scanning results for this rule to pass. + RequiredCodeScanningTools []OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningTool `pulumi:"requiredCodeScanningTools"` +} + +// OrganizationRulesetRulesRequiredCodeScanningInput is an input type that accepts OrganizationRulesetRulesRequiredCodeScanningArgs and OrganizationRulesetRulesRequiredCodeScanningOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesRequiredCodeScanningInput` via: +// +// OrganizationRulesetRulesRequiredCodeScanningArgs{...} +type OrganizationRulesetRulesRequiredCodeScanningInput interface { + pulumi.Input + + ToOrganizationRulesetRulesRequiredCodeScanningOutput() OrganizationRulesetRulesRequiredCodeScanningOutput + ToOrganizationRulesetRulesRequiredCodeScanningOutputWithContext(context.Context) OrganizationRulesetRulesRequiredCodeScanningOutput +} + +type OrganizationRulesetRulesRequiredCodeScanningArgs struct { + // Tools that must provide code scanning results for this rule to pass. + RequiredCodeScanningTools OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayInput `pulumi:"requiredCodeScanningTools"` +} + +func (OrganizationRulesetRulesRequiredCodeScanningArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesRequiredCodeScanning)(nil)).Elem() +} + +func (i OrganizationRulesetRulesRequiredCodeScanningArgs) ToOrganizationRulesetRulesRequiredCodeScanningOutput() OrganizationRulesetRulesRequiredCodeScanningOutput { + return i.ToOrganizationRulesetRulesRequiredCodeScanningOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesRequiredCodeScanningArgs) ToOrganizationRulesetRulesRequiredCodeScanningOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredCodeScanningOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesRequiredCodeScanningOutput) +} + +func (i OrganizationRulesetRulesRequiredCodeScanningArgs) ToOrganizationRulesetRulesRequiredCodeScanningPtrOutput() OrganizationRulesetRulesRequiredCodeScanningPtrOutput { + return i.ToOrganizationRulesetRulesRequiredCodeScanningPtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesRequiredCodeScanningArgs) ToOrganizationRulesetRulesRequiredCodeScanningPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredCodeScanningPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesRequiredCodeScanningOutput).ToOrganizationRulesetRulesRequiredCodeScanningPtrOutputWithContext(ctx) +} + +// OrganizationRulesetRulesRequiredCodeScanningPtrInput is an input type that accepts OrganizationRulesetRulesRequiredCodeScanningArgs, OrganizationRulesetRulesRequiredCodeScanningPtr and OrganizationRulesetRulesRequiredCodeScanningPtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesRequiredCodeScanningPtrInput` via: +// +// OrganizationRulesetRulesRequiredCodeScanningArgs{...} +// +// or: +// +// nil +type OrganizationRulesetRulesRequiredCodeScanningPtrInput interface { + pulumi.Input + + ToOrganizationRulesetRulesRequiredCodeScanningPtrOutput() OrganizationRulesetRulesRequiredCodeScanningPtrOutput + ToOrganizationRulesetRulesRequiredCodeScanningPtrOutputWithContext(context.Context) OrganizationRulesetRulesRequiredCodeScanningPtrOutput +} + +type organizationRulesetRulesRequiredCodeScanningPtrType OrganizationRulesetRulesRequiredCodeScanningArgs + +func OrganizationRulesetRulesRequiredCodeScanningPtr(v *OrganizationRulesetRulesRequiredCodeScanningArgs) OrganizationRulesetRulesRequiredCodeScanningPtrInput { + return (*organizationRulesetRulesRequiredCodeScanningPtrType)(v) +} + +func (*organizationRulesetRulesRequiredCodeScanningPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesRequiredCodeScanning)(nil)).Elem() +} + +func (i *organizationRulesetRulesRequiredCodeScanningPtrType) ToOrganizationRulesetRulesRequiredCodeScanningPtrOutput() OrganizationRulesetRulesRequiredCodeScanningPtrOutput { + return i.ToOrganizationRulesetRulesRequiredCodeScanningPtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetRulesRequiredCodeScanningPtrType) ToOrganizationRulesetRulesRequiredCodeScanningPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredCodeScanningPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesRequiredCodeScanningPtrOutput) +} + +type OrganizationRulesetRulesRequiredCodeScanningOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesRequiredCodeScanningOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesRequiredCodeScanning)(nil)).Elem() +} + +func (o OrganizationRulesetRulesRequiredCodeScanningOutput) ToOrganizationRulesetRulesRequiredCodeScanningOutput() OrganizationRulesetRulesRequiredCodeScanningOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredCodeScanningOutput) ToOrganizationRulesetRulesRequiredCodeScanningOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredCodeScanningOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredCodeScanningOutput) ToOrganizationRulesetRulesRequiredCodeScanningPtrOutput() OrganizationRulesetRulesRequiredCodeScanningPtrOutput { + return o.ToOrganizationRulesetRulesRequiredCodeScanningPtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetRulesRequiredCodeScanningOutput) ToOrganizationRulesetRulesRequiredCodeScanningPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredCodeScanningPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetRulesRequiredCodeScanning) *OrganizationRulesetRulesRequiredCodeScanning { + return &v + }).(OrganizationRulesetRulesRequiredCodeScanningPtrOutput) +} + +// Tools that must provide code scanning results for this rule to pass. +func (o OrganizationRulesetRulesRequiredCodeScanningOutput) RequiredCodeScanningTools() OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput { + return o.ApplyT(func(v OrganizationRulesetRulesRequiredCodeScanning) []OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningTool { + return v.RequiredCodeScanningTools + }).(OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput) +} + +type OrganizationRulesetRulesRequiredCodeScanningPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesRequiredCodeScanningPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesRequiredCodeScanning)(nil)).Elem() +} + +func (o OrganizationRulesetRulesRequiredCodeScanningPtrOutput) ToOrganizationRulesetRulesRequiredCodeScanningPtrOutput() OrganizationRulesetRulesRequiredCodeScanningPtrOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredCodeScanningPtrOutput) ToOrganizationRulesetRulesRequiredCodeScanningPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredCodeScanningPtrOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredCodeScanningPtrOutput) Elem() OrganizationRulesetRulesRequiredCodeScanningOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesRequiredCodeScanning) OrganizationRulesetRulesRequiredCodeScanning { + if v != nil { + return *v + } + var ret OrganizationRulesetRulesRequiredCodeScanning + return ret + }).(OrganizationRulesetRulesRequiredCodeScanningOutput) +} + +// Tools that must provide code scanning results for this rule to pass. +func (o OrganizationRulesetRulesRequiredCodeScanningPtrOutput) RequiredCodeScanningTools() OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesRequiredCodeScanning) []OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningTool { + if v == nil { + return nil + } + return v.RequiredCodeScanningTools + }).(OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput) +} + +type OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningTool struct { + // The severity level at which code scanning results that raise alerts block a reference update. Can be one of: `none`, `errors`, `errorsAndWarnings`, `all`. + AlertsThreshold string `pulumi:"alertsThreshold"` + // The severity level at which code scanning results that raise security alerts block a reference update. Can be one of: `none`, `critical`, `highOrHigher`, `mediumOrHigher`, `all`. + SecurityAlertsThreshold string `pulumi:"securityAlertsThreshold"` + // The name of a code scanning tool. + Tool string `pulumi:"tool"` +} + +// OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolInput is an input type that accepts OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs and OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolInput` via: +// +// OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs{...} +type OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolInput interface { + pulumi.Input + + ToOrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput() OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput + ToOrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutputWithContext(context.Context) OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput +} + +type OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs struct { + // The severity level at which code scanning results that raise alerts block a reference update. Can be one of: `none`, `errors`, `errorsAndWarnings`, `all`. + AlertsThreshold pulumi.StringInput `pulumi:"alertsThreshold"` + // The severity level at which code scanning results that raise security alerts block a reference update. Can be one of: `none`, `critical`, `highOrHigher`, `mediumOrHigher`, `all`. + SecurityAlertsThreshold pulumi.StringInput `pulumi:"securityAlertsThreshold"` + // The name of a code scanning tool. + Tool pulumi.StringInput `pulumi:"tool"` +} + +func (OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningTool)(nil)).Elem() +} + +func (i OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs) ToOrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput() OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput { + return i.ToOrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs) ToOrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput) +} + +// OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayInput is an input type that accepts OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArray and OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayInput` via: +// +// OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArray{ OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs{...} } +type OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayInput interface { + pulumi.Input + + ToOrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput() OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput + ToOrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutputWithContext(context.Context) OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput +} + +type OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArray []OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolInput + +func (OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningTool)(nil)).Elem() +} + +func (i OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArray) ToOrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput() OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput { + return i.ToOrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArray) ToOrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput) +} + +type OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningTool)(nil)).Elem() +} + +func (o OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput) ToOrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput() OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput) ToOrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput { + return o +} + +// The severity level at which code scanning results that raise alerts block a reference update. Can be one of: `none`, `errors`, `errorsAndWarnings`, `all`. +func (o OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput) AlertsThreshold() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningTool) string { + return v.AlertsThreshold + }).(pulumi.StringOutput) +} + +// The severity level at which code scanning results that raise security alerts block a reference update. Can be one of: `none`, `critical`, `highOrHigher`, `mediumOrHigher`, `all`. +func (o OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput) SecurityAlertsThreshold() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningTool) string { + return v.SecurityAlertsThreshold + }).(pulumi.StringOutput) +} + +// The name of a code scanning tool. +func (o OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput) Tool() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningTool) string { return v.Tool }).(pulumi.StringOutput) +} + +type OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningTool)(nil)).Elem() +} + +func (o OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput) ToOrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput() OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput) ToOrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput) Index(i pulumi.IntInput) OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningTool { + return vs[0].([]OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningTool)[vs[1].(int)] + }).(OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput) +} + +type OrganizationRulesetRulesRequiredStatusChecks struct { + // (Boolean) Allow repositories and branches to be created if a check would otherwise prohibit it. Defaults to `false`. + DoNotEnforceOnCreate *bool `pulumi:"doNotEnforceOnCreate"` + // Status checks that are required. Several can be defined. + RequiredChecks []OrganizationRulesetRulesRequiredStatusChecksRequiredCheck `pulumi:"requiredChecks"` + // Whether pull requests targeting a matching branch must be tested with the latest code. This setting will not take effect unless at least one status check is enabled. Defaults to `false`. + StrictRequiredStatusChecksPolicy *bool `pulumi:"strictRequiredStatusChecksPolicy"` +} + +// OrganizationRulesetRulesRequiredStatusChecksInput is an input type that accepts OrganizationRulesetRulesRequiredStatusChecksArgs and OrganizationRulesetRulesRequiredStatusChecksOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesRequiredStatusChecksInput` via: +// +// OrganizationRulesetRulesRequiredStatusChecksArgs{...} +type OrganizationRulesetRulesRequiredStatusChecksInput interface { + pulumi.Input + + ToOrganizationRulesetRulesRequiredStatusChecksOutput() OrganizationRulesetRulesRequiredStatusChecksOutput + ToOrganizationRulesetRulesRequiredStatusChecksOutputWithContext(context.Context) OrganizationRulesetRulesRequiredStatusChecksOutput +} + +type OrganizationRulesetRulesRequiredStatusChecksArgs struct { + // (Boolean) Allow repositories and branches to be created if a check would otherwise prohibit it. Defaults to `false`. + DoNotEnforceOnCreate pulumi.BoolPtrInput `pulumi:"doNotEnforceOnCreate"` + // Status checks that are required. Several can be defined. + RequiredChecks OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayInput `pulumi:"requiredChecks"` + // Whether pull requests targeting a matching branch must be tested with the latest code. This setting will not take effect unless at least one status check is enabled. Defaults to `false`. + StrictRequiredStatusChecksPolicy pulumi.BoolPtrInput `pulumi:"strictRequiredStatusChecksPolicy"` +} + +func (OrganizationRulesetRulesRequiredStatusChecksArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesRequiredStatusChecks)(nil)).Elem() +} + +func (i OrganizationRulesetRulesRequiredStatusChecksArgs) ToOrganizationRulesetRulesRequiredStatusChecksOutput() OrganizationRulesetRulesRequiredStatusChecksOutput { + return i.ToOrganizationRulesetRulesRequiredStatusChecksOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesRequiredStatusChecksArgs) ToOrganizationRulesetRulesRequiredStatusChecksOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredStatusChecksOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesRequiredStatusChecksOutput) +} + +func (i OrganizationRulesetRulesRequiredStatusChecksArgs) ToOrganizationRulesetRulesRequiredStatusChecksPtrOutput() OrganizationRulesetRulesRequiredStatusChecksPtrOutput { + return i.ToOrganizationRulesetRulesRequiredStatusChecksPtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesRequiredStatusChecksArgs) ToOrganizationRulesetRulesRequiredStatusChecksPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredStatusChecksPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesRequiredStatusChecksOutput).ToOrganizationRulesetRulesRequiredStatusChecksPtrOutputWithContext(ctx) +} + +// OrganizationRulesetRulesRequiredStatusChecksPtrInput is an input type that accepts OrganizationRulesetRulesRequiredStatusChecksArgs, OrganizationRulesetRulesRequiredStatusChecksPtr and OrganizationRulesetRulesRequiredStatusChecksPtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesRequiredStatusChecksPtrInput` via: +// +// OrganizationRulesetRulesRequiredStatusChecksArgs{...} +// +// or: +// +// nil +type OrganizationRulesetRulesRequiredStatusChecksPtrInput interface { + pulumi.Input + + ToOrganizationRulesetRulesRequiredStatusChecksPtrOutput() OrganizationRulesetRulesRequiredStatusChecksPtrOutput + ToOrganizationRulesetRulesRequiredStatusChecksPtrOutputWithContext(context.Context) OrganizationRulesetRulesRequiredStatusChecksPtrOutput +} + +type organizationRulesetRulesRequiredStatusChecksPtrType OrganizationRulesetRulesRequiredStatusChecksArgs + +func OrganizationRulesetRulesRequiredStatusChecksPtr(v *OrganizationRulesetRulesRequiredStatusChecksArgs) OrganizationRulesetRulesRequiredStatusChecksPtrInput { + return (*organizationRulesetRulesRequiredStatusChecksPtrType)(v) +} + +func (*organizationRulesetRulesRequiredStatusChecksPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesRequiredStatusChecks)(nil)).Elem() +} + +func (i *organizationRulesetRulesRequiredStatusChecksPtrType) ToOrganizationRulesetRulesRequiredStatusChecksPtrOutput() OrganizationRulesetRulesRequiredStatusChecksPtrOutput { + return i.ToOrganizationRulesetRulesRequiredStatusChecksPtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetRulesRequiredStatusChecksPtrType) ToOrganizationRulesetRulesRequiredStatusChecksPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredStatusChecksPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesRequiredStatusChecksPtrOutput) +} + +type OrganizationRulesetRulesRequiredStatusChecksOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesRequiredStatusChecksOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesRequiredStatusChecks)(nil)).Elem() +} + +func (o OrganizationRulesetRulesRequiredStatusChecksOutput) ToOrganizationRulesetRulesRequiredStatusChecksOutput() OrganizationRulesetRulesRequiredStatusChecksOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredStatusChecksOutput) ToOrganizationRulesetRulesRequiredStatusChecksOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredStatusChecksOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredStatusChecksOutput) ToOrganizationRulesetRulesRequiredStatusChecksPtrOutput() OrganizationRulesetRulesRequiredStatusChecksPtrOutput { + return o.ToOrganizationRulesetRulesRequiredStatusChecksPtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetRulesRequiredStatusChecksOutput) ToOrganizationRulesetRulesRequiredStatusChecksPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredStatusChecksPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetRulesRequiredStatusChecks) *OrganizationRulesetRulesRequiredStatusChecks { + return &v + }).(OrganizationRulesetRulesRequiredStatusChecksPtrOutput) +} + +// (Boolean) Allow repositories and branches to be created if a check would otherwise prohibit it. Defaults to `false`. +func (o OrganizationRulesetRulesRequiredStatusChecksOutput) DoNotEnforceOnCreate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesRequiredStatusChecks) *bool { return v.DoNotEnforceOnCreate }).(pulumi.BoolPtrOutput) +} + +// Status checks that are required. Several can be defined. +func (o OrganizationRulesetRulesRequiredStatusChecksOutput) RequiredChecks() OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput { + return o.ApplyT(func(v OrganizationRulesetRulesRequiredStatusChecks) []OrganizationRulesetRulesRequiredStatusChecksRequiredCheck { + return v.RequiredChecks + }).(OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput) +} + +// Whether pull requests targeting a matching branch must be tested with the latest code. This setting will not take effect unless at least one status check is enabled. Defaults to `false`. +func (o OrganizationRulesetRulesRequiredStatusChecksOutput) StrictRequiredStatusChecksPolicy() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesRequiredStatusChecks) *bool { return v.StrictRequiredStatusChecksPolicy }).(pulumi.BoolPtrOutput) +} + +type OrganizationRulesetRulesRequiredStatusChecksPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesRequiredStatusChecksPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesRequiredStatusChecks)(nil)).Elem() +} + +func (o OrganizationRulesetRulesRequiredStatusChecksPtrOutput) ToOrganizationRulesetRulesRequiredStatusChecksPtrOutput() OrganizationRulesetRulesRequiredStatusChecksPtrOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredStatusChecksPtrOutput) ToOrganizationRulesetRulesRequiredStatusChecksPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredStatusChecksPtrOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredStatusChecksPtrOutput) Elem() OrganizationRulesetRulesRequiredStatusChecksOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesRequiredStatusChecks) OrganizationRulesetRulesRequiredStatusChecks { + if v != nil { + return *v + } + var ret OrganizationRulesetRulesRequiredStatusChecks + return ret + }).(OrganizationRulesetRulesRequiredStatusChecksOutput) +} + +// (Boolean) Allow repositories and branches to be created if a check would otherwise prohibit it. Defaults to `false`. +func (o OrganizationRulesetRulesRequiredStatusChecksPtrOutput) DoNotEnforceOnCreate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesRequiredStatusChecks) *bool { + if v == nil { + return nil + } + return v.DoNotEnforceOnCreate + }).(pulumi.BoolPtrOutput) +} + +// Status checks that are required. Several can be defined. +func (o OrganizationRulesetRulesRequiredStatusChecksPtrOutput) RequiredChecks() OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesRequiredStatusChecks) []OrganizationRulesetRulesRequiredStatusChecksRequiredCheck { + if v == nil { + return nil + } + return v.RequiredChecks + }).(OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput) +} + +// Whether pull requests targeting a matching branch must be tested with the latest code. This setting will not take effect unless at least one status check is enabled. Defaults to `false`. +func (o OrganizationRulesetRulesRequiredStatusChecksPtrOutput) StrictRequiredStatusChecksPolicy() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesRequiredStatusChecks) *bool { + if v == nil { + return nil + } + return v.StrictRequiredStatusChecksPolicy + }).(pulumi.BoolPtrOutput) +} + +type OrganizationRulesetRulesRequiredStatusChecksRequiredCheck struct { + // The status check context name that must be present on the commit. + Context string `pulumi:"context"` + // The optional integration ID that this status check must originate from. + IntegrationId *int `pulumi:"integrationId"` +} + +// OrganizationRulesetRulesRequiredStatusChecksRequiredCheckInput is an input type that accepts OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArgs and OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesRequiredStatusChecksRequiredCheckInput` via: +// +// OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArgs{...} +type OrganizationRulesetRulesRequiredStatusChecksRequiredCheckInput interface { + pulumi.Input + + ToOrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput() OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput + ToOrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutputWithContext(context.Context) OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput +} + +type OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArgs struct { + // The status check context name that must be present on the commit. + Context pulumi.StringInput `pulumi:"context"` + // The optional integration ID that this status check must originate from. + IntegrationId pulumi.IntPtrInput `pulumi:"integrationId"` +} + +func (OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesRequiredStatusChecksRequiredCheck)(nil)).Elem() +} + +func (i OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArgs) ToOrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput() OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput { + return i.ToOrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArgs) ToOrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput) +} + +// OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayInput is an input type that accepts OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArray and OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayInput` via: +// +// OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArray{ OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArgs{...} } +type OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayInput interface { + pulumi.Input + + ToOrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput() OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput + ToOrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutputWithContext(context.Context) OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput +} + +type OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArray []OrganizationRulesetRulesRequiredStatusChecksRequiredCheckInput + +func (OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]OrganizationRulesetRulesRequiredStatusChecksRequiredCheck)(nil)).Elem() +} + +func (i OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArray) ToOrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput() OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput { + return i.ToOrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArray) ToOrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput) +} + +type OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesRequiredStatusChecksRequiredCheck)(nil)).Elem() +} + +func (o OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput) ToOrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput() OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput) ToOrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput { + return o +} + +// The status check context name that must be present on the commit. +func (o OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput) Context() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetRulesRequiredStatusChecksRequiredCheck) string { return v.Context }).(pulumi.StringOutput) +} + +// The optional integration ID that this status check must originate from. +func (o OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput) IntegrationId() pulumi.IntPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesRequiredStatusChecksRequiredCheck) *int { return v.IntegrationId }).(pulumi.IntPtrOutput) +} + +type OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]OrganizationRulesetRulesRequiredStatusChecksRequiredCheck)(nil)).Elem() +} + +func (o OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput) ToOrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput() OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput) ToOrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput) Index(i pulumi.IntInput) OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) OrganizationRulesetRulesRequiredStatusChecksRequiredCheck { + return vs[0].([]OrganizationRulesetRulesRequiredStatusChecksRequiredCheck)[vs[1].(int)] + }).(OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput) +} + +type OrganizationRulesetRulesRequiredWorkflows struct { + // Allow repositories and branches to be created if a check would otherwise prohibit it. + DoNotEnforceOnCreate *bool `pulumi:"doNotEnforceOnCreate"` + // Actions workflows that are required. Several can be defined. + RequiredWorkflows []OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflow `pulumi:"requiredWorkflows"` +} + +// OrganizationRulesetRulesRequiredWorkflowsInput is an input type that accepts OrganizationRulesetRulesRequiredWorkflowsArgs and OrganizationRulesetRulesRequiredWorkflowsOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesRequiredWorkflowsInput` via: +// +// OrganizationRulesetRulesRequiredWorkflowsArgs{...} +type OrganizationRulesetRulesRequiredWorkflowsInput interface { + pulumi.Input + + ToOrganizationRulesetRulesRequiredWorkflowsOutput() OrganizationRulesetRulesRequiredWorkflowsOutput + ToOrganizationRulesetRulesRequiredWorkflowsOutputWithContext(context.Context) OrganizationRulesetRulesRequiredWorkflowsOutput +} + +type OrganizationRulesetRulesRequiredWorkflowsArgs struct { + // Allow repositories and branches to be created if a check would otherwise prohibit it. + DoNotEnforceOnCreate pulumi.BoolPtrInput `pulumi:"doNotEnforceOnCreate"` + // Actions workflows that are required. Several can be defined. + RequiredWorkflows OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayInput `pulumi:"requiredWorkflows"` +} + +func (OrganizationRulesetRulesRequiredWorkflowsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesRequiredWorkflows)(nil)).Elem() +} + +func (i OrganizationRulesetRulesRequiredWorkflowsArgs) ToOrganizationRulesetRulesRequiredWorkflowsOutput() OrganizationRulesetRulesRequiredWorkflowsOutput { + return i.ToOrganizationRulesetRulesRequiredWorkflowsOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesRequiredWorkflowsArgs) ToOrganizationRulesetRulesRequiredWorkflowsOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredWorkflowsOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesRequiredWorkflowsOutput) +} + +func (i OrganizationRulesetRulesRequiredWorkflowsArgs) ToOrganizationRulesetRulesRequiredWorkflowsPtrOutput() OrganizationRulesetRulesRequiredWorkflowsPtrOutput { + return i.ToOrganizationRulesetRulesRequiredWorkflowsPtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesRequiredWorkflowsArgs) ToOrganizationRulesetRulesRequiredWorkflowsPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredWorkflowsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesRequiredWorkflowsOutput).ToOrganizationRulesetRulesRequiredWorkflowsPtrOutputWithContext(ctx) +} + +// OrganizationRulesetRulesRequiredWorkflowsPtrInput is an input type that accepts OrganizationRulesetRulesRequiredWorkflowsArgs, OrganizationRulesetRulesRequiredWorkflowsPtr and OrganizationRulesetRulesRequiredWorkflowsPtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesRequiredWorkflowsPtrInput` via: +// +// OrganizationRulesetRulesRequiredWorkflowsArgs{...} +// +// or: +// +// nil +type OrganizationRulesetRulesRequiredWorkflowsPtrInput interface { + pulumi.Input + + ToOrganizationRulesetRulesRequiredWorkflowsPtrOutput() OrganizationRulesetRulesRequiredWorkflowsPtrOutput + ToOrganizationRulesetRulesRequiredWorkflowsPtrOutputWithContext(context.Context) OrganizationRulesetRulesRequiredWorkflowsPtrOutput +} + +type organizationRulesetRulesRequiredWorkflowsPtrType OrganizationRulesetRulesRequiredWorkflowsArgs + +func OrganizationRulesetRulesRequiredWorkflowsPtr(v *OrganizationRulesetRulesRequiredWorkflowsArgs) OrganizationRulesetRulesRequiredWorkflowsPtrInput { + return (*organizationRulesetRulesRequiredWorkflowsPtrType)(v) +} + +func (*organizationRulesetRulesRequiredWorkflowsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesRequiredWorkflows)(nil)).Elem() +} + +func (i *organizationRulesetRulesRequiredWorkflowsPtrType) ToOrganizationRulesetRulesRequiredWorkflowsPtrOutput() OrganizationRulesetRulesRequiredWorkflowsPtrOutput { + return i.ToOrganizationRulesetRulesRequiredWorkflowsPtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetRulesRequiredWorkflowsPtrType) ToOrganizationRulesetRulesRequiredWorkflowsPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredWorkflowsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesRequiredWorkflowsPtrOutput) +} + +type OrganizationRulesetRulesRequiredWorkflowsOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesRequiredWorkflowsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesRequiredWorkflows)(nil)).Elem() +} + +func (o OrganizationRulesetRulesRequiredWorkflowsOutput) ToOrganizationRulesetRulesRequiredWorkflowsOutput() OrganizationRulesetRulesRequiredWorkflowsOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredWorkflowsOutput) ToOrganizationRulesetRulesRequiredWorkflowsOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredWorkflowsOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredWorkflowsOutput) ToOrganizationRulesetRulesRequiredWorkflowsPtrOutput() OrganizationRulesetRulesRequiredWorkflowsPtrOutput { + return o.ToOrganizationRulesetRulesRequiredWorkflowsPtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetRulesRequiredWorkflowsOutput) ToOrganizationRulesetRulesRequiredWorkflowsPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredWorkflowsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetRulesRequiredWorkflows) *OrganizationRulesetRulesRequiredWorkflows { + return &v + }).(OrganizationRulesetRulesRequiredWorkflowsPtrOutput) +} + +// Allow repositories and branches to be created if a check would otherwise prohibit it. +func (o OrganizationRulesetRulesRequiredWorkflowsOutput) DoNotEnforceOnCreate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesRequiredWorkflows) *bool { return v.DoNotEnforceOnCreate }).(pulumi.BoolPtrOutput) +} + +// Actions workflows that are required. Several can be defined. +func (o OrganizationRulesetRulesRequiredWorkflowsOutput) RequiredWorkflows() OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput { + return o.ApplyT(func(v OrganizationRulesetRulesRequiredWorkflows) []OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflow { + return v.RequiredWorkflows + }).(OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput) +} + +type OrganizationRulesetRulesRequiredWorkflowsPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesRequiredWorkflowsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesRequiredWorkflows)(nil)).Elem() +} + +func (o OrganizationRulesetRulesRequiredWorkflowsPtrOutput) ToOrganizationRulesetRulesRequiredWorkflowsPtrOutput() OrganizationRulesetRulesRequiredWorkflowsPtrOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredWorkflowsPtrOutput) ToOrganizationRulesetRulesRequiredWorkflowsPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredWorkflowsPtrOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredWorkflowsPtrOutput) Elem() OrganizationRulesetRulesRequiredWorkflowsOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesRequiredWorkflows) OrganizationRulesetRulesRequiredWorkflows { + if v != nil { + return *v + } + var ret OrganizationRulesetRulesRequiredWorkflows + return ret + }).(OrganizationRulesetRulesRequiredWorkflowsOutput) +} + +// Allow repositories and branches to be created if a check would otherwise prohibit it. +func (o OrganizationRulesetRulesRequiredWorkflowsPtrOutput) DoNotEnforceOnCreate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesRequiredWorkflows) *bool { + if v == nil { + return nil + } + return v.DoNotEnforceOnCreate + }).(pulumi.BoolPtrOutput) +} + +// Actions workflows that are required. Several can be defined. +func (o OrganizationRulesetRulesRequiredWorkflowsPtrOutput) RequiredWorkflows() OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesRequiredWorkflows) []OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflow { + if v == nil { + return nil + } + return v.RequiredWorkflows + }).(OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput) +} + +type OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflow struct { + // The path to the workflow YAML definition file. + Path string `pulumi:"path"` + // The ref (branch or tag) of the workflow file to use. + Ref *string `pulumi:"ref"` + // The repository in which the workflow is defined. + RepositoryId int `pulumi:"repositoryId"` +} + +// OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowInput is an input type that accepts OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArgs and OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowInput` via: +// +// OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArgs{...} +type OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowInput interface { + pulumi.Input + + ToOrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput() OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput + ToOrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutputWithContext(context.Context) OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput +} + +type OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArgs struct { + // The path to the workflow YAML definition file. + Path pulumi.StringInput `pulumi:"path"` + // The ref (branch or tag) of the workflow file to use. + Ref pulumi.StringPtrInput `pulumi:"ref"` + // The repository in which the workflow is defined. + RepositoryId pulumi.IntInput `pulumi:"repositoryId"` +} + +func (OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflow)(nil)).Elem() +} + +func (i OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArgs) ToOrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput() OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput { + return i.ToOrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArgs) ToOrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput) +} + +// OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayInput is an input type that accepts OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArray and OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayInput` via: +// +// OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArray{ OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArgs{...} } +type OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayInput interface { + pulumi.Input + + ToOrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput() OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput + ToOrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutputWithContext(context.Context) OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput +} + +type OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArray []OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowInput + +func (OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflow)(nil)).Elem() +} + +func (i OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArray) ToOrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput() OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput { + return i.ToOrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArray) ToOrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput) +} + +type OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflow)(nil)).Elem() +} + +func (o OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput) ToOrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput() OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput) ToOrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput { + return o +} + +// The path to the workflow YAML definition file. +func (o OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput) Path() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflow) string { return v.Path }).(pulumi.StringOutput) +} + +// The ref (branch or tag) of the workflow file to use. +func (o OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput) Ref() pulumi.StringPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflow) *string { return v.Ref }).(pulumi.StringPtrOutput) +} + +// The repository in which the workflow is defined. +func (o OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput) RepositoryId() pulumi.IntOutput { + return o.ApplyT(func(v OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflow) int { return v.RepositoryId }).(pulumi.IntOutput) +} + +type OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflow)(nil)).Elem() +} + +func (o OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput) ToOrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput() OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput) ToOrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutputWithContext(ctx context.Context) OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput { + return o +} + +func (o OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput) Index(i pulumi.IntInput) OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflow { + return vs[0].([]OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflow)[vs[1].(int)] + }).(OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput) +} + +type OrganizationRulesetRulesTagNamePattern struct { + // (String) The name of the ruleset. + Name *string `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate *bool `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator string `pulumi:"operator"` + // The pattern to match with. + Pattern string `pulumi:"pattern"` +} + +// OrganizationRulesetRulesTagNamePatternInput is an input type that accepts OrganizationRulesetRulesTagNamePatternArgs and OrganizationRulesetRulesTagNamePatternOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesTagNamePatternInput` via: +// +// OrganizationRulesetRulesTagNamePatternArgs{...} +type OrganizationRulesetRulesTagNamePatternInput interface { + pulumi.Input + + ToOrganizationRulesetRulesTagNamePatternOutput() OrganizationRulesetRulesTagNamePatternOutput + ToOrganizationRulesetRulesTagNamePatternOutputWithContext(context.Context) OrganizationRulesetRulesTagNamePatternOutput +} + +type OrganizationRulesetRulesTagNamePatternArgs struct { + // (String) The name of the ruleset. + Name pulumi.StringPtrInput `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate pulumi.BoolPtrInput `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator pulumi.StringInput `pulumi:"operator"` + // The pattern to match with. + Pattern pulumi.StringInput `pulumi:"pattern"` +} + +func (OrganizationRulesetRulesTagNamePatternArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesTagNamePattern)(nil)).Elem() +} + +func (i OrganizationRulesetRulesTagNamePatternArgs) ToOrganizationRulesetRulesTagNamePatternOutput() OrganizationRulesetRulesTagNamePatternOutput { + return i.ToOrganizationRulesetRulesTagNamePatternOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesTagNamePatternArgs) ToOrganizationRulesetRulesTagNamePatternOutputWithContext(ctx context.Context) OrganizationRulesetRulesTagNamePatternOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesTagNamePatternOutput) +} + +func (i OrganizationRulesetRulesTagNamePatternArgs) ToOrganizationRulesetRulesTagNamePatternPtrOutput() OrganizationRulesetRulesTagNamePatternPtrOutput { + return i.ToOrganizationRulesetRulesTagNamePatternPtrOutputWithContext(context.Background()) +} + +func (i OrganizationRulesetRulesTagNamePatternArgs) ToOrganizationRulesetRulesTagNamePatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesTagNamePatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesTagNamePatternOutput).ToOrganizationRulesetRulesTagNamePatternPtrOutputWithContext(ctx) +} + +// OrganizationRulesetRulesTagNamePatternPtrInput is an input type that accepts OrganizationRulesetRulesTagNamePatternArgs, OrganizationRulesetRulesTagNamePatternPtr and OrganizationRulesetRulesTagNamePatternPtrOutput values. +// You can construct a concrete instance of `OrganizationRulesetRulesTagNamePatternPtrInput` via: +// +// OrganizationRulesetRulesTagNamePatternArgs{...} +// +// or: +// +// nil +type OrganizationRulesetRulesTagNamePatternPtrInput interface { + pulumi.Input + + ToOrganizationRulesetRulesTagNamePatternPtrOutput() OrganizationRulesetRulesTagNamePatternPtrOutput + ToOrganizationRulesetRulesTagNamePatternPtrOutputWithContext(context.Context) OrganizationRulesetRulesTagNamePatternPtrOutput +} + +type organizationRulesetRulesTagNamePatternPtrType OrganizationRulesetRulesTagNamePatternArgs + +func OrganizationRulesetRulesTagNamePatternPtr(v *OrganizationRulesetRulesTagNamePatternArgs) OrganizationRulesetRulesTagNamePatternPtrInput { + return (*organizationRulesetRulesTagNamePatternPtrType)(v) +} + +func (*organizationRulesetRulesTagNamePatternPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesTagNamePattern)(nil)).Elem() +} + +func (i *organizationRulesetRulesTagNamePatternPtrType) ToOrganizationRulesetRulesTagNamePatternPtrOutput() OrganizationRulesetRulesTagNamePatternPtrOutput { + return i.ToOrganizationRulesetRulesTagNamePatternPtrOutputWithContext(context.Background()) +} + +func (i *organizationRulesetRulesTagNamePatternPtrType) ToOrganizationRulesetRulesTagNamePatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesTagNamePatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationRulesetRulesTagNamePatternPtrOutput) +} + +type OrganizationRulesetRulesTagNamePatternOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesTagNamePatternOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationRulesetRulesTagNamePattern)(nil)).Elem() +} + +func (o OrganizationRulesetRulesTagNamePatternOutput) ToOrganizationRulesetRulesTagNamePatternOutput() OrganizationRulesetRulesTagNamePatternOutput { + return o +} + +func (o OrganizationRulesetRulesTagNamePatternOutput) ToOrganizationRulesetRulesTagNamePatternOutputWithContext(ctx context.Context) OrganizationRulesetRulesTagNamePatternOutput { + return o +} + +func (o OrganizationRulesetRulesTagNamePatternOutput) ToOrganizationRulesetRulesTagNamePatternPtrOutput() OrganizationRulesetRulesTagNamePatternPtrOutput { + return o.ToOrganizationRulesetRulesTagNamePatternPtrOutputWithContext(context.Background()) +} + +func (o OrganizationRulesetRulesTagNamePatternOutput) ToOrganizationRulesetRulesTagNamePatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesTagNamePatternPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationRulesetRulesTagNamePattern) *OrganizationRulesetRulesTagNamePattern { + return &v + }).(OrganizationRulesetRulesTagNamePatternPtrOutput) +} + +// (String) The name of the ruleset. +func (o OrganizationRulesetRulesTagNamePatternOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesTagNamePattern) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o OrganizationRulesetRulesTagNamePatternOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationRulesetRulesTagNamePattern) *bool { return v.Negate }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o OrganizationRulesetRulesTagNamePatternOutput) Operator() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetRulesTagNamePattern) string { return v.Operator }).(pulumi.StringOutput) +} + +// The pattern to match with. +func (o OrganizationRulesetRulesTagNamePatternOutput) Pattern() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationRulesetRulesTagNamePattern) string { return v.Pattern }).(pulumi.StringOutput) +} + +type OrganizationRulesetRulesTagNamePatternPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationRulesetRulesTagNamePatternPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationRulesetRulesTagNamePattern)(nil)).Elem() +} + +func (o OrganizationRulesetRulesTagNamePatternPtrOutput) ToOrganizationRulesetRulesTagNamePatternPtrOutput() OrganizationRulesetRulesTagNamePatternPtrOutput { + return o +} + +func (o OrganizationRulesetRulesTagNamePatternPtrOutput) ToOrganizationRulesetRulesTagNamePatternPtrOutputWithContext(ctx context.Context) OrganizationRulesetRulesTagNamePatternPtrOutput { + return o +} + +func (o OrganizationRulesetRulesTagNamePatternPtrOutput) Elem() OrganizationRulesetRulesTagNamePatternOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesTagNamePattern) OrganizationRulesetRulesTagNamePattern { + if v != nil { + return *v + } + var ret OrganizationRulesetRulesTagNamePattern + return ret + }).(OrganizationRulesetRulesTagNamePatternOutput) +} + +// (String) The name of the ruleset. +func (o OrganizationRulesetRulesTagNamePatternPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesTagNamePattern) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o OrganizationRulesetRulesTagNamePatternPtrOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesTagNamePattern) *bool { + if v == nil { + return nil + } + return v.Negate + }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o OrganizationRulesetRulesTagNamePatternPtrOutput) Operator() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesTagNamePattern) *string { + if v == nil { + return nil + } + return &v.Operator + }).(pulumi.StringPtrOutput) +} + +// The pattern to match with. +func (o OrganizationRulesetRulesTagNamePatternPtrOutput) Pattern() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationRulesetRulesTagNamePattern) *string { + if v == nil { + return nil + } + return &v.Pattern + }).(pulumi.StringPtrOutput) +} + +type OrganizationWebhookConfiguration struct { + // The content type for the payload. Valid values are either 'form' or 'json'. + ContentType *string `pulumi:"contentType"` + // Insecure SSL boolean toggle. Defaults to 'false'. + InsecureSsl *bool `pulumi:"insecureSsl"` + // The shared secret for the webhook + Secret *string `pulumi:"secret"` + // URL of the webhook + Url string `pulumi:"url"` +} + +// OrganizationWebhookConfigurationInput is an input type that accepts OrganizationWebhookConfigurationArgs and OrganizationWebhookConfigurationOutput values. +// You can construct a concrete instance of `OrganizationWebhookConfigurationInput` via: +// +// OrganizationWebhookConfigurationArgs{...} +type OrganizationWebhookConfigurationInput interface { + pulumi.Input + + ToOrganizationWebhookConfigurationOutput() OrganizationWebhookConfigurationOutput + ToOrganizationWebhookConfigurationOutputWithContext(context.Context) OrganizationWebhookConfigurationOutput +} + +type OrganizationWebhookConfigurationArgs struct { + // The content type for the payload. Valid values are either 'form' or 'json'. + ContentType pulumi.StringPtrInput `pulumi:"contentType"` + // Insecure SSL boolean toggle. Defaults to 'false'. + InsecureSsl pulumi.BoolPtrInput `pulumi:"insecureSsl"` + // The shared secret for the webhook + Secret pulumi.StringPtrInput `pulumi:"secret"` + // URL of the webhook + Url pulumi.StringInput `pulumi:"url"` +} + +func (OrganizationWebhookConfigurationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationWebhookConfiguration)(nil)).Elem() +} + +func (i OrganizationWebhookConfigurationArgs) ToOrganizationWebhookConfigurationOutput() OrganizationWebhookConfigurationOutput { + return i.ToOrganizationWebhookConfigurationOutputWithContext(context.Background()) +} + +func (i OrganizationWebhookConfigurationArgs) ToOrganizationWebhookConfigurationOutputWithContext(ctx context.Context) OrganizationWebhookConfigurationOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationWebhookConfigurationOutput) +} + +func (i OrganizationWebhookConfigurationArgs) ToOrganizationWebhookConfigurationPtrOutput() OrganizationWebhookConfigurationPtrOutput { + return i.ToOrganizationWebhookConfigurationPtrOutputWithContext(context.Background()) +} + +func (i OrganizationWebhookConfigurationArgs) ToOrganizationWebhookConfigurationPtrOutputWithContext(ctx context.Context) OrganizationWebhookConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationWebhookConfigurationOutput).ToOrganizationWebhookConfigurationPtrOutputWithContext(ctx) +} + +// OrganizationWebhookConfigurationPtrInput is an input type that accepts OrganizationWebhookConfigurationArgs, OrganizationWebhookConfigurationPtr and OrganizationWebhookConfigurationPtrOutput values. +// You can construct a concrete instance of `OrganizationWebhookConfigurationPtrInput` via: +// +// OrganizationWebhookConfigurationArgs{...} +// +// or: +// +// nil +type OrganizationWebhookConfigurationPtrInput interface { + pulumi.Input + + ToOrganizationWebhookConfigurationPtrOutput() OrganizationWebhookConfigurationPtrOutput + ToOrganizationWebhookConfigurationPtrOutputWithContext(context.Context) OrganizationWebhookConfigurationPtrOutput +} + +type organizationWebhookConfigurationPtrType OrganizationWebhookConfigurationArgs + +func OrganizationWebhookConfigurationPtr(v *OrganizationWebhookConfigurationArgs) OrganizationWebhookConfigurationPtrInput { + return (*organizationWebhookConfigurationPtrType)(v) +} + +func (*organizationWebhookConfigurationPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationWebhookConfiguration)(nil)).Elem() +} + +func (i *organizationWebhookConfigurationPtrType) ToOrganizationWebhookConfigurationPtrOutput() OrganizationWebhookConfigurationPtrOutput { + return i.ToOrganizationWebhookConfigurationPtrOutputWithContext(context.Background()) +} + +func (i *organizationWebhookConfigurationPtrType) ToOrganizationWebhookConfigurationPtrOutputWithContext(ctx context.Context) OrganizationWebhookConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(OrganizationWebhookConfigurationPtrOutput) +} + +type OrganizationWebhookConfigurationOutput struct{ *pulumi.OutputState } + +func (OrganizationWebhookConfigurationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*OrganizationWebhookConfiguration)(nil)).Elem() +} + +func (o OrganizationWebhookConfigurationOutput) ToOrganizationWebhookConfigurationOutput() OrganizationWebhookConfigurationOutput { + return o +} + +func (o OrganizationWebhookConfigurationOutput) ToOrganizationWebhookConfigurationOutputWithContext(ctx context.Context) OrganizationWebhookConfigurationOutput { + return o +} + +func (o OrganizationWebhookConfigurationOutput) ToOrganizationWebhookConfigurationPtrOutput() OrganizationWebhookConfigurationPtrOutput { + return o.ToOrganizationWebhookConfigurationPtrOutputWithContext(context.Background()) +} + +func (o OrganizationWebhookConfigurationOutput) ToOrganizationWebhookConfigurationPtrOutputWithContext(ctx context.Context) OrganizationWebhookConfigurationPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v OrganizationWebhookConfiguration) *OrganizationWebhookConfiguration { + return &v + }).(OrganizationWebhookConfigurationPtrOutput) +} + +// The content type for the payload. Valid values are either 'form' or 'json'. +func (o OrganizationWebhookConfigurationOutput) ContentType() pulumi.StringPtrOutput { + return o.ApplyT(func(v OrganizationWebhookConfiguration) *string { return v.ContentType }).(pulumi.StringPtrOutput) +} + +// Insecure SSL boolean toggle. Defaults to 'false'. +func (o OrganizationWebhookConfigurationOutput) InsecureSsl() pulumi.BoolPtrOutput { + return o.ApplyT(func(v OrganizationWebhookConfiguration) *bool { return v.InsecureSsl }).(pulumi.BoolPtrOutput) +} + +// The shared secret for the webhook +func (o OrganizationWebhookConfigurationOutput) Secret() pulumi.StringPtrOutput { + return o.ApplyT(func(v OrganizationWebhookConfiguration) *string { return v.Secret }).(pulumi.StringPtrOutput) +} + +// URL of the webhook +func (o OrganizationWebhookConfigurationOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v OrganizationWebhookConfiguration) string { return v.Url }).(pulumi.StringOutput) +} + +type OrganizationWebhookConfigurationPtrOutput struct{ *pulumi.OutputState } + +func (OrganizationWebhookConfigurationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**OrganizationWebhookConfiguration)(nil)).Elem() +} + +func (o OrganizationWebhookConfigurationPtrOutput) ToOrganizationWebhookConfigurationPtrOutput() OrganizationWebhookConfigurationPtrOutput { + return o +} + +func (o OrganizationWebhookConfigurationPtrOutput) ToOrganizationWebhookConfigurationPtrOutputWithContext(ctx context.Context) OrganizationWebhookConfigurationPtrOutput { + return o +} + +func (o OrganizationWebhookConfigurationPtrOutput) Elem() OrganizationWebhookConfigurationOutput { + return o.ApplyT(func(v *OrganizationWebhookConfiguration) OrganizationWebhookConfiguration { + if v != nil { + return *v + } + var ret OrganizationWebhookConfiguration + return ret + }).(OrganizationWebhookConfigurationOutput) +} + +// The content type for the payload. Valid values are either 'form' or 'json'. +func (o OrganizationWebhookConfigurationPtrOutput) ContentType() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationWebhookConfiguration) *string { + if v == nil { + return nil + } + return v.ContentType + }).(pulumi.StringPtrOutput) +} + +// Insecure SSL boolean toggle. Defaults to 'false'. +func (o OrganizationWebhookConfigurationPtrOutput) InsecureSsl() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *OrganizationWebhookConfiguration) *bool { + if v == nil { + return nil + } + return v.InsecureSsl + }).(pulumi.BoolPtrOutput) +} + +// The shared secret for the webhook +func (o OrganizationWebhookConfigurationPtrOutput) Secret() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationWebhookConfiguration) *string { + if v == nil { + return nil + } + return v.Secret + }).(pulumi.StringPtrOutput) +} + +// URL of the webhook +func (o OrganizationWebhookConfigurationPtrOutput) Url() pulumi.StringPtrOutput { + return o.ApplyT(func(v *OrganizationWebhookConfiguration) *string { + if v == nil { + return nil + } + return &v.Url + }).(pulumi.StringPtrOutput) +} + +type ProviderAppAuth struct { + // The GitHub App ID. + Id string `pulumi:"id"` + // The GitHub App installation instance ID. + InstallationId string `pulumi:"installationId"` + // The GitHub App PEM file contents. + PemFile string `pulumi:"pemFile"` +} + +// ProviderAppAuthInput is an input type that accepts ProviderAppAuthArgs and ProviderAppAuthOutput values. +// You can construct a concrete instance of `ProviderAppAuthInput` via: +// +// ProviderAppAuthArgs{...} +type ProviderAppAuthInput interface { + pulumi.Input + + ToProviderAppAuthOutput() ProviderAppAuthOutput + ToProviderAppAuthOutputWithContext(context.Context) ProviderAppAuthOutput +} + +type ProviderAppAuthArgs struct { + // The GitHub App ID. + Id pulumi.StringInput `pulumi:"id"` + // The GitHub App installation instance ID. + InstallationId pulumi.StringInput `pulumi:"installationId"` + // The GitHub App PEM file contents. + PemFile pulumi.StringInput `pulumi:"pemFile"` +} + +func (ProviderAppAuthArgs) ElementType() reflect.Type { + return reflect.TypeOf((*ProviderAppAuth)(nil)).Elem() +} + +func (i ProviderAppAuthArgs) ToProviderAppAuthOutput() ProviderAppAuthOutput { + return i.ToProviderAppAuthOutputWithContext(context.Background()) +} + +func (i ProviderAppAuthArgs) ToProviderAppAuthOutputWithContext(ctx context.Context) ProviderAppAuthOutput { + return pulumi.ToOutputWithContext(ctx, i).(ProviderAppAuthOutput) +} + +func (i ProviderAppAuthArgs) ToProviderAppAuthPtrOutput() ProviderAppAuthPtrOutput { + return i.ToProviderAppAuthPtrOutputWithContext(context.Background()) +} + +func (i ProviderAppAuthArgs) ToProviderAppAuthPtrOutputWithContext(ctx context.Context) ProviderAppAuthPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ProviderAppAuthOutput).ToProviderAppAuthPtrOutputWithContext(ctx) +} + +// ProviderAppAuthPtrInput is an input type that accepts ProviderAppAuthArgs, ProviderAppAuthPtr and ProviderAppAuthPtrOutput values. +// You can construct a concrete instance of `ProviderAppAuthPtrInput` via: +// +// ProviderAppAuthArgs{...} +// +// or: +// +// nil +type ProviderAppAuthPtrInput interface { + pulumi.Input + + ToProviderAppAuthPtrOutput() ProviderAppAuthPtrOutput + ToProviderAppAuthPtrOutputWithContext(context.Context) ProviderAppAuthPtrOutput +} + +type providerAppAuthPtrType ProviderAppAuthArgs + +func ProviderAppAuthPtr(v *ProviderAppAuthArgs) ProviderAppAuthPtrInput { + return (*providerAppAuthPtrType)(v) +} + +func (*providerAppAuthPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**ProviderAppAuth)(nil)).Elem() +} + +func (i *providerAppAuthPtrType) ToProviderAppAuthPtrOutput() ProviderAppAuthPtrOutput { + return i.ToProviderAppAuthPtrOutputWithContext(context.Background()) +} + +func (i *providerAppAuthPtrType) ToProviderAppAuthPtrOutputWithContext(ctx context.Context) ProviderAppAuthPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(ProviderAppAuthPtrOutput) +} + +type ProviderAppAuthOutput struct{ *pulumi.OutputState } + +func (ProviderAppAuthOutput) ElementType() reflect.Type { + return reflect.TypeOf((*ProviderAppAuth)(nil)).Elem() +} + +func (o ProviderAppAuthOutput) ToProviderAppAuthOutput() ProviderAppAuthOutput { + return o +} + +func (o ProviderAppAuthOutput) ToProviderAppAuthOutputWithContext(ctx context.Context) ProviderAppAuthOutput { + return o +} + +func (o ProviderAppAuthOutput) ToProviderAppAuthPtrOutput() ProviderAppAuthPtrOutput { + return o.ToProviderAppAuthPtrOutputWithContext(context.Background()) +} + +func (o ProviderAppAuthOutput) ToProviderAppAuthPtrOutputWithContext(ctx context.Context) ProviderAppAuthPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v ProviderAppAuth) *ProviderAppAuth { + return &v + }).(ProviderAppAuthPtrOutput) +} + +// The GitHub App ID. +func (o ProviderAppAuthOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v ProviderAppAuth) string { return v.Id }).(pulumi.StringOutput) +} + +// The GitHub App installation instance ID. +func (o ProviderAppAuthOutput) InstallationId() pulumi.StringOutput { + return o.ApplyT(func(v ProviderAppAuth) string { return v.InstallationId }).(pulumi.StringOutput) +} + +// The GitHub App PEM file contents. +func (o ProviderAppAuthOutput) PemFile() pulumi.StringOutput { + return o.ApplyT(func(v ProviderAppAuth) string { return v.PemFile }).(pulumi.StringOutput) +} + +type ProviderAppAuthPtrOutput struct{ *pulumi.OutputState } + +func (ProviderAppAuthPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**ProviderAppAuth)(nil)).Elem() +} + +func (o ProviderAppAuthPtrOutput) ToProviderAppAuthPtrOutput() ProviderAppAuthPtrOutput { + return o +} + +func (o ProviderAppAuthPtrOutput) ToProviderAppAuthPtrOutputWithContext(ctx context.Context) ProviderAppAuthPtrOutput { + return o +} + +func (o ProviderAppAuthPtrOutput) Elem() ProviderAppAuthOutput { + return o.ApplyT(func(v *ProviderAppAuth) ProviderAppAuth { + if v != nil { + return *v + } + var ret ProviderAppAuth + return ret + }).(ProviderAppAuthOutput) +} + +// The GitHub App ID. +func (o ProviderAppAuthPtrOutput) Id() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ProviderAppAuth) *string { + if v == nil { + return nil + } + return &v.Id + }).(pulumi.StringPtrOutput) +} + +// The GitHub App installation instance ID. +func (o ProviderAppAuthPtrOutput) InstallationId() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ProviderAppAuth) *string { + if v == nil { + return nil + } + return &v.InstallationId + }).(pulumi.StringPtrOutput) +} + +// The GitHub App PEM file contents. +func (o ProviderAppAuthPtrOutput) PemFile() pulumi.StringPtrOutput { + return o.ApplyT(func(v *ProviderAppAuth) *string { + if v == nil { + return nil + } + return &v.PemFile + }).(pulumi.StringPtrOutput) +} + +type RepositoryCollaboratorsIgnoreTeam struct { + // The GitHub team id or the GitHub team slug. + TeamId string `pulumi:"teamId"` +} + +// RepositoryCollaboratorsIgnoreTeamInput is an input type that accepts RepositoryCollaboratorsIgnoreTeamArgs and RepositoryCollaboratorsIgnoreTeamOutput values. +// You can construct a concrete instance of `RepositoryCollaboratorsIgnoreTeamInput` via: +// +// RepositoryCollaboratorsIgnoreTeamArgs{...} +type RepositoryCollaboratorsIgnoreTeamInput interface { + pulumi.Input + + ToRepositoryCollaboratorsIgnoreTeamOutput() RepositoryCollaboratorsIgnoreTeamOutput + ToRepositoryCollaboratorsIgnoreTeamOutputWithContext(context.Context) RepositoryCollaboratorsIgnoreTeamOutput +} + +type RepositoryCollaboratorsIgnoreTeamArgs struct { + // The GitHub team id or the GitHub team slug. + TeamId pulumi.StringInput `pulumi:"teamId"` +} + +func (RepositoryCollaboratorsIgnoreTeamArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryCollaboratorsIgnoreTeam)(nil)).Elem() +} + +func (i RepositoryCollaboratorsIgnoreTeamArgs) ToRepositoryCollaboratorsIgnoreTeamOutput() RepositoryCollaboratorsIgnoreTeamOutput { + return i.ToRepositoryCollaboratorsIgnoreTeamOutputWithContext(context.Background()) +} + +func (i RepositoryCollaboratorsIgnoreTeamArgs) ToRepositoryCollaboratorsIgnoreTeamOutputWithContext(ctx context.Context) RepositoryCollaboratorsIgnoreTeamOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryCollaboratorsIgnoreTeamOutput) +} + +// RepositoryCollaboratorsIgnoreTeamArrayInput is an input type that accepts RepositoryCollaboratorsIgnoreTeamArray and RepositoryCollaboratorsIgnoreTeamArrayOutput values. +// You can construct a concrete instance of `RepositoryCollaboratorsIgnoreTeamArrayInput` via: +// +// RepositoryCollaboratorsIgnoreTeamArray{ RepositoryCollaboratorsIgnoreTeamArgs{...} } +type RepositoryCollaboratorsIgnoreTeamArrayInput interface { + pulumi.Input + + ToRepositoryCollaboratorsIgnoreTeamArrayOutput() RepositoryCollaboratorsIgnoreTeamArrayOutput + ToRepositoryCollaboratorsIgnoreTeamArrayOutputWithContext(context.Context) RepositoryCollaboratorsIgnoreTeamArrayOutput +} + +type RepositoryCollaboratorsIgnoreTeamArray []RepositoryCollaboratorsIgnoreTeamInput + +func (RepositoryCollaboratorsIgnoreTeamArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]RepositoryCollaboratorsIgnoreTeam)(nil)).Elem() +} + +func (i RepositoryCollaboratorsIgnoreTeamArray) ToRepositoryCollaboratorsIgnoreTeamArrayOutput() RepositoryCollaboratorsIgnoreTeamArrayOutput { + return i.ToRepositoryCollaboratorsIgnoreTeamArrayOutputWithContext(context.Background()) +} + +func (i RepositoryCollaboratorsIgnoreTeamArray) ToRepositoryCollaboratorsIgnoreTeamArrayOutputWithContext(ctx context.Context) RepositoryCollaboratorsIgnoreTeamArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryCollaboratorsIgnoreTeamArrayOutput) +} + +type RepositoryCollaboratorsIgnoreTeamOutput struct{ *pulumi.OutputState } + +func (RepositoryCollaboratorsIgnoreTeamOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryCollaboratorsIgnoreTeam)(nil)).Elem() +} + +func (o RepositoryCollaboratorsIgnoreTeamOutput) ToRepositoryCollaboratorsIgnoreTeamOutput() RepositoryCollaboratorsIgnoreTeamOutput { + return o +} + +func (o RepositoryCollaboratorsIgnoreTeamOutput) ToRepositoryCollaboratorsIgnoreTeamOutputWithContext(ctx context.Context) RepositoryCollaboratorsIgnoreTeamOutput { + return o +} + +// The GitHub team id or the GitHub team slug. +func (o RepositoryCollaboratorsIgnoreTeamOutput) TeamId() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryCollaboratorsIgnoreTeam) string { return v.TeamId }).(pulumi.StringOutput) +} + +type RepositoryCollaboratorsIgnoreTeamArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryCollaboratorsIgnoreTeamArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]RepositoryCollaboratorsIgnoreTeam)(nil)).Elem() +} + +func (o RepositoryCollaboratorsIgnoreTeamArrayOutput) ToRepositoryCollaboratorsIgnoreTeamArrayOutput() RepositoryCollaboratorsIgnoreTeamArrayOutput { + return o +} + +func (o RepositoryCollaboratorsIgnoreTeamArrayOutput) ToRepositoryCollaboratorsIgnoreTeamArrayOutputWithContext(ctx context.Context) RepositoryCollaboratorsIgnoreTeamArrayOutput { + return o +} + +func (o RepositoryCollaboratorsIgnoreTeamArrayOutput) Index(i pulumi.IntInput) RepositoryCollaboratorsIgnoreTeamOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) RepositoryCollaboratorsIgnoreTeam { + return vs[0].([]RepositoryCollaboratorsIgnoreTeam)[vs[1].(int)] + }).(RepositoryCollaboratorsIgnoreTeamOutput) +} + +type RepositoryCollaboratorsTeam struct { + // The permission of the outside collaborators for the repository. + // Must be one of `pull`, `triage`, `push`, `maintain`, `admin` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organisation. Defaults to `pull`. + // Must be `push` for personal repositories. Defaults to `push`. + Permission *string `pulumi:"permission"` + // The GitHub team id or the GitHub team slug. + TeamId string `pulumi:"teamId"` +} + +// RepositoryCollaboratorsTeamInput is an input type that accepts RepositoryCollaboratorsTeamArgs and RepositoryCollaboratorsTeamOutput values. +// You can construct a concrete instance of `RepositoryCollaboratorsTeamInput` via: +// +// RepositoryCollaboratorsTeamArgs{...} +type RepositoryCollaboratorsTeamInput interface { + pulumi.Input + + ToRepositoryCollaboratorsTeamOutput() RepositoryCollaboratorsTeamOutput + ToRepositoryCollaboratorsTeamOutputWithContext(context.Context) RepositoryCollaboratorsTeamOutput +} + +type RepositoryCollaboratorsTeamArgs struct { + // The permission of the outside collaborators for the repository. + // Must be one of `pull`, `triage`, `push`, `maintain`, `admin` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organisation. Defaults to `pull`. + // Must be `push` for personal repositories. Defaults to `push`. + Permission pulumi.StringPtrInput `pulumi:"permission"` + // The GitHub team id or the GitHub team slug. + TeamId pulumi.StringInput `pulumi:"teamId"` +} + +func (RepositoryCollaboratorsTeamArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryCollaboratorsTeam)(nil)).Elem() +} + +func (i RepositoryCollaboratorsTeamArgs) ToRepositoryCollaboratorsTeamOutput() RepositoryCollaboratorsTeamOutput { + return i.ToRepositoryCollaboratorsTeamOutputWithContext(context.Background()) +} + +func (i RepositoryCollaboratorsTeamArgs) ToRepositoryCollaboratorsTeamOutputWithContext(ctx context.Context) RepositoryCollaboratorsTeamOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryCollaboratorsTeamOutput) +} + +// RepositoryCollaboratorsTeamArrayInput is an input type that accepts RepositoryCollaboratorsTeamArray and RepositoryCollaboratorsTeamArrayOutput values. +// You can construct a concrete instance of `RepositoryCollaboratorsTeamArrayInput` via: +// +// RepositoryCollaboratorsTeamArray{ RepositoryCollaboratorsTeamArgs{...} } +type RepositoryCollaboratorsTeamArrayInput interface { + pulumi.Input + + ToRepositoryCollaboratorsTeamArrayOutput() RepositoryCollaboratorsTeamArrayOutput + ToRepositoryCollaboratorsTeamArrayOutputWithContext(context.Context) RepositoryCollaboratorsTeamArrayOutput +} + +type RepositoryCollaboratorsTeamArray []RepositoryCollaboratorsTeamInput + +func (RepositoryCollaboratorsTeamArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]RepositoryCollaboratorsTeam)(nil)).Elem() +} + +func (i RepositoryCollaboratorsTeamArray) ToRepositoryCollaboratorsTeamArrayOutput() RepositoryCollaboratorsTeamArrayOutput { + return i.ToRepositoryCollaboratorsTeamArrayOutputWithContext(context.Background()) +} + +func (i RepositoryCollaboratorsTeamArray) ToRepositoryCollaboratorsTeamArrayOutputWithContext(ctx context.Context) RepositoryCollaboratorsTeamArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryCollaboratorsTeamArrayOutput) +} + +type RepositoryCollaboratorsTeamOutput struct{ *pulumi.OutputState } + +func (RepositoryCollaboratorsTeamOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryCollaboratorsTeam)(nil)).Elem() +} + +func (o RepositoryCollaboratorsTeamOutput) ToRepositoryCollaboratorsTeamOutput() RepositoryCollaboratorsTeamOutput { + return o +} + +func (o RepositoryCollaboratorsTeamOutput) ToRepositoryCollaboratorsTeamOutputWithContext(ctx context.Context) RepositoryCollaboratorsTeamOutput { + return o +} + +// The permission of the outside collaborators for the repository. +// Must be one of `pull`, `triage`, `push`, `maintain`, `admin` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organisation. Defaults to `pull`. +// Must be `push` for personal repositories. Defaults to `push`. +func (o RepositoryCollaboratorsTeamOutput) Permission() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryCollaboratorsTeam) *string { return v.Permission }).(pulumi.StringPtrOutput) +} + +// The GitHub team id or the GitHub team slug. +func (o RepositoryCollaboratorsTeamOutput) TeamId() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryCollaboratorsTeam) string { return v.TeamId }).(pulumi.StringOutput) +} + +type RepositoryCollaboratorsTeamArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryCollaboratorsTeamArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]RepositoryCollaboratorsTeam)(nil)).Elem() +} + +func (o RepositoryCollaboratorsTeamArrayOutput) ToRepositoryCollaboratorsTeamArrayOutput() RepositoryCollaboratorsTeamArrayOutput { + return o +} + +func (o RepositoryCollaboratorsTeamArrayOutput) ToRepositoryCollaboratorsTeamArrayOutputWithContext(ctx context.Context) RepositoryCollaboratorsTeamArrayOutput { + return o +} + +func (o RepositoryCollaboratorsTeamArrayOutput) Index(i pulumi.IntInput) RepositoryCollaboratorsTeamOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) RepositoryCollaboratorsTeam { + return vs[0].([]RepositoryCollaboratorsTeam)[vs[1].(int)] + }).(RepositoryCollaboratorsTeamOutput) +} + +type RepositoryCollaboratorsUser struct { + // The permission of the outside collaborators for the repository. + // Must be one of `pull`, `push`, `maintain`, `triage` or `admin` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organization for organization-owned repositories. + // Must be `push` for personal repositories. Defaults to `push`. + Permission *string `pulumi:"permission"` + // The user to add to the repository as a collaborator. + Username string `pulumi:"username"` +} + +// RepositoryCollaboratorsUserInput is an input type that accepts RepositoryCollaboratorsUserArgs and RepositoryCollaboratorsUserOutput values. +// You can construct a concrete instance of `RepositoryCollaboratorsUserInput` via: +// +// RepositoryCollaboratorsUserArgs{...} +type RepositoryCollaboratorsUserInput interface { + pulumi.Input + + ToRepositoryCollaboratorsUserOutput() RepositoryCollaboratorsUserOutput + ToRepositoryCollaboratorsUserOutputWithContext(context.Context) RepositoryCollaboratorsUserOutput +} + +type RepositoryCollaboratorsUserArgs struct { + // The permission of the outside collaborators for the repository. + // Must be one of `pull`, `push`, `maintain`, `triage` or `admin` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organization for organization-owned repositories. + // Must be `push` for personal repositories. Defaults to `push`. + Permission pulumi.StringPtrInput `pulumi:"permission"` + // The user to add to the repository as a collaborator. + Username pulumi.StringInput `pulumi:"username"` +} + +func (RepositoryCollaboratorsUserArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryCollaboratorsUser)(nil)).Elem() +} + +func (i RepositoryCollaboratorsUserArgs) ToRepositoryCollaboratorsUserOutput() RepositoryCollaboratorsUserOutput { + return i.ToRepositoryCollaboratorsUserOutputWithContext(context.Background()) +} + +func (i RepositoryCollaboratorsUserArgs) ToRepositoryCollaboratorsUserOutputWithContext(ctx context.Context) RepositoryCollaboratorsUserOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryCollaboratorsUserOutput) +} + +// RepositoryCollaboratorsUserArrayInput is an input type that accepts RepositoryCollaboratorsUserArray and RepositoryCollaboratorsUserArrayOutput values. +// You can construct a concrete instance of `RepositoryCollaboratorsUserArrayInput` via: +// +// RepositoryCollaboratorsUserArray{ RepositoryCollaboratorsUserArgs{...} } +type RepositoryCollaboratorsUserArrayInput interface { + pulumi.Input + + ToRepositoryCollaboratorsUserArrayOutput() RepositoryCollaboratorsUserArrayOutput + ToRepositoryCollaboratorsUserArrayOutputWithContext(context.Context) RepositoryCollaboratorsUserArrayOutput +} + +type RepositoryCollaboratorsUserArray []RepositoryCollaboratorsUserInput + +func (RepositoryCollaboratorsUserArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]RepositoryCollaboratorsUser)(nil)).Elem() +} + +func (i RepositoryCollaboratorsUserArray) ToRepositoryCollaboratorsUserArrayOutput() RepositoryCollaboratorsUserArrayOutput { + return i.ToRepositoryCollaboratorsUserArrayOutputWithContext(context.Background()) +} + +func (i RepositoryCollaboratorsUserArray) ToRepositoryCollaboratorsUserArrayOutputWithContext(ctx context.Context) RepositoryCollaboratorsUserArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryCollaboratorsUserArrayOutput) +} + +type RepositoryCollaboratorsUserOutput struct{ *pulumi.OutputState } + +func (RepositoryCollaboratorsUserOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryCollaboratorsUser)(nil)).Elem() +} + +func (o RepositoryCollaboratorsUserOutput) ToRepositoryCollaboratorsUserOutput() RepositoryCollaboratorsUserOutput { + return o +} + +func (o RepositoryCollaboratorsUserOutput) ToRepositoryCollaboratorsUserOutputWithContext(ctx context.Context) RepositoryCollaboratorsUserOutput { + return o +} + +// The permission of the outside collaborators for the repository. +// Must be one of `pull`, `push`, `maintain`, `triage` or `admin` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organization for organization-owned repositories. +// Must be `push` for personal repositories. Defaults to `push`. +func (o RepositoryCollaboratorsUserOutput) Permission() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryCollaboratorsUser) *string { return v.Permission }).(pulumi.StringPtrOutput) +} + +// The user to add to the repository as a collaborator. +func (o RepositoryCollaboratorsUserOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryCollaboratorsUser) string { return v.Username }).(pulumi.StringOutput) +} + +type RepositoryCollaboratorsUserArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryCollaboratorsUserArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]RepositoryCollaboratorsUser)(nil)).Elem() +} + +func (o RepositoryCollaboratorsUserArrayOutput) ToRepositoryCollaboratorsUserArrayOutput() RepositoryCollaboratorsUserArrayOutput { + return o +} + +func (o RepositoryCollaboratorsUserArrayOutput) ToRepositoryCollaboratorsUserArrayOutputWithContext(ctx context.Context) RepositoryCollaboratorsUserArrayOutput { + return o +} + +func (o RepositoryCollaboratorsUserArrayOutput) Index(i pulumi.IntInput) RepositoryCollaboratorsUserOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) RepositoryCollaboratorsUser { + return vs[0].([]RepositoryCollaboratorsUser)[vs[1].(int)] + }).(RepositoryCollaboratorsUserOutput) +} + +type RepositoryEnvironmentDeploymentBranchPolicy struct { + // Whether only branches that match the specified name patterns can deploy to this environment. + CustomBranchPolicies bool `pulumi:"customBranchPolicies"` + // Whether only branches with branch protection rules can deploy to this environment. + ProtectedBranches bool `pulumi:"protectedBranches"` +} + +// RepositoryEnvironmentDeploymentBranchPolicyInput is an input type that accepts RepositoryEnvironmentDeploymentBranchPolicyArgs and RepositoryEnvironmentDeploymentBranchPolicyOutput values. +// You can construct a concrete instance of `RepositoryEnvironmentDeploymentBranchPolicyInput` via: +// +// RepositoryEnvironmentDeploymentBranchPolicyArgs{...} +type RepositoryEnvironmentDeploymentBranchPolicyInput interface { + pulumi.Input + + ToRepositoryEnvironmentDeploymentBranchPolicyOutput() RepositoryEnvironmentDeploymentBranchPolicyOutput + ToRepositoryEnvironmentDeploymentBranchPolicyOutputWithContext(context.Context) RepositoryEnvironmentDeploymentBranchPolicyOutput +} + +type RepositoryEnvironmentDeploymentBranchPolicyArgs struct { + // Whether only branches that match the specified name patterns can deploy to this environment. + CustomBranchPolicies pulumi.BoolInput `pulumi:"customBranchPolicies"` + // Whether only branches with branch protection rules can deploy to this environment. + ProtectedBranches pulumi.BoolInput `pulumi:"protectedBranches"` +} + +func (RepositoryEnvironmentDeploymentBranchPolicyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryEnvironmentDeploymentBranchPolicy)(nil)).Elem() +} + +func (i RepositoryEnvironmentDeploymentBranchPolicyArgs) ToRepositoryEnvironmentDeploymentBranchPolicyOutput() RepositoryEnvironmentDeploymentBranchPolicyOutput { + return i.ToRepositoryEnvironmentDeploymentBranchPolicyOutputWithContext(context.Background()) +} + +func (i RepositoryEnvironmentDeploymentBranchPolicyArgs) ToRepositoryEnvironmentDeploymentBranchPolicyOutputWithContext(ctx context.Context) RepositoryEnvironmentDeploymentBranchPolicyOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryEnvironmentDeploymentBranchPolicyOutput) +} + +func (i RepositoryEnvironmentDeploymentBranchPolicyArgs) ToRepositoryEnvironmentDeploymentBranchPolicyPtrOutput() RepositoryEnvironmentDeploymentBranchPolicyPtrOutput { + return i.ToRepositoryEnvironmentDeploymentBranchPolicyPtrOutputWithContext(context.Background()) +} + +func (i RepositoryEnvironmentDeploymentBranchPolicyArgs) ToRepositoryEnvironmentDeploymentBranchPolicyPtrOutputWithContext(ctx context.Context) RepositoryEnvironmentDeploymentBranchPolicyPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryEnvironmentDeploymentBranchPolicyOutput).ToRepositoryEnvironmentDeploymentBranchPolicyPtrOutputWithContext(ctx) +} + +// RepositoryEnvironmentDeploymentBranchPolicyPtrInput is an input type that accepts RepositoryEnvironmentDeploymentBranchPolicyArgs, RepositoryEnvironmentDeploymentBranchPolicyPtr and RepositoryEnvironmentDeploymentBranchPolicyPtrOutput values. +// You can construct a concrete instance of `RepositoryEnvironmentDeploymentBranchPolicyPtrInput` via: +// +// RepositoryEnvironmentDeploymentBranchPolicyArgs{...} +// +// or: +// +// nil +type RepositoryEnvironmentDeploymentBranchPolicyPtrInput interface { + pulumi.Input + + ToRepositoryEnvironmentDeploymentBranchPolicyPtrOutput() RepositoryEnvironmentDeploymentBranchPolicyPtrOutput + ToRepositoryEnvironmentDeploymentBranchPolicyPtrOutputWithContext(context.Context) RepositoryEnvironmentDeploymentBranchPolicyPtrOutput +} + +type repositoryEnvironmentDeploymentBranchPolicyPtrType RepositoryEnvironmentDeploymentBranchPolicyArgs + +func RepositoryEnvironmentDeploymentBranchPolicyPtr(v *RepositoryEnvironmentDeploymentBranchPolicyArgs) RepositoryEnvironmentDeploymentBranchPolicyPtrInput { + return (*repositoryEnvironmentDeploymentBranchPolicyPtrType)(v) +} + +func (*repositoryEnvironmentDeploymentBranchPolicyPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryEnvironmentDeploymentBranchPolicy)(nil)).Elem() +} + +func (i *repositoryEnvironmentDeploymentBranchPolicyPtrType) ToRepositoryEnvironmentDeploymentBranchPolicyPtrOutput() RepositoryEnvironmentDeploymentBranchPolicyPtrOutput { + return i.ToRepositoryEnvironmentDeploymentBranchPolicyPtrOutputWithContext(context.Background()) +} + +func (i *repositoryEnvironmentDeploymentBranchPolicyPtrType) ToRepositoryEnvironmentDeploymentBranchPolicyPtrOutputWithContext(ctx context.Context) RepositoryEnvironmentDeploymentBranchPolicyPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryEnvironmentDeploymentBranchPolicyPtrOutput) +} + +type RepositoryEnvironmentDeploymentBranchPolicyOutput struct{ *pulumi.OutputState } + +func (RepositoryEnvironmentDeploymentBranchPolicyOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryEnvironmentDeploymentBranchPolicy)(nil)).Elem() +} + +func (o RepositoryEnvironmentDeploymentBranchPolicyOutput) ToRepositoryEnvironmentDeploymentBranchPolicyOutput() RepositoryEnvironmentDeploymentBranchPolicyOutput { + return o +} + +func (o RepositoryEnvironmentDeploymentBranchPolicyOutput) ToRepositoryEnvironmentDeploymentBranchPolicyOutputWithContext(ctx context.Context) RepositoryEnvironmentDeploymentBranchPolicyOutput { + return o +} + +func (o RepositoryEnvironmentDeploymentBranchPolicyOutput) ToRepositoryEnvironmentDeploymentBranchPolicyPtrOutput() RepositoryEnvironmentDeploymentBranchPolicyPtrOutput { + return o.ToRepositoryEnvironmentDeploymentBranchPolicyPtrOutputWithContext(context.Background()) +} + +func (o RepositoryEnvironmentDeploymentBranchPolicyOutput) ToRepositoryEnvironmentDeploymentBranchPolicyPtrOutputWithContext(ctx context.Context) RepositoryEnvironmentDeploymentBranchPolicyPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryEnvironmentDeploymentBranchPolicy) *RepositoryEnvironmentDeploymentBranchPolicy { + return &v + }).(RepositoryEnvironmentDeploymentBranchPolicyPtrOutput) +} + +// Whether only branches that match the specified name patterns can deploy to this environment. +func (o RepositoryEnvironmentDeploymentBranchPolicyOutput) CustomBranchPolicies() pulumi.BoolOutput { + return o.ApplyT(func(v RepositoryEnvironmentDeploymentBranchPolicy) bool { return v.CustomBranchPolicies }).(pulumi.BoolOutput) +} + +// Whether only branches with branch protection rules can deploy to this environment. +func (o RepositoryEnvironmentDeploymentBranchPolicyOutput) ProtectedBranches() pulumi.BoolOutput { + return o.ApplyT(func(v RepositoryEnvironmentDeploymentBranchPolicy) bool { return v.ProtectedBranches }).(pulumi.BoolOutput) +} + +type RepositoryEnvironmentDeploymentBranchPolicyPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryEnvironmentDeploymentBranchPolicyPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryEnvironmentDeploymentBranchPolicy)(nil)).Elem() +} + +func (o RepositoryEnvironmentDeploymentBranchPolicyPtrOutput) ToRepositoryEnvironmentDeploymentBranchPolicyPtrOutput() RepositoryEnvironmentDeploymentBranchPolicyPtrOutput { + return o +} + +func (o RepositoryEnvironmentDeploymentBranchPolicyPtrOutput) ToRepositoryEnvironmentDeploymentBranchPolicyPtrOutputWithContext(ctx context.Context) RepositoryEnvironmentDeploymentBranchPolicyPtrOutput { + return o +} + +func (o RepositoryEnvironmentDeploymentBranchPolicyPtrOutput) Elem() RepositoryEnvironmentDeploymentBranchPolicyOutput { + return o.ApplyT(func(v *RepositoryEnvironmentDeploymentBranchPolicy) RepositoryEnvironmentDeploymentBranchPolicy { + if v != nil { + return *v + } + var ret RepositoryEnvironmentDeploymentBranchPolicy + return ret + }).(RepositoryEnvironmentDeploymentBranchPolicyOutput) +} + +// Whether only branches that match the specified name patterns can deploy to this environment. +func (o RepositoryEnvironmentDeploymentBranchPolicyPtrOutput) CustomBranchPolicies() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryEnvironmentDeploymentBranchPolicy) *bool { + if v == nil { + return nil + } + return &v.CustomBranchPolicies + }).(pulumi.BoolPtrOutput) +} + +// Whether only branches with branch protection rules can deploy to this environment. +func (o RepositoryEnvironmentDeploymentBranchPolicyPtrOutput) ProtectedBranches() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryEnvironmentDeploymentBranchPolicy) *bool { + if v == nil { + return nil + } + return &v.ProtectedBranches + }).(pulumi.BoolPtrOutput) +} + +type RepositoryEnvironmentReviewer struct { + // Up to 6 IDs for teams who may review jobs that reference the environment. Reviewers must have at least read access to the repository. Only one of the required reviewers needs to approve the job for it to proceed. + Teams []int `pulumi:"teams"` + // Up to 6 IDs for users who may review jobs that reference the environment. Reviewers must have at least read access to the repository. Only one of the required reviewers needs to approve the job for it to proceed. + Users []int `pulumi:"users"` +} + +// RepositoryEnvironmentReviewerInput is an input type that accepts RepositoryEnvironmentReviewerArgs and RepositoryEnvironmentReviewerOutput values. +// You can construct a concrete instance of `RepositoryEnvironmentReviewerInput` via: +// +// RepositoryEnvironmentReviewerArgs{...} +type RepositoryEnvironmentReviewerInput interface { + pulumi.Input + + ToRepositoryEnvironmentReviewerOutput() RepositoryEnvironmentReviewerOutput + ToRepositoryEnvironmentReviewerOutputWithContext(context.Context) RepositoryEnvironmentReviewerOutput +} + +type RepositoryEnvironmentReviewerArgs struct { + // Up to 6 IDs for teams who may review jobs that reference the environment. Reviewers must have at least read access to the repository. Only one of the required reviewers needs to approve the job for it to proceed. + Teams pulumi.IntArrayInput `pulumi:"teams"` + // Up to 6 IDs for users who may review jobs that reference the environment. Reviewers must have at least read access to the repository. Only one of the required reviewers needs to approve the job for it to proceed. + Users pulumi.IntArrayInput `pulumi:"users"` +} + +func (RepositoryEnvironmentReviewerArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryEnvironmentReviewer)(nil)).Elem() +} + +func (i RepositoryEnvironmentReviewerArgs) ToRepositoryEnvironmentReviewerOutput() RepositoryEnvironmentReviewerOutput { + return i.ToRepositoryEnvironmentReviewerOutputWithContext(context.Background()) +} + +func (i RepositoryEnvironmentReviewerArgs) ToRepositoryEnvironmentReviewerOutputWithContext(ctx context.Context) RepositoryEnvironmentReviewerOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryEnvironmentReviewerOutput) +} + +// RepositoryEnvironmentReviewerArrayInput is an input type that accepts RepositoryEnvironmentReviewerArray and RepositoryEnvironmentReviewerArrayOutput values. +// You can construct a concrete instance of `RepositoryEnvironmentReviewerArrayInput` via: +// +// RepositoryEnvironmentReviewerArray{ RepositoryEnvironmentReviewerArgs{...} } +type RepositoryEnvironmentReviewerArrayInput interface { + pulumi.Input + + ToRepositoryEnvironmentReviewerArrayOutput() RepositoryEnvironmentReviewerArrayOutput + ToRepositoryEnvironmentReviewerArrayOutputWithContext(context.Context) RepositoryEnvironmentReviewerArrayOutput +} + +type RepositoryEnvironmentReviewerArray []RepositoryEnvironmentReviewerInput + +func (RepositoryEnvironmentReviewerArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]RepositoryEnvironmentReviewer)(nil)).Elem() +} + +func (i RepositoryEnvironmentReviewerArray) ToRepositoryEnvironmentReviewerArrayOutput() RepositoryEnvironmentReviewerArrayOutput { + return i.ToRepositoryEnvironmentReviewerArrayOutputWithContext(context.Background()) +} + +func (i RepositoryEnvironmentReviewerArray) ToRepositoryEnvironmentReviewerArrayOutputWithContext(ctx context.Context) RepositoryEnvironmentReviewerArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryEnvironmentReviewerArrayOutput) +} + +type RepositoryEnvironmentReviewerOutput struct{ *pulumi.OutputState } + +func (RepositoryEnvironmentReviewerOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryEnvironmentReviewer)(nil)).Elem() +} + +func (o RepositoryEnvironmentReviewerOutput) ToRepositoryEnvironmentReviewerOutput() RepositoryEnvironmentReviewerOutput { + return o +} + +func (o RepositoryEnvironmentReviewerOutput) ToRepositoryEnvironmentReviewerOutputWithContext(ctx context.Context) RepositoryEnvironmentReviewerOutput { + return o +} + +// Up to 6 IDs for teams who may review jobs that reference the environment. Reviewers must have at least read access to the repository. Only one of the required reviewers needs to approve the job for it to proceed. +func (o RepositoryEnvironmentReviewerOutput) Teams() pulumi.IntArrayOutput { + return o.ApplyT(func(v RepositoryEnvironmentReviewer) []int { return v.Teams }).(pulumi.IntArrayOutput) +} + +// Up to 6 IDs for users who may review jobs that reference the environment. Reviewers must have at least read access to the repository. Only one of the required reviewers needs to approve the job for it to proceed. +func (o RepositoryEnvironmentReviewerOutput) Users() pulumi.IntArrayOutput { + return o.ApplyT(func(v RepositoryEnvironmentReviewer) []int { return v.Users }).(pulumi.IntArrayOutput) +} + +type RepositoryEnvironmentReviewerArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryEnvironmentReviewerArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]RepositoryEnvironmentReviewer)(nil)).Elem() +} + +func (o RepositoryEnvironmentReviewerArrayOutput) ToRepositoryEnvironmentReviewerArrayOutput() RepositoryEnvironmentReviewerArrayOutput { + return o +} + +func (o RepositoryEnvironmentReviewerArrayOutput) ToRepositoryEnvironmentReviewerArrayOutputWithContext(ctx context.Context) RepositoryEnvironmentReviewerArrayOutput { + return o +} + +func (o RepositoryEnvironmentReviewerArrayOutput) Index(i pulumi.IntInput) RepositoryEnvironmentReviewerOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) RepositoryEnvironmentReviewer { + return vs[0].([]RepositoryEnvironmentReviewer)[vs[1].(int)] + }).(RepositoryEnvironmentReviewerOutput) +} + +type RepositoryPagesType struct { + // The type of GitHub Pages site to build. Can be `legacy` or `workflow`. If you use `legacy` as build type you need to set the option `source`. + BuildType *string `pulumi:"buildType"` + // The custom domain for the repository. This can only be set after the repository has been created. + Cname *string `pulumi:"cname"` + // Whether the rendered GitHub Pages site has a custom 404 page. + Custom404 *bool `pulumi:"custom404"` + // The absolute URL (including scheme) of the rendered GitHub Pages site e.g. `https://username.github.io`. + HtmlUrl *string `pulumi:"htmlUrl"` + // The source branch and directory for the rendered Pages site. See GitHub Pages Source below for details. + Source *RepositoryPagesSource `pulumi:"source"` + // The GitHub Pages site's build status e.g. `building` or `built`. + Status *string `pulumi:"status"` + Url *string `pulumi:"url"` +} + +// RepositoryPagesTypeInput is an input type that accepts RepositoryPagesTypeArgs and RepositoryPagesTypeOutput values. +// You can construct a concrete instance of `RepositoryPagesTypeInput` via: +// +// RepositoryPagesTypeArgs{...} +type RepositoryPagesTypeInput interface { + pulumi.Input + + ToRepositoryPagesTypeOutput() RepositoryPagesTypeOutput + ToRepositoryPagesTypeOutputWithContext(context.Context) RepositoryPagesTypeOutput +} + +type RepositoryPagesTypeArgs struct { + // The type of GitHub Pages site to build. Can be `legacy` or `workflow`. If you use `legacy` as build type you need to set the option `source`. + BuildType pulumi.StringPtrInput `pulumi:"buildType"` + // The custom domain for the repository. This can only be set after the repository has been created. + Cname pulumi.StringPtrInput `pulumi:"cname"` + // Whether the rendered GitHub Pages site has a custom 404 page. + Custom404 pulumi.BoolPtrInput `pulumi:"custom404"` + // The absolute URL (including scheme) of the rendered GitHub Pages site e.g. `https://username.github.io`. + HtmlUrl pulumi.StringPtrInput `pulumi:"htmlUrl"` + // The source branch and directory for the rendered Pages site. See GitHub Pages Source below for details. + Source RepositoryPagesSourcePtrInput `pulumi:"source"` + // The GitHub Pages site's build status e.g. `building` or `built`. + Status pulumi.StringPtrInput `pulumi:"status"` + Url pulumi.StringPtrInput `pulumi:"url"` +} + +func (RepositoryPagesTypeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryPagesType)(nil)).Elem() +} + +func (i RepositoryPagesTypeArgs) ToRepositoryPagesTypeOutput() RepositoryPagesTypeOutput { + return i.ToRepositoryPagesTypeOutputWithContext(context.Background()) +} + +func (i RepositoryPagesTypeArgs) ToRepositoryPagesTypeOutputWithContext(ctx context.Context) RepositoryPagesTypeOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryPagesTypeOutput) +} + +func (i RepositoryPagesTypeArgs) ToRepositoryPagesTypePtrOutput() RepositoryPagesTypePtrOutput { + return i.ToRepositoryPagesTypePtrOutputWithContext(context.Background()) +} + +func (i RepositoryPagesTypeArgs) ToRepositoryPagesTypePtrOutputWithContext(ctx context.Context) RepositoryPagesTypePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryPagesTypeOutput).ToRepositoryPagesTypePtrOutputWithContext(ctx) +} + +// RepositoryPagesTypePtrInput is an input type that accepts RepositoryPagesTypeArgs, RepositoryPagesTypePtr and RepositoryPagesTypePtrOutput values. +// You can construct a concrete instance of `RepositoryPagesTypePtrInput` via: +// +// RepositoryPagesTypeArgs{...} +// +// or: +// +// nil +type RepositoryPagesTypePtrInput interface { + pulumi.Input + + ToRepositoryPagesTypePtrOutput() RepositoryPagesTypePtrOutput + ToRepositoryPagesTypePtrOutputWithContext(context.Context) RepositoryPagesTypePtrOutput +} + +type repositoryPagesTypePtrType RepositoryPagesTypeArgs + +func RepositoryPagesTypePtr(v *RepositoryPagesTypeArgs) RepositoryPagesTypePtrInput { + return (*repositoryPagesTypePtrType)(v) +} + +func (*repositoryPagesTypePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryPagesType)(nil)).Elem() +} + +func (i *repositoryPagesTypePtrType) ToRepositoryPagesTypePtrOutput() RepositoryPagesTypePtrOutput { + return i.ToRepositoryPagesTypePtrOutputWithContext(context.Background()) +} + +func (i *repositoryPagesTypePtrType) ToRepositoryPagesTypePtrOutputWithContext(ctx context.Context) RepositoryPagesTypePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryPagesTypePtrOutput) +} + +type RepositoryPagesTypeOutput struct{ *pulumi.OutputState } + +func (RepositoryPagesTypeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryPagesType)(nil)).Elem() +} + +func (o RepositoryPagesTypeOutput) ToRepositoryPagesTypeOutput() RepositoryPagesTypeOutput { + return o +} + +func (o RepositoryPagesTypeOutput) ToRepositoryPagesTypeOutputWithContext(ctx context.Context) RepositoryPagesTypeOutput { + return o +} + +func (o RepositoryPagesTypeOutput) ToRepositoryPagesTypePtrOutput() RepositoryPagesTypePtrOutput { + return o.ToRepositoryPagesTypePtrOutputWithContext(context.Background()) +} + +func (o RepositoryPagesTypeOutput) ToRepositoryPagesTypePtrOutputWithContext(ctx context.Context) RepositoryPagesTypePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryPagesType) *RepositoryPagesType { + return &v + }).(RepositoryPagesTypePtrOutput) +} + +// The type of GitHub Pages site to build. Can be `legacy` or `workflow`. If you use `legacy` as build type you need to set the option `source`. +func (o RepositoryPagesTypeOutput) BuildType() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryPagesType) *string { return v.BuildType }).(pulumi.StringPtrOutput) +} + +// The custom domain for the repository. This can only be set after the repository has been created. +func (o RepositoryPagesTypeOutput) Cname() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryPagesType) *string { return v.Cname }).(pulumi.StringPtrOutput) +} + +// Whether the rendered GitHub Pages site has a custom 404 page. +func (o RepositoryPagesTypeOutput) Custom404() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryPagesType) *bool { return v.Custom404 }).(pulumi.BoolPtrOutput) +} + +// The absolute URL (including scheme) of the rendered GitHub Pages site e.g. `https://username.github.io`. +func (o RepositoryPagesTypeOutput) HtmlUrl() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryPagesType) *string { return v.HtmlUrl }).(pulumi.StringPtrOutput) +} + +// The source branch and directory for the rendered Pages site. See GitHub Pages Source below for details. +func (o RepositoryPagesTypeOutput) Source() RepositoryPagesSourcePtrOutput { + return o.ApplyT(func(v RepositoryPagesType) *RepositoryPagesSource { return v.Source }).(RepositoryPagesSourcePtrOutput) +} + +// The GitHub Pages site's build status e.g. `building` or `built`. +func (o RepositoryPagesTypeOutput) Status() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryPagesType) *string { return v.Status }).(pulumi.StringPtrOutput) +} + +func (o RepositoryPagesTypeOutput) Url() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryPagesType) *string { return v.Url }).(pulumi.StringPtrOutput) +} + +type RepositoryPagesTypePtrOutput struct{ *pulumi.OutputState } + +func (RepositoryPagesTypePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryPagesType)(nil)).Elem() +} + +func (o RepositoryPagesTypePtrOutput) ToRepositoryPagesTypePtrOutput() RepositoryPagesTypePtrOutput { + return o +} + +func (o RepositoryPagesTypePtrOutput) ToRepositoryPagesTypePtrOutputWithContext(ctx context.Context) RepositoryPagesTypePtrOutput { + return o +} + +func (o RepositoryPagesTypePtrOutput) Elem() RepositoryPagesTypeOutput { + return o.ApplyT(func(v *RepositoryPagesType) RepositoryPagesType { + if v != nil { + return *v + } + var ret RepositoryPagesType + return ret + }).(RepositoryPagesTypeOutput) +} + +// The type of GitHub Pages site to build. Can be `legacy` or `workflow`. If you use `legacy` as build type you need to set the option `source`. +func (o RepositoryPagesTypePtrOutput) BuildType() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryPagesType) *string { + if v == nil { + return nil + } + return v.BuildType + }).(pulumi.StringPtrOutput) +} + +// The custom domain for the repository. This can only be set after the repository has been created. +func (o RepositoryPagesTypePtrOutput) Cname() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryPagesType) *string { + if v == nil { + return nil + } + return v.Cname + }).(pulumi.StringPtrOutput) +} + +// Whether the rendered GitHub Pages site has a custom 404 page. +func (o RepositoryPagesTypePtrOutput) Custom404() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryPagesType) *bool { + if v == nil { + return nil + } + return v.Custom404 + }).(pulumi.BoolPtrOutput) +} + +// The absolute URL (including scheme) of the rendered GitHub Pages site e.g. `https://username.github.io`. +func (o RepositoryPagesTypePtrOutput) HtmlUrl() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryPagesType) *string { + if v == nil { + return nil + } + return v.HtmlUrl + }).(pulumi.StringPtrOutput) +} + +// The source branch and directory for the rendered Pages site. See GitHub Pages Source below for details. +func (o RepositoryPagesTypePtrOutput) Source() RepositoryPagesSourcePtrOutput { + return o.ApplyT(func(v *RepositoryPagesType) *RepositoryPagesSource { + if v == nil { + return nil + } + return v.Source + }).(RepositoryPagesSourcePtrOutput) +} + +// The GitHub Pages site's build status e.g. `building` or `built`. +func (o RepositoryPagesTypePtrOutput) Status() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryPagesType) *string { + if v == nil { + return nil + } + return v.Status + }).(pulumi.StringPtrOutput) +} + +func (o RepositoryPagesTypePtrOutput) Url() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryPagesType) *string { + if v == nil { + return nil + } + return v.Url + }).(pulumi.StringPtrOutput) +} + +type RepositoryPagesSource struct { + // The repository branch used to publish the site's source files (e.g., `main` or `gh-pages`). + Branch string `pulumi:"branch"` + // The repository directory from which the site publishes. Defaults to `/`. Can be `/` or `/docs`. + Path *string `pulumi:"path"` +} + +// RepositoryPagesSourceInput is an input type that accepts RepositoryPagesSourceArgs and RepositoryPagesSourceOutput values. +// You can construct a concrete instance of `RepositoryPagesSourceInput` via: +// +// RepositoryPagesSourceArgs{...} +type RepositoryPagesSourceInput interface { + pulumi.Input + + ToRepositoryPagesSourceOutput() RepositoryPagesSourceOutput + ToRepositoryPagesSourceOutputWithContext(context.Context) RepositoryPagesSourceOutput +} + +type RepositoryPagesSourceArgs struct { + // The repository branch used to publish the site's source files (e.g., `main` or `gh-pages`). + Branch pulumi.StringInput `pulumi:"branch"` + // The repository directory from which the site publishes. Defaults to `/`. Can be `/` or `/docs`. + Path pulumi.StringPtrInput `pulumi:"path"` +} + +func (RepositoryPagesSourceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryPagesSource)(nil)).Elem() +} + +func (i RepositoryPagesSourceArgs) ToRepositoryPagesSourceOutput() RepositoryPagesSourceOutput { + return i.ToRepositoryPagesSourceOutputWithContext(context.Background()) +} + +func (i RepositoryPagesSourceArgs) ToRepositoryPagesSourceOutputWithContext(ctx context.Context) RepositoryPagesSourceOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryPagesSourceOutput) +} + +func (i RepositoryPagesSourceArgs) ToRepositoryPagesSourcePtrOutput() RepositoryPagesSourcePtrOutput { + return i.ToRepositoryPagesSourcePtrOutputWithContext(context.Background()) +} + +func (i RepositoryPagesSourceArgs) ToRepositoryPagesSourcePtrOutputWithContext(ctx context.Context) RepositoryPagesSourcePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryPagesSourceOutput).ToRepositoryPagesSourcePtrOutputWithContext(ctx) +} + +// RepositoryPagesSourcePtrInput is an input type that accepts RepositoryPagesSourceArgs, RepositoryPagesSourcePtr and RepositoryPagesSourcePtrOutput values. +// You can construct a concrete instance of `RepositoryPagesSourcePtrInput` via: +// +// RepositoryPagesSourceArgs{...} +// +// or: +// +// nil +type RepositoryPagesSourcePtrInput interface { + pulumi.Input + + ToRepositoryPagesSourcePtrOutput() RepositoryPagesSourcePtrOutput + ToRepositoryPagesSourcePtrOutputWithContext(context.Context) RepositoryPagesSourcePtrOutput +} + +type repositoryPagesSourcePtrType RepositoryPagesSourceArgs + +func RepositoryPagesSourcePtr(v *RepositoryPagesSourceArgs) RepositoryPagesSourcePtrInput { + return (*repositoryPagesSourcePtrType)(v) +} + +func (*repositoryPagesSourcePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryPagesSource)(nil)).Elem() +} + +func (i *repositoryPagesSourcePtrType) ToRepositoryPagesSourcePtrOutput() RepositoryPagesSourcePtrOutput { + return i.ToRepositoryPagesSourcePtrOutputWithContext(context.Background()) +} + +func (i *repositoryPagesSourcePtrType) ToRepositoryPagesSourcePtrOutputWithContext(ctx context.Context) RepositoryPagesSourcePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryPagesSourcePtrOutput) +} + +type RepositoryPagesSourceOutput struct{ *pulumi.OutputState } + +func (RepositoryPagesSourceOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryPagesSource)(nil)).Elem() +} + +func (o RepositoryPagesSourceOutput) ToRepositoryPagesSourceOutput() RepositoryPagesSourceOutput { + return o +} + +func (o RepositoryPagesSourceOutput) ToRepositoryPagesSourceOutputWithContext(ctx context.Context) RepositoryPagesSourceOutput { + return o +} + +func (o RepositoryPagesSourceOutput) ToRepositoryPagesSourcePtrOutput() RepositoryPagesSourcePtrOutput { + return o.ToRepositoryPagesSourcePtrOutputWithContext(context.Background()) +} + +func (o RepositoryPagesSourceOutput) ToRepositoryPagesSourcePtrOutputWithContext(ctx context.Context) RepositoryPagesSourcePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryPagesSource) *RepositoryPagesSource { + return &v + }).(RepositoryPagesSourcePtrOutput) +} + +// The repository branch used to publish the site's source files (e.g., `main` or `gh-pages`). +func (o RepositoryPagesSourceOutput) Branch() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryPagesSource) string { return v.Branch }).(pulumi.StringOutput) +} + +// The repository directory from which the site publishes. Defaults to `/`. Can be `/` or `/docs`. +func (o RepositoryPagesSourceOutput) Path() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryPagesSource) *string { return v.Path }).(pulumi.StringPtrOutput) +} + +type RepositoryPagesSourcePtrOutput struct{ *pulumi.OutputState } + +func (RepositoryPagesSourcePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryPagesSource)(nil)).Elem() +} + +func (o RepositoryPagesSourcePtrOutput) ToRepositoryPagesSourcePtrOutput() RepositoryPagesSourcePtrOutput { + return o +} + +func (o RepositoryPagesSourcePtrOutput) ToRepositoryPagesSourcePtrOutputWithContext(ctx context.Context) RepositoryPagesSourcePtrOutput { + return o +} + +func (o RepositoryPagesSourcePtrOutput) Elem() RepositoryPagesSourceOutput { + return o.ApplyT(func(v *RepositoryPagesSource) RepositoryPagesSource { + if v != nil { + return *v + } + var ret RepositoryPagesSource + return ret + }).(RepositoryPagesSourceOutput) +} + +// The repository branch used to publish the site's source files (e.g., `main` or `gh-pages`). +func (o RepositoryPagesSourcePtrOutput) Branch() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryPagesSource) *string { + if v == nil { + return nil + } + return &v.Branch + }).(pulumi.StringPtrOutput) +} + +// The repository directory from which the site publishes. Defaults to `/`. Can be `/` or `/docs`. +func (o RepositoryPagesSourcePtrOutput) Path() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryPagesSource) *string { + if v == nil { + return nil + } + return v.Path + }).(pulumi.StringPtrOutput) +} + +type RepositoryRulesetBypassActor struct { + // (Number) The ID of the actor that can bypass a ruleset. If `actorType` is `Integration`, `actorId` is a GitHub App ID. App ID can be obtained by following instructions from the [Get an App API docs](https://docs.github.com/en/rest/apps/apps?apiVersion=2022-11-28#get-an-app). Some actor types such as `DeployKey` do not have an ID. + ActorId *int `pulumi:"actorId"` + // The type of actor that can bypass a ruleset. Can be one of: `RepositoryRole`, `Team`, `Integration`, `OrganizationAdmin`, `DeployKey`. + ActorType string `pulumi:"actorType"` + // (String) When the specified actor can bypass the ruleset. pullRequest means that an actor can only bypass rules on pull requests. Can be one of: `always`, `pullRequest`, `exempt`. + // + // > Note: at the time of writing this, the following actor types correspond to the following actor IDs: + // + // - `OrganizationAdmin` > `1` + // - `RepositoryRole` (This is the actor type, the following are the base repository roles and their associated IDs.) + BypassMode string `pulumi:"bypassMode"` +} + +// RepositoryRulesetBypassActorInput is an input type that accepts RepositoryRulesetBypassActorArgs and RepositoryRulesetBypassActorOutput values. +// You can construct a concrete instance of `RepositoryRulesetBypassActorInput` via: +// +// RepositoryRulesetBypassActorArgs{...} +type RepositoryRulesetBypassActorInput interface { + pulumi.Input + + ToRepositoryRulesetBypassActorOutput() RepositoryRulesetBypassActorOutput + ToRepositoryRulesetBypassActorOutputWithContext(context.Context) RepositoryRulesetBypassActorOutput +} + +type RepositoryRulesetBypassActorArgs struct { + // (Number) The ID of the actor that can bypass a ruleset. If `actorType` is `Integration`, `actorId` is a GitHub App ID. App ID can be obtained by following instructions from the [Get an App API docs](https://docs.github.com/en/rest/apps/apps?apiVersion=2022-11-28#get-an-app). Some actor types such as `DeployKey` do not have an ID. + ActorId pulumi.IntPtrInput `pulumi:"actorId"` + // The type of actor that can bypass a ruleset. Can be one of: `RepositoryRole`, `Team`, `Integration`, `OrganizationAdmin`, `DeployKey`. + ActorType pulumi.StringInput `pulumi:"actorType"` + // (String) When the specified actor can bypass the ruleset. pullRequest means that an actor can only bypass rules on pull requests. Can be one of: `always`, `pullRequest`, `exempt`. + // + // > Note: at the time of writing this, the following actor types correspond to the following actor IDs: + // + // - `OrganizationAdmin` > `1` + // - `RepositoryRole` (This is the actor type, the following are the base repository roles and their associated IDs.) + BypassMode pulumi.StringInput `pulumi:"bypassMode"` +} + +func (RepositoryRulesetBypassActorArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetBypassActor)(nil)).Elem() +} + +func (i RepositoryRulesetBypassActorArgs) ToRepositoryRulesetBypassActorOutput() RepositoryRulesetBypassActorOutput { + return i.ToRepositoryRulesetBypassActorOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetBypassActorArgs) ToRepositoryRulesetBypassActorOutputWithContext(ctx context.Context) RepositoryRulesetBypassActorOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetBypassActorOutput) +} + +// RepositoryRulesetBypassActorArrayInput is an input type that accepts RepositoryRulesetBypassActorArray and RepositoryRulesetBypassActorArrayOutput values. +// You can construct a concrete instance of `RepositoryRulesetBypassActorArrayInput` via: +// +// RepositoryRulesetBypassActorArray{ RepositoryRulesetBypassActorArgs{...} } +type RepositoryRulesetBypassActorArrayInput interface { + pulumi.Input + + ToRepositoryRulesetBypassActorArrayOutput() RepositoryRulesetBypassActorArrayOutput + ToRepositoryRulesetBypassActorArrayOutputWithContext(context.Context) RepositoryRulesetBypassActorArrayOutput +} + +type RepositoryRulesetBypassActorArray []RepositoryRulesetBypassActorInput + +func (RepositoryRulesetBypassActorArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]RepositoryRulesetBypassActor)(nil)).Elem() +} + +func (i RepositoryRulesetBypassActorArray) ToRepositoryRulesetBypassActorArrayOutput() RepositoryRulesetBypassActorArrayOutput { + return i.ToRepositoryRulesetBypassActorArrayOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetBypassActorArray) ToRepositoryRulesetBypassActorArrayOutputWithContext(ctx context.Context) RepositoryRulesetBypassActorArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetBypassActorArrayOutput) +} + +type RepositoryRulesetBypassActorOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetBypassActorOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetBypassActor)(nil)).Elem() +} + +func (o RepositoryRulesetBypassActorOutput) ToRepositoryRulesetBypassActorOutput() RepositoryRulesetBypassActorOutput { + return o +} + +func (o RepositoryRulesetBypassActorOutput) ToRepositoryRulesetBypassActorOutputWithContext(ctx context.Context) RepositoryRulesetBypassActorOutput { + return o +} + +// (Number) The ID of the actor that can bypass a ruleset. If `actorType` is `Integration`, `actorId` is a GitHub App ID. App ID can be obtained by following instructions from the [Get an App API docs](https://docs.github.com/en/rest/apps/apps?apiVersion=2022-11-28#get-an-app). Some actor types such as `DeployKey` do not have an ID. +func (o RepositoryRulesetBypassActorOutput) ActorId() pulumi.IntPtrOutput { + return o.ApplyT(func(v RepositoryRulesetBypassActor) *int { return v.ActorId }).(pulumi.IntPtrOutput) +} + +// The type of actor that can bypass a ruleset. Can be one of: `RepositoryRole`, `Team`, `Integration`, `OrganizationAdmin`, `DeployKey`. +func (o RepositoryRulesetBypassActorOutput) ActorType() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetBypassActor) string { return v.ActorType }).(pulumi.StringOutput) +} + +// (String) When the specified actor can bypass the ruleset. pullRequest means that an actor can only bypass rules on pull requests. Can be one of: `always`, `pullRequest`, `exempt`. +// +// > Note: at the time of writing this, the following actor types correspond to the following actor IDs: +// +// - `OrganizationAdmin` > `1` +// - `RepositoryRole` (This is the actor type, the following are the base repository roles and their associated IDs.) +func (o RepositoryRulesetBypassActorOutput) BypassMode() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetBypassActor) string { return v.BypassMode }).(pulumi.StringOutput) +} + +type RepositoryRulesetBypassActorArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetBypassActorArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]RepositoryRulesetBypassActor)(nil)).Elem() +} + +func (o RepositoryRulesetBypassActorArrayOutput) ToRepositoryRulesetBypassActorArrayOutput() RepositoryRulesetBypassActorArrayOutput { + return o +} + +func (o RepositoryRulesetBypassActorArrayOutput) ToRepositoryRulesetBypassActorArrayOutputWithContext(ctx context.Context) RepositoryRulesetBypassActorArrayOutput { + return o +} + +func (o RepositoryRulesetBypassActorArrayOutput) Index(i pulumi.IntInput) RepositoryRulesetBypassActorOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) RepositoryRulesetBypassActor { + return vs[0].([]RepositoryRulesetBypassActor)[vs[1].(int)] + }).(RepositoryRulesetBypassActorOutput) +} + +type RepositoryRulesetConditions struct { + // (Block List, Max: 1) Required for `branch` and `tag` targets. Must NOT be set for `push` targets. (see below for nested schema) + // + // > **Note:** For `push` targets, do not include `refName` in conditions. Push rulesets operate on file content, not on refs. The `conditions` block is optional for push targets. + RefName RepositoryRulesetConditionsRefName `pulumi:"refName"` +} + +// RepositoryRulesetConditionsInput is an input type that accepts RepositoryRulesetConditionsArgs and RepositoryRulesetConditionsOutput values. +// You can construct a concrete instance of `RepositoryRulesetConditionsInput` via: +// +// RepositoryRulesetConditionsArgs{...} +type RepositoryRulesetConditionsInput interface { + pulumi.Input + + ToRepositoryRulesetConditionsOutput() RepositoryRulesetConditionsOutput + ToRepositoryRulesetConditionsOutputWithContext(context.Context) RepositoryRulesetConditionsOutput +} + +type RepositoryRulesetConditionsArgs struct { + // (Block List, Max: 1) Required for `branch` and `tag` targets. Must NOT be set for `push` targets. (see below for nested schema) + // + // > **Note:** For `push` targets, do not include `refName` in conditions. Push rulesets operate on file content, not on refs. The `conditions` block is optional for push targets. + RefName RepositoryRulesetConditionsRefNameInput `pulumi:"refName"` +} + +func (RepositoryRulesetConditionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetConditions)(nil)).Elem() +} + +func (i RepositoryRulesetConditionsArgs) ToRepositoryRulesetConditionsOutput() RepositoryRulesetConditionsOutput { + return i.ToRepositoryRulesetConditionsOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetConditionsArgs) ToRepositoryRulesetConditionsOutputWithContext(ctx context.Context) RepositoryRulesetConditionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetConditionsOutput) +} + +func (i RepositoryRulesetConditionsArgs) ToRepositoryRulesetConditionsPtrOutput() RepositoryRulesetConditionsPtrOutput { + return i.ToRepositoryRulesetConditionsPtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetConditionsArgs) ToRepositoryRulesetConditionsPtrOutputWithContext(ctx context.Context) RepositoryRulesetConditionsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetConditionsOutput).ToRepositoryRulesetConditionsPtrOutputWithContext(ctx) +} + +// RepositoryRulesetConditionsPtrInput is an input type that accepts RepositoryRulesetConditionsArgs, RepositoryRulesetConditionsPtr and RepositoryRulesetConditionsPtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetConditionsPtrInput` via: +// +// RepositoryRulesetConditionsArgs{...} +// +// or: +// +// nil +type RepositoryRulesetConditionsPtrInput interface { + pulumi.Input + + ToRepositoryRulesetConditionsPtrOutput() RepositoryRulesetConditionsPtrOutput + ToRepositoryRulesetConditionsPtrOutputWithContext(context.Context) RepositoryRulesetConditionsPtrOutput +} + +type repositoryRulesetConditionsPtrType RepositoryRulesetConditionsArgs + +func RepositoryRulesetConditionsPtr(v *RepositoryRulesetConditionsArgs) RepositoryRulesetConditionsPtrInput { + return (*repositoryRulesetConditionsPtrType)(v) +} + +func (*repositoryRulesetConditionsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetConditions)(nil)).Elem() +} + +func (i *repositoryRulesetConditionsPtrType) ToRepositoryRulesetConditionsPtrOutput() RepositoryRulesetConditionsPtrOutput { + return i.ToRepositoryRulesetConditionsPtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetConditionsPtrType) ToRepositoryRulesetConditionsPtrOutputWithContext(ctx context.Context) RepositoryRulesetConditionsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetConditionsPtrOutput) +} + +type RepositoryRulesetConditionsOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetConditionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetConditions)(nil)).Elem() +} + +func (o RepositoryRulesetConditionsOutput) ToRepositoryRulesetConditionsOutput() RepositoryRulesetConditionsOutput { + return o +} + +func (o RepositoryRulesetConditionsOutput) ToRepositoryRulesetConditionsOutputWithContext(ctx context.Context) RepositoryRulesetConditionsOutput { + return o +} + +func (o RepositoryRulesetConditionsOutput) ToRepositoryRulesetConditionsPtrOutput() RepositoryRulesetConditionsPtrOutput { + return o.ToRepositoryRulesetConditionsPtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetConditionsOutput) ToRepositoryRulesetConditionsPtrOutputWithContext(ctx context.Context) RepositoryRulesetConditionsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetConditions) *RepositoryRulesetConditions { + return &v + }).(RepositoryRulesetConditionsPtrOutput) +} + +// (Block List, Max: 1) Required for `branch` and `tag` targets. Must NOT be set for `push` targets. (see below for nested schema) +// +// > **Note:** For `push` targets, do not include `refName` in conditions. Push rulesets operate on file content, not on refs. The `conditions` block is optional for push targets. +func (o RepositoryRulesetConditionsOutput) RefName() RepositoryRulesetConditionsRefNameOutput { + return o.ApplyT(func(v RepositoryRulesetConditions) RepositoryRulesetConditionsRefName { return v.RefName }).(RepositoryRulesetConditionsRefNameOutput) +} + +type RepositoryRulesetConditionsPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetConditionsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetConditions)(nil)).Elem() +} + +func (o RepositoryRulesetConditionsPtrOutput) ToRepositoryRulesetConditionsPtrOutput() RepositoryRulesetConditionsPtrOutput { + return o +} + +func (o RepositoryRulesetConditionsPtrOutput) ToRepositoryRulesetConditionsPtrOutputWithContext(ctx context.Context) RepositoryRulesetConditionsPtrOutput { + return o +} + +func (o RepositoryRulesetConditionsPtrOutput) Elem() RepositoryRulesetConditionsOutput { + return o.ApplyT(func(v *RepositoryRulesetConditions) RepositoryRulesetConditions { + if v != nil { + return *v + } + var ret RepositoryRulesetConditions + return ret + }).(RepositoryRulesetConditionsOutput) +} + +// (Block List, Max: 1) Required for `branch` and `tag` targets. Must NOT be set for `push` targets. (see below for nested schema) +// +// > **Note:** For `push` targets, do not include `refName` in conditions. Push rulesets operate on file content, not on refs. The `conditions` block is optional for push targets. +func (o RepositoryRulesetConditionsPtrOutput) RefName() RepositoryRulesetConditionsRefNamePtrOutput { + return o.ApplyT(func(v *RepositoryRulesetConditions) *RepositoryRulesetConditionsRefName { + if v == nil { + return nil + } + return &v.RefName + }).(RepositoryRulesetConditionsRefNamePtrOutput) +} + +type RepositoryRulesetConditionsRefName struct { + // Array of ref names or patterns to exclude. The condition will not pass if any of these patterns match. + Excludes []string `pulumi:"excludes"` + // Array of ref names or patterns to include. One of these patterns must match for the condition to pass. Also accepts `~DEFAULT_BRANCH` to include the default branch or `~ALL` to include all branches. + Includes []string `pulumi:"includes"` +} + +// RepositoryRulesetConditionsRefNameInput is an input type that accepts RepositoryRulesetConditionsRefNameArgs and RepositoryRulesetConditionsRefNameOutput values. +// You can construct a concrete instance of `RepositoryRulesetConditionsRefNameInput` via: +// +// RepositoryRulesetConditionsRefNameArgs{...} +type RepositoryRulesetConditionsRefNameInput interface { + pulumi.Input + + ToRepositoryRulesetConditionsRefNameOutput() RepositoryRulesetConditionsRefNameOutput + ToRepositoryRulesetConditionsRefNameOutputWithContext(context.Context) RepositoryRulesetConditionsRefNameOutput +} + +type RepositoryRulesetConditionsRefNameArgs struct { + // Array of ref names or patterns to exclude. The condition will not pass if any of these patterns match. + Excludes pulumi.StringArrayInput `pulumi:"excludes"` + // Array of ref names or patterns to include. One of these patterns must match for the condition to pass. Also accepts `~DEFAULT_BRANCH` to include the default branch or `~ALL` to include all branches. + Includes pulumi.StringArrayInput `pulumi:"includes"` +} + +func (RepositoryRulesetConditionsRefNameArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetConditionsRefName)(nil)).Elem() +} + +func (i RepositoryRulesetConditionsRefNameArgs) ToRepositoryRulesetConditionsRefNameOutput() RepositoryRulesetConditionsRefNameOutput { + return i.ToRepositoryRulesetConditionsRefNameOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetConditionsRefNameArgs) ToRepositoryRulesetConditionsRefNameOutputWithContext(ctx context.Context) RepositoryRulesetConditionsRefNameOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetConditionsRefNameOutput) +} + +func (i RepositoryRulesetConditionsRefNameArgs) ToRepositoryRulesetConditionsRefNamePtrOutput() RepositoryRulesetConditionsRefNamePtrOutput { + return i.ToRepositoryRulesetConditionsRefNamePtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetConditionsRefNameArgs) ToRepositoryRulesetConditionsRefNamePtrOutputWithContext(ctx context.Context) RepositoryRulesetConditionsRefNamePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetConditionsRefNameOutput).ToRepositoryRulesetConditionsRefNamePtrOutputWithContext(ctx) +} + +// RepositoryRulesetConditionsRefNamePtrInput is an input type that accepts RepositoryRulesetConditionsRefNameArgs, RepositoryRulesetConditionsRefNamePtr and RepositoryRulesetConditionsRefNamePtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetConditionsRefNamePtrInput` via: +// +// RepositoryRulesetConditionsRefNameArgs{...} +// +// or: +// +// nil +type RepositoryRulesetConditionsRefNamePtrInput interface { + pulumi.Input + + ToRepositoryRulesetConditionsRefNamePtrOutput() RepositoryRulesetConditionsRefNamePtrOutput + ToRepositoryRulesetConditionsRefNamePtrOutputWithContext(context.Context) RepositoryRulesetConditionsRefNamePtrOutput +} + +type repositoryRulesetConditionsRefNamePtrType RepositoryRulesetConditionsRefNameArgs + +func RepositoryRulesetConditionsRefNamePtr(v *RepositoryRulesetConditionsRefNameArgs) RepositoryRulesetConditionsRefNamePtrInput { + return (*repositoryRulesetConditionsRefNamePtrType)(v) +} + +func (*repositoryRulesetConditionsRefNamePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetConditionsRefName)(nil)).Elem() +} + +func (i *repositoryRulesetConditionsRefNamePtrType) ToRepositoryRulesetConditionsRefNamePtrOutput() RepositoryRulesetConditionsRefNamePtrOutput { + return i.ToRepositoryRulesetConditionsRefNamePtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetConditionsRefNamePtrType) ToRepositoryRulesetConditionsRefNamePtrOutputWithContext(ctx context.Context) RepositoryRulesetConditionsRefNamePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetConditionsRefNamePtrOutput) +} + +type RepositoryRulesetConditionsRefNameOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetConditionsRefNameOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetConditionsRefName)(nil)).Elem() +} + +func (o RepositoryRulesetConditionsRefNameOutput) ToRepositoryRulesetConditionsRefNameOutput() RepositoryRulesetConditionsRefNameOutput { + return o +} + +func (o RepositoryRulesetConditionsRefNameOutput) ToRepositoryRulesetConditionsRefNameOutputWithContext(ctx context.Context) RepositoryRulesetConditionsRefNameOutput { + return o +} + +func (o RepositoryRulesetConditionsRefNameOutput) ToRepositoryRulesetConditionsRefNamePtrOutput() RepositoryRulesetConditionsRefNamePtrOutput { + return o.ToRepositoryRulesetConditionsRefNamePtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetConditionsRefNameOutput) ToRepositoryRulesetConditionsRefNamePtrOutputWithContext(ctx context.Context) RepositoryRulesetConditionsRefNamePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetConditionsRefName) *RepositoryRulesetConditionsRefName { + return &v + }).(RepositoryRulesetConditionsRefNamePtrOutput) +} + +// Array of ref names or patterns to exclude. The condition will not pass if any of these patterns match. +func (o RepositoryRulesetConditionsRefNameOutput) Excludes() pulumi.StringArrayOutput { + return o.ApplyT(func(v RepositoryRulesetConditionsRefName) []string { return v.Excludes }).(pulumi.StringArrayOutput) +} + +// Array of ref names or patterns to include. One of these patterns must match for the condition to pass. Also accepts `~DEFAULT_BRANCH` to include the default branch or `~ALL` to include all branches. +func (o RepositoryRulesetConditionsRefNameOutput) Includes() pulumi.StringArrayOutput { + return o.ApplyT(func(v RepositoryRulesetConditionsRefName) []string { return v.Includes }).(pulumi.StringArrayOutput) +} + +type RepositoryRulesetConditionsRefNamePtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetConditionsRefNamePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetConditionsRefName)(nil)).Elem() +} + +func (o RepositoryRulesetConditionsRefNamePtrOutput) ToRepositoryRulesetConditionsRefNamePtrOutput() RepositoryRulesetConditionsRefNamePtrOutput { + return o +} + +func (o RepositoryRulesetConditionsRefNamePtrOutput) ToRepositoryRulesetConditionsRefNamePtrOutputWithContext(ctx context.Context) RepositoryRulesetConditionsRefNamePtrOutput { + return o +} + +func (o RepositoryRulesetConditionsRefNamePtrOutput) Elem() RepositoryRulesetConditionsRefNameOutput { + return o.ApplyT(func(v *RepositoryRulesetConditionsRefName) RepositoryRulesetConditionsRefName { + if v != nil { + return *v + } + var ret RepositoryRulesetConditionsRefName + return ret + }).(RepositoryRulesetConditionsRefNameOutput) +} + +// Array of ref names or patterns to exclude. The condition will not pass if any of these patterns match. +func (o RepositoryRulesetConditionsRefNamePtrOutput) Excludes() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RepositoryRulesetConditionsRefName) []string { + if v == nil { + return nil + } + return v.Excludes + }).(pulumi.StringArrayOutput) +} + +// Array of ref names or patterns to include. One of these patterns must match for the condition to pass. Also accepts `~DEFAULT_BRANCH` to include the default branch or `~ALL` to include all branches. +func (o RepositoryRulesetConditionsRefNamePtrOutput) Includes() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RepositoryRulesetConditionsRefName) []string { + if v == nil { + return nil + } + return v.Includes + }).(pulumi.StringArrayOutput) +} + +type RepositoryRulesetRules struct { + // (Block List, Max: 1) Parameters to be used for the branchNamePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. Conflicts with `tagNamePattern` as it only applied to rulesets with target `branch`. (see below for nested schema) + BranchNamePattern *RepositoryRulesetRulesBranchNamePattern `pulumi:"branchNamePattern"` + // (Block List, Max: 1) Parameters to be used for the commitAuthorEmailPattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) + CommitAuthorEmailPattern *RepositoryRulesetRulesCommitAuthorEmailPattern `pulumi:"commitAuthorEmailPattern"` + // (Block List, Max: 1) Parameters to be used for the commitMessagePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) + CommitMessagePattern *RepositoryRulesetRulesCommitMessagePattern `pulumi:"commitMessagePattern"` + // (Block List, Max: 1) Parameters to be used for the committerEmailPattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) + CommitterEmailPattern *RepositoryRulesetRulesCommitterEmailPattern `pulumi:"committerEmailPattern"` + // (Block List, Max: 1) Automatically request Copilot code review for new pull requests if the author has access to Copilot code review and their premium requests quota has not reached the limit. (see below for nested schema) + CopilotCodeReview *RepositoryRulesetRulesCopilotCodeReview `pulumi:"copilotCodeReview"` + // (Boolean) Only allow users with bypass permission to create matching refs. + Creation *bool `pulumi:"creation"` + // (Boolean) Only allow users with bypass permissions to delete matching refs. + Deletion *bool `pulumi:"deletion"` + // (Block List, Max: 1) Prevent commits that include files with specified file extensions from being pushed to the commit graph. This rule only applies to rulesets with target `push`. (see below for nested schema) + FileExtensionRestriction *RepositoryRulesetRulesFileExtensionRestriction `pulumi:"fileExtensionRestriction"` + // (Block List, Max 1) Parameters to be used for the filePathRestriction rule. When enabled restricts access to files within the repository. (See below for nested schema) + FilePathRestriction *RepositoryRulesetRulesFilePathRestriction `pulumi:"filePathRestriction"` + // (Integer) The maximum number of characters allowed in file paths. + MaxFilePathLength *RepositoryRulesetRulesMaxFilePathLength `pulumi:"maxFilePathLength"` + // (Integer) The maximum allowed size, in megabytes (MB), of a file. Valid range is 1-100 MB. + MaxFileSize *RepositoryRulesetRulesMaxFileSize `pulumi:"maxFileSize"` + // (Block List, Max: 1) Merges must be performed via a merge queue. (see below for nested schema) + MergeQueue *RepositoryRulesetRulesMergeQueue `pulumi:"mergeQueue"` + // (Boolean) Prevent users with push access from force pushing to branches. + NonFastForward *bool `pulumi:"nonFastForward"` + // (Block List, Max: 1) Require all commits be made to a non-target branch and submitted via a pull request before they can be merged. (see below for nested schema) + PullRequest *RepositoryRulesetRulesPullRequest `pulumi:"pullRequest"` + // (Block List, Max: 1) Define which tools must provide code scanning results before the reference is updated. When configured, code scanning must be enabled and have results for both the commit and the reference being updated. Multiple code scanning tools can be specified. (see below for nested schema) + RequiredCodeScanning *RepositoryRulesetRulesRequiredCodeScanning `pulumi:"requiredCodeScanning"` + // (Block List, Max: 1) Choose which environments must be successfully deployed to before branches can be merged into a branch that matches this rule. (see below for nested schema) + RequiredDeployments *RepositoryRulesetRulesRequiredDeployments `pulumi:"requiredDeployments"` + // (Boolean) Prevent merge commits from being pushed to matching branches. + RequiredLinearHistory *bool `pulumi:"requiredLinearHistory"` + // (Boolean) Commits pushed to matching branches must have verified signatures. + RequiredSignatures *bool `pulumi:"requiredSignatures"` + // (Block List, Max: 1) Choose which status checks must pass before branches can be merged into a branch that matches this rule. When enabled, commits must first be pushed to another branch, then merged or pushed directly to a branch that matches this rule after status checks have passed. (see below for nested schema) + RequiredStatusChecks *RepositoryRulesetRulesRequiredStatusChecks `pulumi:"requiredStatusChecks"` + // (Block List, Max: 1) Parameters to be used for the tagNamePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. Conflicts with `branchNamePattern` as it only applied to rulesets with target `tag`. (see below for nested schema) + TagNamePattern *RepositoryRulesetRulesTagNamePattern `pulumi:"tagNamePattern"` + // (Boolean) Only allow users with bypass permission to update matching refs. + Update *bool `pulumi:"update"` + // (Boolean) Branch can pull changes from its upstream repository. This is only applicable to forked repositories. Requires `update` to be set to `true`. Note: behaviour is affected by a known bug on the GitHub side which may cause issues when using this parameter. + UpdateAllowsFetchAndMerge *bool `pulumi:"updateAllowsFetchAndMerge"` +} + +// RepositoryRulesetRulesInput is an input type that accepts RepositoryRulesetRulesArgs and RepositoryRulesetRulesOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesInput` via: +// +// RepositoryRulesetRulesArgs{...} +type RepositoryRulesetRulesInput interface { + pulumi.Input + + ToRepositoryRulesetRulesOutput() RepositoryRulesetRulesOutput + ToRepositoryRulesetRulesOutputWithContext(context.Context) RepositoryRulesetRulesOutput +} + +type RepositoryRulesetRulesArgs struct { + // (Block List, Max: 1) Parameters to be used for the branchNamePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. Conflicts with `tagNamePattern` as it only applied to rulesets with target `branch`. (see below for nested schema) + BranchNamePattern RepositoryRulesetRulesBranchNamePatternPtrInput `pulumi:"branchNamePattern"` + // (Block List, Max: 1) Parameters to be used for the commitAuthorEmailPattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) + CommitAuthorEmailPattern RepositoryRulesetRulesCommitAuthorEmailPatternPtrInput `pulumi:"commitAuthorEmailPattern"` + // (Block List, Max: 1) Parameters to be used for the commitMessagePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) + CommitMessagePattern RepositoryRulesetRulesCommitMessagePatternPtrInput `pulumi:"commitMessagePattern"` + // (Block List, Max: 1) Parameters to be used for the committerEmailPattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) + CommitterEmailPattern RepositoryRulesetRulesCommitterEmailPatternPtrInput `pulumi:"committerEmailPattern"` + // (Block List, Max: 1) Automatically request Copilot code review for new pull requests if the author has access to Copilot code review and their premium requests quota has not reached the limit. (see below for nested schema) + CopilotCodeReview RepositoryRulesetRulesCopilotCodeReviewPtrInput `pulumi:"copilotCodeReview"` + // (Boolean) Only allow users with bypass permission to create matching refs. + Creation pulumi.BoolPtrInput `pulumi:"creation"` + // (Boolean) Only allow users with bypass permissions to delete matching refs. + Deletion pulumi.BoolPtrInput `pulumi:"deletion"` + // (Block List, Max: 1) Prevent commits that include files with specified file extensions from being pushed to the commit graph. This rule only applies to rulesets with target `push`. (see below for nested schema) + FileExtensionRestriction RepositoryRulesetRulesFileExtensionRestrictionPtrInput `pulumi:"fileExtensionRestriction"` + // (Block List, Max 1) Parameters to be used for the filePathRestriction rule. When enabled restricts access to files within the repository. (See below for nested schema) + FilePathRestriction RepositoryRulesetRulesFilePathRestrictionPtrInput `pulumi:"filePathRestriction"` + // (Integer) The maximum number of characters allowed in file paths. + MaxFilePathLength RepositoryRulesetRulesMaxFilePathLengthPtrInput `pulumi:"maxFilePathLength"` + // (Integer) The maximum allowed size, in megabytes (MB), of a file. Valid range is 1-100 MB. + MaxFileSize RepositoryRulesetRulesMaxFileSizePtrInput `pulumi:"maxFileSize"` + // (Block List, Max: 1) Merges must be performed via a merge queue. (see below for nested schema) + MergeQueue RepositoryRulesetRulesMergeQueuePtrInput `pulumi:"mergeQueue"` + // (Boolean) Prevent users with push access from force pushing to branches. + NonFastForward pulumi.BoolPtrInput `pulumi:"nonFastForward"` + // (Block List, Max: 1) Require all commits be made to a non-target branch and submitted via a pull request before they can be merged. (see below for nested schema) + PullRequest RepositoryRulesetRulesPullRequestPtrInput `pulumi:"pullRequest"` + // (Block List, Max: 1) Define which tools must provide code scanning results before the reference is updated. When configured, code scanning must be enabled and have results for both the commit and the reference being updated. Multiple code scanning tools can be specified. (see below for nested schema) + RequiredCodeScanning RepositoryRulesetRulesRequiredCodeScanningPtrInput `pulumi:"requiredCodeScanning"` + // (Block List, Max: 1) Choose which environments must be successfully deployed to before branches can be merged into a branch that matches this rule. (see below for nested schema) + RequiredDeployments RepositoryRulesetRulesRequiredDeploymentsPtrInput `pulumi:"requiredDeployments"` + // (Boolean) Prevent merge commits from being pushed to matching branches. + RequiredLinearHistory pulumi.BoolPtrInput `pulumi:"requiredLinearHistory"` + // (Boolean) Commits pushed to matching branches must have verified signatures. + RequiredSignatures pulumi.BoolPtrInput `pulumi:"requiredSignatures"` + // (Block List, Max: 1) Choose which status checks must pass before branches can be merged into a branch that matches this rule. When enabled, commits must first be pushed to another branch, then merged or pushed directly to a branch that matches this rule after status checks have passed. (see below for nested schema) + RequiredStatusChecks RepositoryRulesetRulesRequiredStatusChecksPtrInput `pulumi:"requiredStatusChecks"` + // (Block List, Max: 1) Parameters to be used for the tagNamePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. Conflicts with `branchNamePattern` as it only applied to rulesets with target `tag`. (see below for nested schema) + TagNamePattern RepositoryRulesetRulesTagNamePatternPtrInput `pulumi:"tagNamePattern"` + // (Boolean) Only allow users with bypass permission to update matching refs. + Update pulumi.BoolPtrInput `pulumi:"update"` + // (Boolean) Branch can pull changes from its upstream repository. This is only applicable to forked repositories. Requires `update` to be set to `true`. Note: behaviour is affected by a known bug on the GitHub side which may cause issues when using this parameter. + UpdateAllowsFetchAndMerge pulumi.BoolPtrInput `pulumi:"updateAllowsFetchAndMerge"` +} + +func (RepositoryRulesetRulesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRules)(nil)).Elem() +} + +func (i RepositoryRulesetRulesArgs) ToRepositoryRulesetRulesOutput() RepositoryRulesetRulesOutput { + return i.ToRepositoryRulesetRulesOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesArgs) ToRepositoryRulesetRulesOutputWithContext(ctx context.Context) RepositoryRulesetRulesOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesOutput) +} + +func (i RepositoryRulesetRulesArgs) ToRepositoryRulesetRulesPtrOutput() RepositoryRulesetRulesPtrOutput { + return i.ToRepositoryRulesetRulesPtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesArgs) ToRepositoryRulesetRulesPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesOutput).ToRepositoryRulesetRulesPtrOutputWithContext(ctx) +} + +// RepositoryRulesetRulesPtrInput is an input type that accepts RepositoryRulesetRulesArgs, RepositoryRulesetRulesPtr and RepositoryRulesetRulesPtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesPtrInput` via: +// +// RepositoryRulesetRulesArgs{...} +// +// or: +// +// nil +type RepositoryRulesetRulesPtrInput interface { + pulumi.Input + + ToRepositoryRulesetRulesPtrOutput() RepositoryRulesetRulesPtrOutput + ToRepositoryRulesetRulesPtrOutputWithContext(context.Context) RepositoryRulesetRulesPtrOutput +} + +type repositoryRulesetRulesPtrType RepositoryRulesetRulesArgs + +func RepositoryRulesetRulesPtr(v *RepositoryRulesetRulesArgs) RepositoryRulesetRulesPtrInput { + return (*repositoryRulesetRulesPtrType)(v) +} + +func (*repositoryRulesetRulesPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRules)(nil)).Elem() +} + +func (i *repositoryRulesetRulesPtrType) ToRepositoryRulesetRulesPtrOutput() RepositoryRulesetRulesPtrOutput { + return i.ToRepositoryRulesetRulesPtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetRulesPtrType) ToRepositoryRulesetRulesPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesPtrOutput) +} + +type RepositoryRulesetRulesOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRules)(nil)).Elem() +} + +func (o RepositoryRulesetRulesOutput) ToRepositoryRulesetRulesOutput() RepositoryRulesetRulesOutput { + return o +} + +func (o RepositoryRulesetRulesOutput) ToRepositoryRulesetRulesOutputWithContext(ctx context.Context) RepositoryRulesetRulesOutput { + return o +} + +func (o RepositoryRulesetRulesOutput) ToRepositoryRulesetRulesPtrOutput() RepositoryRulesetRulesPtrOutput { + return o.ToRepositoryRulesetRulesPtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetRulesOutput) ToRepositoryRulesetRulesPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetRules) *RepositoryRulesetRules { + return &v + }).(RepositoryRulesetRulesPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the branchNamePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. Conflicts with `tagNamePattern` as it only applied to rulesets with target `branch`. (see below for nested schema) +func (o RepositoryRulesetRulesOutput) BranchNamePattern() RepositoryRulesetRulesBranchNamePatternPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *RepositoryRulesetRulesBranchNamePattern { return v.BranchNamePattern }).(RepositoryRulesetRulesBranchNamePatternPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the commitAuthorEmailPattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) +func (o RepositoryRulesetRulesOutput) CommitAuthorEmailPattern() RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *RepositoryRulesetRulesCommitAuthorEmailPattern { + return v.CommitAuthorEmailPattern + }).(RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the commitMessagePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) +func (o RepositoryRulesetRulesOutput) CommitMessagePattern() RepositoryRulesetRulesCommitMessagePatternPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *RepositoryRulesetRulesCommitMessagePattern { + return v.CommitMessagePattern + }).(RepositoryRulesetRulesCommitMessagePatternPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the committerEmailPattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) +func (o RepositoryRulesetRulesOutput) CommitterEmailPattern() RepositoryRulesetRulesCommitterEmailPatternPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *RepositoryRulesetRulesCommitterEmailPattern { + return v.CommitterEmailPattern + }).(RepositoryRulesetRulesCommitterEmailPatternPtrOutput) +} + +// (Block List, Max: 1) Automatically request Copilot code review for new pull requests if the author has access to Copilot code review and their premium requests quota has not reached the limit. (see below for nested schema) +func (o RepositoryRulesetRulesOutput) CopilotCodeReview() RepositoryRulesetRulesCopilotCodeReviewPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *RepositoryRulesetRulesCopilotCodeReview { return v.CopilotCodeReview }).(RepositoryRulesetRulesCopilotCodeReviewPtrOutput) +} + +// (Boolean) Only allow users with bypass permission to create matching refs. +func (o RepositoryRulesetRulesOutput) Creation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *bool { return v.Creation }).(pulumi.BoolPtrOutput) +} + +// (Boolean) Only allow users with bypass permissions to delete matching refs. +func (o RepositoryRulesetRulesOutput) Deletion() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *bool { return v.Deletion }).(pulumi.BoolPtrOutput) +} + +// (Block List, Max: 1) Prevent commits that include files with specified file extensions from being pushed to the commit graph. This rule only applies to rulesets with target `push`. (see below for nested schema) +func (o RepositoryRulesetRulesOutput) FileExtensionRestriction() RepositoryRulesetRulesFileExtensionRestrictionPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *RepositoryRulesetRulesFileExtensionRestriction { + return v.FileExtensionRestriction + }).(RepositoryRulesetRulesFileExtensionRestrictionPtrOutput) +} + +// (Block List, Max 1) Parameters to be used for the filePathRestriction rule. When enabled restricts access to files within the repository. (See below for nested schema) +func (o RepositoryRulesetRulesOutput) FilePathRestriction() RepositoryRulesetRulesFilePathRestrictionPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *RepositoryRulesetRulesFilePathRestriction { + return v.FilePathRestriction + }).(RepositoryRulesetRulesFilePathRestrictionPtrOutput) +} + +// (Integer) The maximum number of characters allowed in file paths. +func (o RepositoryRulesetRulesOutput) MaxFilePathLength() RepositoryRulesetRulesMaxFilePathLengthPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *RepositoryRulesetRulesMaxFilePathLength { return v.MaxFilePathLength }).(RepositoryRulesetRulesMaxFilePathLengthPtrOutput) +} + +// (Integer) The maximum allowed size, in megabytes (MB), of a file. Valid range is 1-100 MB. +func (o RepositoryRulesetRulesOutput) MaxFileSize() RepositoryRulesetRulesMaxFileSizePtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *RepositoryRulesetRulesMaxFileSize { return v.MaxFileSize }).(RepositoryRulesetRulesMaxFileSizePtrOutput) +} + +// (Block List, Max: 1) Merges must be performed via a merge queue. (see below for nested schema) +func (o RepositoryRulesetRulesOutput) MergeQueue() RepositoryRulesetRulesMergeQueuePtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *RepositoryRulesetRulesMergeQueue { return v.MergeQueue }).(RepositoryRulesetRulesMergeQueuePtrOutput) +} + +// (Boolean) Prevent users with push access from force pushing to branches. +func (o RepositoryRulesetRulesOutput) NonFastForward() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *bool { return v.NonFastForward }).(pulumi.BoolPtrOutput) +} + +// (Block List, Max: 1) Require all commits be made to a non-target branch and submitted via a pull request before they can be merged. (see below for nested schema) +func (o RepositoryRulesetRulesOutput) PullRequest() RepositoryRulesetRulesPullRequestPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *RepositoryRulesetRulesPullRequest { return v.PullRequest }).(RepositoryRulesetRulesPullRequestPtrOutput) +} + +// (Block List, Max: 1) Define which tools must provide code scanning results before the reference is updated. When configured, code scanning must be enabled and have results for both the commit and the reference being updated. Multiple code scanning tools can be specified. (see below for nested schema) +func (o RepositoryRulesetRulesOutput) RequiredCodeScanning() RepositoryRulesetRulesRequiredCodeScanningPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *RepositoryRulesetRulesRequiredCodeScanning { + return v.RequiredCodeScanning + }).(RepositoryRulesetRulesRequiredCodeScanningPtrOutput) +} + +// (Block List, Max: 1) Choose which environments must be successfully deployed to before branches can be merged into a branch that matches this rule. (see below for nested schema) +func (o RepositoryRulesetRulesOutput) RequiredDeployments() RepositoryRulesetRulesRequiredDeploymentsPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *RepositoryRulesetRulesRequiredDeployments { + return v.RequiredDeployments + }).(RepositoryRulesetRulesRequiredDeploymentsPtrOutput) +} + +// (Boolean) Prevent merge commits from being pushed to matching branches. +func (o RepositoryRulesetRulesOutput) RequiredLinearHistory() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *bool { return v.RequiredLinearHistory }).(pulumi.BoolPtrOutput) +} + +// (Boolean) Commits pushed to matching branches must have verified signatures. +func (o RepositoryRulesetRulesOutput) RequiredSignatures() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *bool { return v.RequiredSignatures }).(pulumi.BoolPtrOutput) +} + +// (Block List, Max: 1) Choose which status checks must pass before branches can be merged into a branch that matches this rule. When enabled, commits must first be pushed to another branch, then merged or pushed directly to a branch that matches this rule after status checks have passed. (see below for nested schema) +func (o RepositoryRulesetRulesOutput) RequiredStatusChecks() RepositoryRulesetRulesRequiredStatusChecksPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *RepositoryRulesetRulesRequiredStatusChecks { + return v.RequiredStatusChecks + }).(RepositoryRulesetRulesRequiredStatusChecksPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the tagNamePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. Conflicts with `branchNamePattern` as it only applied to rulesets with target `tag`. (see below for nested schema) +func (o RepositoryRulesetRulesOutput) TagNamePattern() RepositoryRulesetRulesTagNamePatternPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *RepositoryRulesetRulesTagNamePattern { return v.TagNamePattern }).(RepositoryRulesetRulesTagNamePatternPtrOutput) +} + +// (Boolean) Only allow users with bypass permission to update matching refs. +func (o RepositoryRulesetRulesOutput) Update() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *bool { return v.Update }).(pulumi.BoolPtrOutput) +} + +// (Boolean) Branch can pull changes from its upstream repository. This is only applicable to forked repositories. Requires `update` to be set to `true`. Note: behaviour is affected by a known bug on the GitHub side which may cause issues when using this parameter. +func (o RepositoryRulesetRulesOutput) UpdateAllowsFetchAndMerge() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRules) *bool { return v.UpdateAllowsFetchAndMerge }).(pulumi.BoolPtrOutput) +} + +type RepositoryRulesetRulesPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRules)(nil)).Elem() +} + +func (o RepositoryRulesetRulesPtrOutput) ToRepositoryRulesetRulesPtrOutput() RepositoryRulesetRulesPtrOutput { + return o +} + +func (o RepositoryRulesetRulesPtrOutput) ToRepositoryRulesetRulesPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesPtrOutput { + return o +} + +func (o RepositoryRulesetRulesPtrOutput) Elem() RepositoryRulesetRulesOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) RepositoryRulesetRules { + if v != nil { + return *v + } + var ret RepositoryRulesetRules + return ret + }).(RepositoryRulesetRulesOutput) +} + +// (Block List, Max: 1) Parameters to be used for the branchNamePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. Conflicts with `tagNamePattern` as it only applied to rulesets with target `branch`. (see below for nested schema) +func (o RepositoryRulesetRulesPtrOutput) BranchNamePattern() RepositoryRulesetRulesBranchNamePatternPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *RepositoryRulesetRulesBranchNamePattern { + if v == nil { + return nil + } + return v.BranchNamePattern + }).(RepositoryRulesetRulesBranchNamePatternPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the commitAuthorEmailPattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) +func (o RepositoryRulesetRulesPtrOutput) CommitAuthorEmailPattern() RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *RepositoryRulesetRulesCommitAuthorEmailPattern { + if v == nil { + return nil + } + return v.CommitAuthorEmailPattern + }).(RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the commitMessagePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) +func (o RepositoryRulesetRulesPtrOutput) CommitMessagePattern() RepositoryRulesetRulesCommitMessagePatternPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *RepositoryRulesetRulesCommitMessagePattern { + if v == nil { + return nil + } + return v.CommitMessagePattern + }).(RepositoryRulesetRulesCommitMessagePatternPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the committerEmailPattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. (see below for nested schema) +func (o RepositoryRulesetRulesPtrOutput) CommitterEmailPattern() RepositoryRulesetRulesCommitterEmailPatternPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *RepositoryRulesetRulesCommitterEmailPattern { + if v == nil { + return nil + } + return v.CommitterEmailPattern + }).(RepositoryRulesetRulesCommitterEmailPatternPtrOutput) +} + +// (Block List, Max: 1) Automatically request Copilot code review for new pull requests if the author has access to Copilot code review and their premium requests quota has not reached the limit. (see below for nested schema) +func (o RepositoryRulesetRulesPtrOutput) CopilotCodeReview() RepositoryRulesetRulesCopilotCodeReviewPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *RepositoryRulesetRulesCopilotCodeReview { + if v == nil { + return nil + } + return v.CopilotCodeReview + }).(RepositoryRulesetRulesCopilotCodeReviewPtrOutput) +} + +// (Boolean) Only allow users with bypass permission to create matching refs. +func (o RepositoryRulesetRulesPtrOutput) Creation() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *bool { + if v == nil { + return nil + } + return v.Creation + }).(pulumi.BoolPtrOutput) +} + +// (Boolean) Only allow users with bypass permissions to delete matching refs. +func (o RepositoryRulesetRulesPtrOutput) Deletion() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *bool { + if v == nil { + return nil + } + return v.Deletion + }).(pulumi.BoolPtrOutput) +} + +// (Block List, Max: 1) Prevent commits that include files with specified file extensions from being pushed to the commit graph. This rule only applies to rulesets with target `push`. (see below for nested schema) +func (o RepositoryRulesetRulesPtrOutput) FileExtensionRestriction() RepositoryRulesetRulesFileExtensionRestrictionPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *RepositoryRulesetRulesFileExtensionRestriction { + if v == nil { + return nil + } + return v.FileExtensionRestriction + }).(RepositoryRulesetRulesFileExtensionRestrictionPtrOutput) +} + +// (Block List, Max 1) Parameters to be used for the filePathRestriction rule. When enabled restricts access to files within the repository. (See below for nested schema) +func (o RepositoryRulesetRulesPtrOutput) FilePathRestriction() RepositoryRulesetRulesFilePathRestrictionPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *RepositoryRulesetRulesFilePathRestriction { + if v == nil { + return nil + } + return v.FilePathRestriction + }).(RepositoryRulesetRulesFilePathRestrictionPtrOutput) +} + +// (Integer) The maximum number of characters allowed in file paths. +func (o RepositoryRulesetRulesPtrOutput) MaxFilePathLength() RepositoryRulesetRulesMaxFilePathLengthPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *RepositoryRulesetRulesMaxFilePathLength { + if v == nil { + return nil + } + return v.MaxFilePathLength + }).(RepositoryRulesetRulesMaxFilePathLengthPtrOutput) +} + +// (Integer) The maximum allowed size, in megabytes (MB), of a file. Valid range is 1-100 MB. +func (o RepositoryRulesetRulesPtrOutput) MaxFileSize() RepositoryRulesetRulesMaxFileSizePtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *RepositoryRulesetRulesMaxFileSize { + if v == nil { + return nil + } + return v.MaxFileSize + }).(RepositoryRulesetRulesMaxFileSizePtrOutput) +} + +// (Block List, Max: 1) Merges must be performed via a merge queue. (see below for nested schema) +func (o RepositoryRulesetRulesPtrOutput) MergeQueue() RepositoryRulesetRulesMergeQueuePtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *RepositoryRulesetRulesMergeQueue { + if v == nil { + return nil + } + return v.MergeQueue + }).(RepositoryRulesetRulesMergeQueuePtrOutput) +} + +// (Boolean) Prevent users with push access from force pushing to branches. +func (o RepositoryRulesetRulesPtrOutput) NonFastForward() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *bool { + if v == nil { + return nil + } + return v.NonFastForward + }).(pulumi.BoolPtrOutput) +} + +// (Block List, Max: 1) Require all commits be made to a non-target branch and submitted via a pull request before they can be merged. (see below for nested schema) +func (o RepositoryRulesetRulesPtrOutput) PullRequest() RepositoryRulesetRulesPullRequestPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *RepositoryRulesetRulesPullRequest { + if v == nil { + return nil + } + return v.PullRequest + }).(RepositoryRulesetRulesPullRequestPtrOutput) +} + +// (Block List, Max: 1) Define which tools must provide code scanning results before the reference is updated. When configured, code scanning must be enabled and have results for both the commit and the reference being updated. Multiple code scanning tools can be specified. (see below for nested schema) +func (o RepositoryRulesetRulesPtrOutput) RequiredCodeScanning() RepositoryRulesetRulesRequiredCodeScanningPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *RepositoryRulesetRulesRequiredCodeScanning { + if v == nil { + return nil + } + return v.RequiredCodeScanning + }).(RepositoryRulesetRulesRequiredCodeScanningPtrOutput) +} + +// (Block List, Max: 1) Choose which environments must be successfully deployed to before branches can be merged into a branch that matches this rule. (see below for nested schema) +func (o RepositoryRulesetRulesPtrOutput) RequiredDeployments() RepositoryRulesetRulesRequiredDeploymentsPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *RepositoryRulesetRulesRequiredDeployments { + if v == nil { + return nil + } + return v.RequiredDeployments + }).(RepositoryRulesetRulesRequiredDeploymentsPtrOutput) +} + +// (Boolean) Prevent merge commits from being pushed to matching branches. +func (o RepositoryRulesetRulesPtrOutput) RequiredLinearHistory() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *bool { + if v == nil { + return nil + } + return v.RequiredLinearHistory + }).(pulumi.BoolPtrOutput) +} + +// (Boolean) Commits pushed to matching branches must have verified signatures. +func (o RepositoryRulesetRulesPtrOutput) RequiredSignatures() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *bool { + if v == nil { + return nil + } + return v.RequiredSignatures + }).(pulumi.BoolPtrOutput) +} + +// (Block List, Max: 1) Choose which status checks must pass before branches can be merged into a branch that matches this rule. When enabled, commits must first be pushed to another branch, then merged or pushed directly to a branch that matches this rule after status checks have passed. (see below for nested schema) +func (o RepositoryRulesetRulesPtrOutput) RequiredStatusChecks() RepositoryRulesetRulesRequiredStatusChecksPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *RepositoryRulesetRulesRequiredStatusChecks { + if v == nil { + return nil + } + return v.RequiredStatusChecks + }).(RepositoryRulesetRulesRequiredStatusChecksPtrOutput) +} + +// (Block List, Max: 1) Parameters to be used for the tagNamePattern rule. This rule only applies to repositories within an enterprise, it cannot be applied to repositories owned by individuals or regular organizations. Conflicts with `branchNamePattern` as it only applied to rulesets with target `tag`. (see below for nested schema) +func (o RepositoryRulesetRulesPtrOutput) TagNamePattern() RepositoryRulesetRulesTagNamePatternPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *RepositoryRulesetRulesTagNamePattern { + if v == nil { + return nil + } + return v.TagNamePattern + }).(RepositoryRulesetRulesTagNamePatternPtrOutput) +} + +// (Boolean) Only allow users with bypass permission to update matching refs. +func (o RepositoryRulesetRulesPtrOutput) Update() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *bool { + if v == nil { + return nil + } + return v.Update + }).(pulumi.BoolPtrOutput) +} + +// (Boolean) Branch can pull changes from its upstream repository. This is only applicable to forked repositories. Requires `update` to be set to `true`. Note: behaviour is affected by a known bug on the GitHub side which may cause issues when using this parameter. +func (o RepositoryRulesetRulesPtrOutput) UpdateAllowsFetchAndMerge() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRules) *bool { + if v == nil { + return nil + } + return v.UpdateAllowsFetchAndMerge + }).(pulumi.BoolPtrOutput) +} + +type RepositoryRulesetRulesBranchNamePattern struct { + // (String) The name of the ruleset. + Name *string `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate *bool `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator string `pulumi:"operator"` + // The pattern to match with. + Pattern string `pulumi:"pattern"` +} + +// RepositoryRulesetRulesBranchNamePatternInput is an input type that accepts RepositoryRulesetRulesBranchNamePatternArgs and RepositoryRulesetRulesBranchNamePatternOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesBranchNamePatternInput` via: +// +// RepositoryRulesetRulesBranchNamePatternArgs{...} +type RepositoryRulesetRulesBranchNamePatternInput interface { + pulumi.Input + + ToRepositoryRulesetRulesBranchNamePatternOutput() RepositoryRulesetRulesBranchNamePatternOutput + ToRepositoryRulesetRulesBranchNamePatternOutputWithContext(context.Context) RepositoryRulesetRulesBranchNamePatternOutput +} + +type RepositoryRulesetRulesBranchNamePatternArgs struct { + // (String) The name of the ruleset. + Name pulumi.StringPtrInput `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate pulumi.BoolPtrInput `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator pulumi.StringInput `pulumi:"operator"` + // The pattern to match with. + Pattern pulumi.StringInput `pulumi:"pattern"` +} + +func (RepositoryRulesetRulesBranchNamePatternArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesBranchNamePattern)(nil)).Elem() +} + +func (i RepositoryRulesetRulesBranchNamePatternArgs) ToRepositoryRulesetRulesBranchNamePatternOutput() RepositoryRulesetRulesBranchNamePatternOutput { + return i.ToRepositoryRulesetRulesBranchNamePatternOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesBranchNamePatternArgs) ToRepositoryRulesetRulesBranchNamePatternOutputWithContext(ctx context.Context) RepositoryRulesetRulesBranchNamePatternOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesBranchNamePatternOutput) +} + +func (i RepositoryRulesetRulesBranchNamePatternArgs) ToRepositoryRulesetRulesBranchNamePatternPtrOutput() RepositoryRulesetRulesBranchNamePatternPtrOutput { + return i.ToRepositoryRulesetRulesBranchNamePatternPtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesBranchNamePatternArgs) ToRepositoryRulesetRulesBranchNamePatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesBranchNamePatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesBranchNamePatternOutput).ToRepositoryRulesetRulesBranchNamePatternPtrOutputWithContext(ctx) +} + +// RepositoryRulesetRulesBranchNamePatternPtrInput is an input type that accepts RepositoryRulesetRulesBranchNamePatternArgs, RepositoryRulesetRulesBranchNamePatternPtr and RepositoryRulesetRulesBranchNamePatternPtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesBranchNamePatternPtrInput` via: +// +// RepositoryRulesetRulesBranchNamePatternArgs{...} +// +// or: +// +// nil +type RepositoryRulesetRulesBranchNamePatternPtrInput interface { + pulumi.Input + + ToRepositoryRulesetRulesBranchNamePatternPtrOutput() RepositoryRulesetRulesBranchNamePatternPtrOutput + ToRepositoryRulesetRulesBranchNamePatternPtrOutputWithContext(context.Context) RepositoryRulesetRulesBranchNamePatternPtrOutput +} + +type repositoryRulesetRulesBranchNamePatternPtrType RepositoryRulesetRulesBranchNamePatternArgs + +func RepositoryRulesetRulesBranchNamePatternPtr(v *RepositoryRulesetRulesBranchNamePatternArgs) RepositoryRulesetRulesBranchNamePatternPtrInput { + return (*repositoryRulesetRulesBranchNamePatternPtrType)(v) +} + +func (*repositoryRulesetRulesBranchNamePatternPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesBranchNamePattern)(nil)).Elem() +} + +func (i *repositoryRulesetRulesBranchNamePatternPtrType) ToRepositoryRulesetRulesBranchNamePatternPtrOutput() RepositoryRulesetRulesBranchNamePatternPtrOutput { + return i.ToRepositoryRulesetRulesBranchNamePatternPtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetRulesBranchNamePatternPtrType) ToRepositoryRulesetRulesBranchNamePatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesBranchNamePatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesBranchNamePatternPtrOutput) +} + +type RepositoryRulesetRulesBranchNamePatternOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesBranchNamePatternOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesBranchNamePattern)(nil)).Elem() +} + +func (o RepositoryRulesetRulesBranchNamePatternOutput) ToRepositoryRulesetRulesBranchNamePatternOutput() RepositoryRulesetRulesBranchNamePatternOutput { + return o +} + +func (o RepositoryRulesetRulesBranchNamePatternOutput) ToRepositoryRulesetRulesBranchNamePatternOutputWithContext(ctx context.Context) RepositoryRulesetRulesBranchNamePatternOutput { + return o +} + +func (o RepositoryRulesetRulesBranchNamePatternOutput) ToRepositoryRulesetRulesBranchNamePatternPtrOutput() RepositoryRulesetRulesBranchNamePatternPtrOutput { + return o.ToRepositoryRulesetRulesBranchNamePatternPtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetRulesBranchNamePatternOutput) ToRepositoryRulesetRulesBranchNamePatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesBranchNamePatternPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetRulesBranchNamePattern) *RepositoryRulesetRulesBranchNamePattern { + return &v + }).(RepositoryRulesetRulesBranchNamePatternPtrOutput) +} + +// (String) The name of the ruleset. +func (o RepositoryRulesetRulesBranchNamePatternOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesBranchNamePattern) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o RepositoryRulesetRulesBranchNamePatternOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesBranchNamePattern) *bool { return v.Negate }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o RepositoryRulesetRulesBranchNamePatternOutput) Operator() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetRulesBranchNamePattern) string { return v.Operator }).(pulumi.StringOutput) +} + +// The pattern to match with. +func (o RepositoryRulesetRulesBranchNamePatternOutput) Pattern() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetRulesBranchNamePattern) string { return v.Pattern }).(pulumi.StringOutput) +} + +type RepositoryRulesetRulesBranchNamePatternPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesBranchNamePatternPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesBranchNamePattern)(nil)).Elem() +} + +func (o RepositoryRulesetRulesBranchNamePatternPtrOutput) ToRepositoryRulesetRulesBranchNamePatternPtrOutput() RepositoryRulesetRulesBranchNamePatternPtrOutput { + return o +} + +func (o RepositoryRulesetRulesBranchNamePatternPtrOutput) ToRepositoryRulesetRulesBranchNamePatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesBranchNamePatternPtrOutput { + return o +} + +func (o RepositoryRulesetRulesBranchNamePatternPtrOutput) Elem() RepositoryRulesetRulesBranchNamePatternOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesBranchNamePattern) RepositoryRulesetRulesBranchNamePattern { + if v != nil { + return *v + } + var ret RepositoryRulesetRulesBranchNamePattern + return ret + }).(RepositoryRulesetRulesBranchNamePatternOutput) +} + +// (String) The name of the ruleset. +func (o RepositoryRulesetRulesBranchNamePatternPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesBranchNamePattern) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o RepositoryRulesetRulesBranchNamePatternPtrOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesBranchNamePattern) *bool { + if v == nil { + return nil + } + return v.Negate + }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o RepositoryRulesetRulesBranchNamePatternPtrOutput) Operator() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesBranchNamePattern) *string { + if v == nil { + return nil + } + return &v.Operator + }).(pulumi.StringPtrOutput) +} + +// The pattern to match with. +func (o RepositoryRulesetRulesBranchNamePatternPtrOutput) Pattern() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesBranchNamePattern) *string { + if v == nil { + return nil + } + return &v.Pattern + }).(pulumi.StringPtrOutput) +} + +type RepositoryRulesetRulesCommitAuthorEmailPattern struct { + // (String) The name of the ruleset. + Name *string `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate *bool `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator string `pulumi:"operator"` + // The pattern to match with. + Pattern string `pulumi:"pattern"` +} + +// RepositoryRulesetRulesCommitAuthorEmailPatternInput is an input type that accepts RepositoryRulesetRulesCommitAuthorEmailPatternArgs and RepositoryRulesetRulesCommitAuthorEmailPatternOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesCommitAuthorEmailPatternInput` via: +// +// RepositoryRulesetRulesCommitAuthorEmailPatternArgs{...} +type RepositoryRulesetRulesCommitAuthorEmailPatternInput interface { + pulumi.Input + + ToRepositoryRulesetRulesCommitAuthorEmailPatternOutput() RepositoryRulesetRulesCommitAuthorEmailPatternOutput + ToRepositoryRulesetRulesCommitAuthorEmailPatternOutputWithContext(context.Context) RepositoryRulesetRulesCommitAuthorEmailPatternOutput +} + +type RepositoryRulesetRulesCommitAuthorEmailPatternArgs struct { + // (String) The name of the ruleset. + Name pulumi.StringPtrInput `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate pulumi.BoolPtrInput `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator pulumi.StringInput `pulumi:"operator"` + // The pattern to match with. + Pattern pulumi.StringInput `pulumi:"pattern"` +} + +func (RepositoryRulesetRulesCommitAuthorEmailPatternArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesCommitAuthorEmailPattern)(nil)).Elem() +} + +func (i RepositoryRulesetRulesCommitAuthorEmailPatternArgs) ToRepositoryRulesetRulesCommitAuthorEmailPatternOutput() RepositoryRulesetRulesCommitAuthorEmailPatternOutput { + return i.ToRepositoryRulesetRulesCommitAuthorEmailPatternOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesCommitAuthorEmailPatternArgs) ToRepositoryRulesetRulesCommitAuthorEmailPatternOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitAuthorEmailPatternOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesCommitAuthorEmailPatternOutput) +} + +func (i RepositoryRulesetRulesCommitAuthorEmailPatternArgs) ToRepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput() RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput { + return i.ToRepositoryRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesCommitAuthorEmailPatternArgs) ToRepositoryRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesCommitAuthorEmailPatternOutput).ToRepositoryRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(ctx) +} + +// RepositoryRulesetRulesCommitAuthorEmailPatternPtrInput is an input type that accepts RepositoryRulesetRulesCommitAuthorEmailPatternArgs, RepositoryRulesetRulesCommitAuthorEmailPatternPtr and RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesCommitAuthorEmailPatternPtrInput` via: +// +// RepositoryRulesetRulesCommitAuthorEmailPatternArgs{...} +// +// or: +// +// nil +type RepositoryRulesetRulesCommitAuthorEmailPatternPtrInput interface { + pulumi.Input + + ToRepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput() RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput + ToRepositoryRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(context.Context) RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput +} + +type repositoryRulesetRulesCommitAuthorEmailPatternPtrType RepositoryRulesetRulesCommitAuthorEmailPatternArgs + +func RepositoryRulesetRulesCommitAuthorEmailPatternPtr(v *RepositoryRulesetRulesCommitAuthorEmailPatternArgs) RepositoryRulesetRulesCommitAuthorEmailPatternPtrInput { + return (*repositoryRulesetRulesCommitAuthorEmailPatternPtrType)(v) +} + +func (*repositoryRulesetRulesCommitAuthorEmailPatternPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesCommitAuthorEmailPattern)(nil)).Elem() +} + +func (i *repositoryRulesetRulesCommitAuthorEmailPatternPtrType) ToRepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput() RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput { + return i.ToRepositoryRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetRulesCommitAuthorEmailPatternPtrType) ToRepositoryRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput) +} + +type RepositoryRulesetRulesCommitAuthorEmailPatternOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesCommitAuthorEmailPatternOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesCommitAuthorEmailPattern)(nil)).Elem() +} + +func (o RepositoryRulesetRulesCommitAuthorEmailPatternOutput) ToRepositoryRulesetRulesCommitAuthorEmailPatternOutput() RepositoryRulesetRulesCommitAuthorEmailPatternOutput { + return o +} + +func (o RepositoryRulesetRulesCommitAuthorEmailPatternOutput) ToRepositoryRulesetRulesCommitAuthorEmailPatternOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitAuthorEmailPatternOutput { + return o +} + +func (o RepositoryRulesetRulesCommitAuthorEmailPatternOutput) ToRepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput() RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput { + return o.ToRepositoryRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetRulesCommitAuthorEmailPatternOutput) ToRepositoryRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetRulesCommitAuthorEmailPattern) *RepositoryRulesetRulesCommitAuthorEmailPattern { + return &v + }).(RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput) +} + +// (String) The name of the ruleset. +func (o RepositoryRulesetRulesCommitAuthorEmailPatternOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesCommitAuthorEmailPattern) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o RepositoryRulesetRulesCommitAuthorEmailPatternOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesCommitAuthorEmailPattern) *bool { return v.Negate }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o RepositoryRulesetRulesCommitAuthorEmailPatternOutput) Operator() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetRulesCommitAuthorEmailPattern) string { return v.Operator }).(pulumi.StringOutput) +} + +// The pattern to match with. +func (o RepositoryRulesetRulesCommitAuthorEmailPatternOutput) Pattern() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetRulesCommitAuthorEmailPattern) string { return v.Pattern }).(pulumi.StringOutput) +} + +type RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesCommitAuthorEmailPattern)(nil)).Elem() +} + +func (o RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput) ToRepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput() RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput { + return o +} + +func (o RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput) ToRepositoryRulesetRulesCommitAuthorEmailPatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput { + return o +} + +func (o RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput) Elem() RepositoryRulesetRulesCommitAuthorEmailPatternOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCommitAuthorEmailPattern) RepositoryRulesetRulesCommitAuthorEmailPattern { + if v != nil { + return *v + } + var ret RepositoryRulesetRulesCommitAuthorEmailPattern + return ret + }).(RepositoryRulesetRulesCommitAuthorEmailPatternOutput) +} + +// (String) The name of the ruleset. +func (o RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCommitAuthorEmailPattern) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCommitAuthorEmailPattern) *bool { + if v == nil { + return nil + } + return v.Negate + }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput) Operator() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCommitAuthorEmailPattern) *string { + if v == nil { + return nil + } + return &v.Operator + }).(pulumi.StringPtrOutput) +} + +// The pattern to match with. +func (o RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput) Pattern() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCommitAuthorEmailPattern) *string { + if v == nil { + return nil + } + return &v.Pattern + }).(pulumi.StringPtrOutput) +} + +type RepositoryRulesetRulesCommitMessagePattern struct { + // (String) The name of the ruleset. + Name *string `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate *bool `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator string `pulumi:"operator"` + // The pattern to match with. + Pattern string `pulumi:"pattern"` +} + +// RepositoryRulesetRulesCommitMessagePatternInput is an input type that accepts RepositoryRulesetRulesCommitMessagePatternArgs and RepositoryRulesetRulesCommitMessagePatternOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesCommitMessagePatternInput` via: +// +// RepositoryRulesetRulesCommitMessagePatternArgs{...} +type RepositoryRulesetRulesCommitMessagePatternInput interface { + pulumi.Input + + ToRepositoryRulesetRulesCommitMessagePatternOutput() RepositoryRulesetRulesCommitMessagePatternOutput + ToRepositoryRulesetRulesCommitMessagePatternOutputWithContext(context.Context) RepositoryRulesetRulesCommitMessagePatternOutput +} + +type RepositoryRulesetRulesCommitMessagePatternArgs struct { + // (String) The name of the ruleset. + Name pulumi.StringPtrInput `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate pulumi.BoolPtrInput `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator pulumi.StringInput `pulumi:"operator"` + // The pattern to match with. + Pattern pulumi.StringInput `pulumi:"pattern"` +} + +func (RepositoryRulesetRulesCommitMessagePatternArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesCommitMessagePattern)(nil)).Elem() +} + +func (i RepositoryRulesetRulesCommitMessagePatternArgs) ToRepositoryRulesetRulesCommitMessagePatternOutput() RepositoryRulesetRulesCommitMessagePatternOutput { + return i.ToRepositoryRulesetRulesCommitMessagePatternOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesCommitMessagePatternArgs) ToRepositoryRulesetRulesCommitMessagePatternOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitMessagePatternOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesCommitMessagePatternOutput) +} + +func (i RepositoryRulesetRulesCommitMessagePatternArgs) ToRepositoryRulesetRulesCommitMessagePatternPtrOutput() RepositoryRulesetRulesCommitMessagePatternPtrOutput { + return i.ToRepositoryRulesetRulesCommitMessagePatternPtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesCommitMessagePatternArgs) ToRepositoryRulesetRulesCommitMessagePatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitMessagePatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesCommitMessagePatternOutput).ToRepositoryRulesetRulesCommitMessagePatternPtrOutputWithContext(ctx) +} + +// RepositoryRulesetRulesCommitMessagePatternPtrInput is an input type that accepts RepositoryRulesetRulesCommitMessagePatternArgs, RepositoryRulesetRulesCommitMessagePatternPtr and RepositoryRulesetRulesCommitMessagePatternPtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesCommitMessagePatternPtrInput` via: +// +// RepositoryRulesetRulesCommitMessagePatternArgs{...} +// +// or: +// +// nil +type RepositoryRulesetRulesCommitMessagePatternPtrInput interface { + pulumi.Input + + ToRepositoryRulesetRulesCommitMessagePatternPtrOutput() RepositoryRulesetRulesCommitMessagePatternPtrOutput + ToRepositoryRulesetRulesCommitMessagePatternPtrOutputWithContext(context.Context) RepositoryRulesetRulesCommitMessagePatternPtrOutput +} + +type repositoryRulesetRulesCommitMessagePatternPtrType RepositoryRulesetRulesCommitMessagePatternArgs + +func RepositoryRulesetRulesCommitMessagePatternPtr(v *RepositoryRulesetRulesCommitMessagePatternArgs) RepositoryRulesetRulesCommitMessagePatternPtrInput { + return (*repositoryRulesetRulesCommitMessagePatternPtrType)(v) +} + +func (*repositoryRulesetRulesCommitMessagePatternPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesCommitMessagePattern)(nil)).Elem() +} + +func (i *repositoryRulesetRulesCommitMessagePatternPtrType) ToRepositoryRulesetRulesCommitMessagePatternPtrOutput() RepositoryRulesetRulesCommitMessagePatternPtrOutput { + return i.ToRepositoryRulesetRulesCommitMessagePatternPtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetRulesCommitMessagePatternPtrType) ToRepositoryRulesetRulesCommitMessagePatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitMessagePatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesCommitMessagePatternPtrOutput) +} + +type RepositoryRulesetRulesCommitMessagePatternOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesCommitMessagePatternOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesCommitMessagePattern)(nil)).Elem() +} + +func (o RepositoryRulesetRulesCommitMessagePatternOutput) ToRepositoryRulesetRulesCommitMessagePatternOutput() RepositoryRulesetRulesCommitMessagePatternOutput { + return o +} + +func (o RepositoryRulesetRulesCommitMessagePatternOutput) ToRepositoryRulesetRulesCommitMessagePatternOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitMessagePatternOutput { + return o +} + +func (o RepositoryRulesetRulesCommitMessagePatternOutput) ToRepositoryRulesetRulesCommitMessagePatternPtrOutput() RepositoryRulesetRulesCommitMessagePatternPtrOutput { + return o.ToRepositoryRulesetRulesCommitMessagePatternPtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetRulesCommitMessagePatternOutput) ToRepositoryRulesetRulesCommitMessagePatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitMessagePatternPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetRulesCommitMessagePattern) *RepositoryRulesetRulesCommitMessagePattern { + return &v + }).(RepositoryRulesetRulesCommitMessagePatternPtrOutput) +} + +// (String) The name of the ruleset. +func (o RepositoryRulesetRulesCommitMessagePatternOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesCommitMessagePattern) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o RepositoryRulesetRulesCommitMessagePatternOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesCommitMessagePattern) *bool { return v.Negate }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o RepositoryRulesetRulesCommitMessagePatternOutput) Operator() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetRulesCommitMessagePattern) string { return v.Operator }).(pulumi.StringOutput) +} + +// The pattern to match with. +func (o RepositoryRulesetRulesCommitMessagePatternOutput) Pattern() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetRulesCommitMessagePattern) string { return v.Pattern }).(pulumi.StringOutput) +} + +type RepositoryRulesetRulesCommitMessagePatternPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesCommitMessagePatternPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesCommitMessagePattern)(nil)).Elem() +} + +func (o RepositoryRulesetRulesCommitMessagePatternPtrOutput) ToRepositoryRulesetRulesCommitMessagePatternPtrOutput() RepositoryRulesetRulesCommitMessagePatternPtrOutput { + return o +} + +func (o RepositoryRulesetRulesCommitMessagePatternPtrOutput) ToRepositoryRulesetRulesCommitMessagePatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitMessagePatternPtrOutput { + return o +} + +func (o RepositoryRulesetRulesCommitMessagePatternPtrOutput) Elem() RepositoryRulesetRulesCommitMessagePatternOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCommitMessagePattern) RepositoryRulesetRulesCommitMessagePattern { + if v != nil { + return *v + } + var ret RepositoryRulesetRulesCommitMessagePattern + return ret + }).(RepositoryRulesetRulesCommitMessagePatternOutput) +} + +// (String) The name of the ruleset. +func (o RepositoryRulesetRulesCommitMessagePatternPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCommitMessagePattern) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o RepositoryRulesetRulesCommitMessagePatternPtrOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCommitMessagePattern) *bool { + if v == nil { + return nil + } + return v.Negate + }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o RepositoryRulesetRulesCommitMessagePatternPtrOutput) Operator() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCommitMessagePattern) *string { + if v == nil { + return nil + } + return &v.Operator + }).(pulumi.StringPtrOutput) +} + +// The pattern to match with. +func (o RepositoryRulesetRulesCommitMessagePatternPtrOutput) Pattern() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCommitMessagePattern) *string { + if v == nil { + return nil + } + return &v.Pattern + }).(pulumi.StringPtrOutput) +} + +type RepositoryRulesetRulesCommitterEmailPattern struct { + // (String) The name of the ruleset. + Name *string `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate *bool `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator string `pulumi:"operator"` + // The pattern to match with. + Pattern string `pulumi:"pattern"` +} + +// RepositoryRulesetRulesCommitterEmailPatternInput is an input type that accepts RepositoryRulesetRulesCommitterEmailPatternArgs and RepositoryRulesetRulesCommitterEmailPatternOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesCommitterEmailPatternInput` via: +// +// RepositoryRulesetRulesCommitterEmailPatternArgs{...} +type RepositoryRulesetRulesCommitterEmailPatternInput interface { + pulumi.Input + + ToRepositoryRulesetRulesCommitterEmailPatternOutput() RepositoryRulesetRulesCommitterEmailPatternOutput + ToRepositoryRulesetRulesCommitterEmailPatternOutputWithContext(context.Context) RepositoryRulesetRulesCommitterEmailPatternOutput +} + +type RepositoryRulesetRulesCommitterEmailPatternArgs struct { + // (String) The name of the ruleset. + Name pulumi.StringPtrInput `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate pulumi.BoolPtrInput `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator pulumi.StringInput `pulumi:"operator"` + // The pattern to match with. + Pattern pulumi.StringInput `pulumi:"pattern"` +} + +func (RepositoryRulesetRulesCommitterEmailPatternArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesCommitterEmailPattern)(nil)).Elem() +} + +func (i RepositoryRulesetRulesCommitterEmailPatternArgs) ToRepositoryRulesetRulesCommitterEmailPatternOutput() RepositoryRulesetRulesCommitterEmailPatternOutput { + return i.ToRepositoryRulesetRulesCommitterEmailPatternOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesCommitterEmailPatternArgs) ToRepositoryRulesetRulesCommitterEmailPatternOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitterEmailPatternOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesCommitterEmailPatternOutput) +} + +func (i RepositoryRulesetRulesCommitterEmailPatternArgs) ToRepositoryRulesetRulesCommitterEmailPatternPtrOutput() RepositoryRulesetRulesCommitterEmailPatternPtrOutput { + return i.ToRepositoryRulesetRulesCommitterEmailPatternPtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesCommitterEmailPatternArgs) ToRepositoryRulesetRulesCommitterEmailPatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitterEmailPatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesCommitterEmailPatternOutput).ToRepositoryRulesetRulesCommitterEmailPatternPtrOutputWithContext(ctx) +} + +// RepositoryRulesetRulesCommitterEmailPatternPtrInput is an input type that accepts RepositoryRulesetRulesCommitterEmailPatternArgs, RepositoryRulesetRulesCommitterEmailPatternPtr and RepositoryRulesetRulesCommitterEmailPatternPtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesCommitterEmailPatternPtrInput` via: +// +// RepositoryRulesetRulesCommitterEmailPatternArgs{...} +// +// or: +// +// nil +type RepositoryRulesetRulesCommitterEmailPatternPtrInput interface { + pulumi.Input + + ToRepositoryRulesetRulesCommitterEmailPatternPtrOutput() RepositoryRulesetRulesCommitterEmailPatternPtrOutput + ToRepositoryRulesetRulesCommitterEmailPatternPtrOutputWithContext(context.Context) RepositoryRulesetRulesCommitterEmailPatternPtrOutput +} + +type repositoryRulesetRulesCommitterEmailPatternPtrType RepositoryRulesetRulesCommitterEmailPatternArgs + +func RepositoryRulesetRulesCommitterEmailPatternPtr(v *RepositoryRulesetRulesCommitterEmailPatternArgs) RepositoryRulesetRulesCommitterEmailPatternPtrInput { + return (*repositoryRulesetRulesCommitterEmailPatternPtrType)(v) +} + +func (*repositoryRulesetRulesCommitterEmailPatternPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesCommitterEmailPattern)(nil)).Elem() +} + +func (i *repositoryRulesetRulesCommitterEmailPatternPtrType) ToRepositoryRulesetRulesCommitterEmailPatternPtrOutput() RepositoryRulesetRulesCommitterEmailPatternPtrOutput { + return i.ToRepositoryRulesetRulesCommitterEmailPatternPtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetRulesCommitterEmailPatternPtrType) ToRepositoryRulesetRulesCommitterEmailPatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitterEmailPatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesCommitterEmailPatternPtrOutput) +} + +type RepositoryRulesetRulesCommitterEmailPatternOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesCommitterEmailPatternOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesCommitterEmailPattern)(nil)).Elem() +} + +func (o RepositoryRulesetRulesCommitterEmailPatternOutput) ToRepositoryRulesetRulesCommitterEmailPatternOutput() RepositoryRulesetRulesCommitterEmailPatternOutput { + return o +} + +func (o RepositoryRulesetRulesCommitterEmailPatternOutput) ToRepositoryRulesetRulesCommitterEmailPatternOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitterEmailPatternOutput { + return o +} + +func (o RepositoryRulesetRulesCommitterEmailPatternOutput) ToRepositoryRulesetRulesCommitterEmailPatternPtrOutput() RepositoryRulesetRulesCommitterEmailPatternPtrOutput { + return o.ToRepositoryRulesetRulesCommitterEmailPatternPtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetRulesCommitterEmailPatternOutput) ToRepositoryRulesetRulesCommitterEmailPatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitterEmailPatternPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetRulesCommitterEmailPattern) *RepositoryRulesetRulesCommitterEmailPattern { + return &v + }).(RepositoryRulesetRulesCommitterEmailPatternPtrOutput) +} + +// (String) The name of the ruleset. +func (o RepositoryRulesetRulesCommitterEmailPatternOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesCommitterEmailPattern) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o RepositoryRulesetRulesCommitterEmailPatternOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesCommitterEmailPattern) *bool { return v.Negate }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o RepositoryRulesetRulesCommitterEmailPatternOutput) Operator() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetRulesCommitterEmailPattern) string { return v.Operator }).(pulumi.StringOutput) +} + +// The pattern to match with. +func (o RepositoryRulesetRulesCommitterEmailPatternOutput) Pattern() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetRulesCommitterEmailPattern) string { return v.Pattern }).(pulumi.StringOutput) +} + +type RepositoryRulesetRulesCommitterEmailPatternPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesCommitterEmailPatternPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesCommitterEmailPattern)(nil)).Elem() +} + +func (o RepositoryRulesetRulesCommitterEmailPatternPtrOutput) ToRepositoryRulesetRulesCommitterEmailPatternPtrOutput() RepositoryRulesetRulesCommitterEmailPatternPtrOutput { + return o +} + +func (o RepositoryRulesetRulesCommitterEmailPatternPtrOutput) ToRepositoryRulesetRulesCommitterEmailPatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesCommitterEmailPatternPtrOutput { + return o +} + +func (o RepositoryRulesetRulesCommitterEmailPatternPtrOutput) Elem() RepositoryRulesetRulesCommitterEmailPatternOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCommitterEmailPattern) RepositoryRulesetRulesCommitterEmailPattern { + if v != nil { + return *v + } + var ret RepositoryRulesetRulesCommitterEmailPattern + return ret + }).(RepositoryRulesetRulesCommitterEmailPatternOutput) +} + +// (String) The name of the ruleset. +func (o RepositoryRulesetRulesCommitterEmailPatternPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCommitterEmailPattern) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o RepositoryRulesetRulesCommitterEmailPatternPtrOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCommitterEmailPattern) *bool { + if v == nil { + return nil + } + return v.Negate + }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o RepositoryRulesetRulesCommitterEmailPatternPtrOutput) Operator() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCommitterEmailPattern) *string { + if v == nil { + return nil + } + return &v.Operator + }).(pulumi.StringPtrOutput) +} + +// The pattern to match with. +func (o RepositoryRulesetRulesCommitterEmailPatternPtrOutput) Pattern() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCommitterEmailPattern) *string { + if v == nil { + return nil + } + return &v.Pattern + }).(pulumi.StringPtrOutput) +} + +type RepositoryRulesetRulesCopilotCodeReview struct { + // Copilot automatically reviews draft pull requests before they are marked as ready for review. Defaults to `false`. + ReviewDraftPullRequests *bool `pulumi:"reviewDraftPullRequests"` + // Copilot automatically reviews each new push to the pull request. Defaults to `false`. + ReviewOnPush *bool `pulumi:"reviewOnPush"` +} + +// RepositoryRulesetRulesCopilotCodeReviewInput is an input type that accepts RepositoryRulesetRulesCopilotCodeReviewArgs and RepositoryRulesetRulesCopilotCodeReviewOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesCopilotCodeReviewInput` via: +// +// RepositoryRulesetRulesCopilotCodeReviewArgs{...} +type RepositoryRulesetRulesCopilotCodeReviewInput interface { + pulumi.Input + + ToRepositoryRulesetRulesCopilotCodeReviewOutput() RepositoryRulesetRulesCopilotCodeReviewOutput + ToRepositoryRulesetRulesCopilotCodeReviewOutputWithContext(context.Context) RepositoryRulesetRulesCopilotCodeReviewOutput +} + +type RepositoryRulesetRulesCopilotCodeReviewArgs struct { + // Copilot automatically reviews draft pull requests before they are marked as ready for review. Defaults to `false`. + ReviewDraftPullRequests pulumi.BoolPtrInput `pulumi:"reviewDraftPullRequests"` + // Copilot automatically reviews each new push to the pull request. Defaults to `false`. + ReviewOnPush pulumi.BoolPtrInput `pulumi:"reviewOnPush"` +} + +func (RepositoryRulesetRulesCopilotCodeReviewArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesCopilotCodeReview)(nil)).Elem() +} + +func (i RepositoryRulesetRulesCopilotCodeReviewArgs) ToRepositoryRulesetRulesCopilotCodeReviewOutput() RepositoryRulesetRulesCopilotCodeReviewOutput { + return i.ToRepositoryRulesetRulesCopilotCodeReviewOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesCopilotCodeReviewArgs) ToRepositoryRulesetRulesCopilotCodeReviewOutputWithContext(ctx context.Context) RepositoryRulesetRulesCopilotCodeReviewOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesCopilotCodeReviewOutput) +} + +func (i RepositoryRulesetRulesCopilotCodeReviewArgs) ToRepositoryRulesetRulesCopilotCodeReviewPtrOutput() RepositoryRulesetRulesCopilotCodeReviewPtrOutput { + return i.ToRepositoryRulesetRulesCopilotCodeReviewPtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesCopilotCodeReviewArgs) ToRepositoryRulesetRulesCopilotCodeReviewPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesCopilotCodeReviewPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesCopilotCodeReviewOutput).ToRepositoryRulesetRulesCopilotCodeReviewPtrOutputWithContext(ctx) +} + +// RepositoryRulesetRulesCopilotCodeReviewPtrInput is an input type that accepts RepositoryRulesetRulesCopilotCodeReviewArgs, RepositoryRulesetRulesCopilotCodeReviewPtr and RepositoryRulesetRulesCopilotCodeReviewPtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesCopilotCodeReviewPtrInput` via: +// +// RepositoryRulesetRulesCopilotCodeReviewArgs{...} +// +// or: +// +// nil +type RepositoryRulesetRulesCopilotCodeReviewPtrInput interface { + pulumi.Input + + ToRepositoryRulesetRulesCopilotCodeReviewPtrOutput() RepositoryRulesetRulesCopilotCodeReviewPtrOutput + ToRepositoryRulesetRulesCopilotCodeReviewPtrOutputWithContext(context.Context) RepositoryRulesetRulesCopilotCodeReviewPtrOutput +} + +type repositoryRulesetRulesCopilotCodeReviewPtrType RepositoryRulesetRulesCopilotCodeReviewArgs + +func RepositoryRulesetRulesCopilotCodeReviewPtr(v *RepositoryRulesetRulesCopilotCodeReviewArgs) RepositoryRulesetRulesCopilotCodeReviewPtrInput { + return (*repositoryRulesetRulesCopilotCodeReviewPtrType)(v) +} + +func (*repositoryRulesetRulesCopilotCodeReviewPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesCopilotCodeReview)(nil)).Elem() +} + +func (i *repositoryRulesetRulesCopilotCodeReviewPtrType) ToRepositoryRulesetRulesCopilotCodeReviewPtrOutput() RepositoryRulesetRulesCopilotCodeReviewPtrOutput { + return i.ToRepositoryRulesetRulesCopilotCodeReviewPtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetRulesCopilotCodeReviewPtrType) ToRepositoryRulesetRulesCopilotCodeReviewPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesCopilotCodeReviewPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesCopilotCodeReviewPtrOutput) +} + +type RepositoryRulesetRulesCopilotCodeReviewOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesCopilotCodeReviewOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesCopilotCodeReview)(nil)).Elem() +} + +func (o RepositoryRulesetRulesCopilotCodeReviewOutput) ToRepositoryRulesetRulesCopilotCodeReviewOutput() RepositoryRulesetRulesCopilotCodeReviewOutput { + return o +} + +func (o RepositoryRulesetRulesCopilotCodeReviewOutput) ToRepositoryRulesetRulesCopilotCodeReviewOutputWithContext(ctx context.Context) RepositoryRulesetRulesCopilotCodeReviewOutput { + return o +} + +func (o RepositoryRulesetRulesCopilotCodeReviewOutput) ToRepositoryRulesetRulesCopilotCodeReviewPtrOutput() RepositoryRulesetRulesCopilotCodeReviewPtrOutput { + return o.ToRepositoryRulesetRulesCopilotCodeReviewPtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetRulesCopilotCodeReviewOutput) ToRepositoryRulesetRulesCopilotCodeReviewPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesCopilotCodeReviewPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetRulesCopilotCodeReview) *RepositoryRulesetRulesCopilotCodeReview { + return &v + }).(RepositoryRulesetRulesCopilotCodeReviewPtrOutput) +} + +// Copilot automatically reviews draft pull requests before they are marked as ready for review. Defaults to `false`. +func (o RepositoryRulesetRulesCopilotCodeReviewOutput) ReviewDraftPullRequests() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesCopilotCodeReview) *bool { return v.ReviewDraftPullRequests }).(pulumi.BoolPtrOutput) +} + +// Copilot automatically reviews each new push to the pull request. Defaults to `false`. +func (o RepositoryRulesetRulesCopilotCodeReviewOutput) ReviewOnPush() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesCopilotCodeReview) *bool { return v.ReviewOnPush }).(pulumi.BoolPtrOutput) +} + +type RepositoryRulesetRulesCopilotCodeReviewPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesCopilotCodeReviewPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesCopilotCodeReview)(nil)).Elem() +} + +func (o RepositoryRulesetRulesCopilotCodeReviewPtrOutput) ToRepositoryRulesetRulesCopilotCodeReviewPtrOutput() RepositoryRulesetRulesCopilotCodeReviewPtrOutput { + return o +} + +func (o RepositoryRulesetRulesCopilotCodeReviewPtrOutput) ToRepositoryRulesetRulesCopilotCodeReviewPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesCopilotCodeReviewPtrOutput { + return o +} + +func (o RepositoryRulesetRulesCopilotCodeReviewPtrOutput) Elem() RepositoryRulesetRulesCopilotCodeReviewOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCopilotCodeReview) RepositoryRulesetRulesCopilotCodeReview { + if v != nil { + return *v + } + var ret RepositoryRulesetRulesCopilotCodeReview + return ret + }).(RepositoryRulesetRulesCopilotCodeReviewOutput) +} + +// Copilot automatically reviews draft pull requests before they are marked as ready for review. Defaults to `false`. +func (o RepositoryRulesetRulesCopilotCodeReviewPtrOutput) ReviewDraftPullRequests() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCopilotCodeReview) *bool { + if v == nil { + return nil + } + return v.ReviewDraftPullRequests + }).(pulumi.BoolPtrOutput) +} + +// Copilot automatically reviews each new push to the pull request. Defaults to `false`. +func (o RepositoryRulesetRulesCopilotCodeReviewPtrOutput) ReviewOnPush() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesCopilotCodeReview) *bool { + if v == nil { + return nil + } + return v.ReviewOnPush + }).(pulumi.BoolPtrOutput) +} + +type RepositoryRulesetRulesFileExtensionRestriction struct { + // A list of file extensions. + RestrictedFileExtensions []string `pulumi:"restrictedFileExtensions"` +} + +// RepositoryRulesetRulesFileExtensionRestrictionInput is an input type that accepts RepositoryRulesetRulesFileExtensionRestrictionArgs and RepositoryRulesetRulesFileExtensionRestrictionOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesFileExtensionRestrictionInput` via: +// +// RepositoryRulesetRulesFileExtensionRestrictionArgs{...} +type RepositoryRulesetRulesFileExtensionRestrictionInput interface { + pulumi.Input + + ToRepositoryRulesetRulesFileExtensionRestrictionOutput() RepositoryRulesetRulesFileExtensionRestrictionOutput + ToRepositoryRulesetRulesFileExtensionRestrictionOutputWithContext(context.Context) RepositoryRulesetRulesFileExtensionRestrictionOutput +} + +type RepositoryRulesetRulesFileExtensionRestrictionArgs struct { + // A list of file extensions. + RestrictedFileExtensions pulumi.StringArrayInput `pulumi:"restrictedFileExtensions"` +} + +func (RepositoryRulesetRulesFileExtensionRestrictionArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesFileExtensionRestriction)(nil)).Elem() +} + +func (i RepositoryRulesetRulesFileExtensionRestrictionArgs) ToRepositoryRulesetRulesFileExtensionRestrictionOutput() RepositoryRulesetRulesFileExtensionRestrictionOutput { + return i.ToRepositoryRulesetRulesFileExtensionRestrictionOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesFileExtensionRestrictionArgs) ToRepositoryRulesetRulesFileExtensionRestrictionOutputWithContext(ctx context.Context) RepositoryRulesetRulesFileExtensionRestrictionOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesFileExtensionRestrictionOutput) +} + +func (i RepositoryRulesetRulesFileExtensionRestrictionArgs) ToRepositoryRulesetRulesFileExtensionRestrictionPtrOutput() RepositoryRulesetRulesFileExtensionRestrictionPtrOutput { + return i.ToRepositoryRulesetRulesFileExtensionRestrictionPtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesFileExtensionRestrictionArgs) ToRepositoryRulesetRulesFileExtensionRestrictionPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesFileExtensionRestrictionPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesFileExtensionRestrictionOutput).ToRepositoryRulesetRulesFileExtensionRestrictionPtrOutputWithContext(ctx) +} + +// RepositoryRulesetRulesFileExtensionRestrictionPtrInput is an input type that accepts RepositoryRulesetRulesFileExtensionRestrictionArgs, RepositoryRulesetRulesFileExtensionRestrictionPtr and RepositoryRulesetRulesFileExtensionRestrictionPtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesFileExtensionRestrictionPtrInput` via: +// +// RepositoryRulesetRulesFileExtensionRestrictionArgs{...} +// +// or: +// +// nil +type RepositoryRulesetRulesFileExtensionRestrictionPtrInput interface { + pulumi.Input + + ToRepositoryRulesetRulesFileExtensionRestrictionPtrOutput() RepositoryRulesetRulesFileExtensionRestrictionPtrOutput + ToRepositoryRulesetRulesFileExtensionRestrictionPtrOutputWithContext(context.Context) RepositoryRulesetRulesFileExtensionRestrictionPtrOutput +} + +type repositoryRulesetRulesFileExtensionRestrictionPtrType RepositoryRulesetRulesFileExtensionRestrictionArgs + +func RepositoryRulesetRulesFileExtensionRestrictionPtr(v *RepositoryRulesetRulesFileExtensionRestrictionArgs) RepositoryRulesetRulesFileExtensionRestrictionPtrInput { + return (*repositoryRulesetRulesFileExtensionRestrictionPtrType)(v) +} + +func (*repositoryRulesetRulesFileExtensionRestrictionPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesFileExtensionRestriction)(nil)).Elem() +} + +func (i *repositoryRulesetRulesFileExtensionRestrictionPtrType) ToRepositoryRulesetRulesFileExtensionRestrictionPtrOutput() RepositoryRulesetRulesFileExtensionRestrictionPtrOutput { + return i.ToRepositoryRulesetRulesFileExtensionRestrictionPtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetRulesFileExtensionRestrictionPtrType) ToRepositoryRulesetRulesFileExtensionRestrictionPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesFileExtensionRestrictionPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesFileExtensionRestrictionPtrOutput) +} + +type RepositoryRulesetRulesFileExtensionRestrictionOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesFileExtensionRestrictionOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesFileExtensionRestriction)(nil)).Elem() +} + +func (o RepositoryRulesetRulesFileExtensionRestrictionOutput) ToRepositoryRulesetRulesFileExtensionRestrictionOutput() RepositoryRulesetRulesFileExtensionRestrictionOutput { + return o +} + +func (o RepositoryRulesetRulesFileExtensionRestrictionOutput) ToRepositoryRulesetRulesFileExtensionRestrictionOutputWithContext(ctx context.Context) RepositoryRulesetRulesFileExtensionRestrictionOutput { + return o +} + +func (o RepositoryRulesetRulesFileExtensionRestrictionOutput) ToRepositoryRulesetRulesFileExtensionRestrictionPtrOutput() RepositoryRulesetRulesFileExtensionRestrictionPtrOutput { + return o.ToRepositoryRulesetRulesFileExtensionRestrictionPtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetRulesFileExtensionRestrictionOutput) ToRepositoryRulesetRulesFileExtensionRestrictionPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesFileExtensionRestrictionPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetRulesFileExtensionRestriction) *RepositoryRulesetRulesFileExtensionRestriction { + return &v + }).(RepositoryRulesetRulesFileExtensionRestrictionPtrOutput) +} + +// A list of file extensions. +func (o RepositoryRulesetRulesFileExtensionRestrictionOutput) RestrictedFileExtensions() pulumi.StringArrayOutput { + return o.ApplyT(func(v RepositoryRulesetRulesFileExtensionRestriction) []string { return v.RestrictedFileExtensions }).(pulumi.StringArrayOutput) +} + +type RepositoryRulesetRulesFileExtensionRestrictionPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesFileExtensionRestrictionPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesFileExtensionRestriction)(nil)).Elem() +} + +func (o RepositoryRulesetRulesFileExtensionRestrictionPtrOutput) ToRepositoryRulesetRulesFileExtensionRestrictionPtrOutput() RepositoryRulesetRulesFileExtensionRestrictionPtrOutput { + return o +} + +func (o RepositoryRulesetRulesFileExtensionRestrictionPtrOutput) ToRepositoryRulesetRulesFileExtensionRestrictionPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesFileExtensionRestrictionPtrOutput { + return o +} + +func (o RepositoryRulesetRulesFileExtensionRestrictionPtrOutput) Elem() RepositoryRulesetRulesFileExtensionRestrictionOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesFileExtensionRestriction) RepositoryRulesetRulesFileExtensionRestriction { + if v != nil { + return *v + } + var ret RepositoryRulesetRulesFileExtensionRestriction + return ret + }).(RepositoryRulesetRulesFileExtensionRestrictionOutput) +} + +// A list of file extensions. +func (o RepositoryRulesetRulesFileExtensionRestrictionPtrOutput) RestrictedFileExtensions() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesFileExtensionRestriction) []string { + if v == nil { + return nil + } + return v.RestrictedFileExtensions + }).(pulumi.StringArrayOutput) +} + +type RepositoryRulesetRulesFilePathRestriction struct { + // The file paths that are restricted from being pushed to the commit graph. + RestrictedFilePaths []string `pulumi:"restrictedFilePaths"` +} + +// RepositoryRulesetRulesFilePathRestrictionInput is an input type that accepts RepositoryRulesetRulesFilePathRestrictionArgs and RepositoryRulesetRulesFilePathRestrictionOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesFilePathRestrictionInput` via: +// +// RepositoryRulesetRulesFilePathRestrictionArgs{...} +type RepositoryRulesetRulesFilePathRestrictionInput interface { + pulumi.Input + + ToRepositoryRulesetRulesFilePathRestrictionOutput() RepositoryRulesetRulesFilePathRestrictionOutput + ToRepositoryRulesetRulesFilePathRestrictionOutputWithContext(context.Context) RepositoryRulesetRulesFilePathRestrictionOutput +} + +type RepositoryRulesetRulesFilePathRestrictionArgs struct { + // The file paths that are restricted from being pushed to the commit graph. + RestrictedFilePaths pulumi.StringArrayInput `pulumi:"restrictedFilePaths"` +} + +func (RepositoryRulesetRulesFilePathRestrictionArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesFilePathRestriction)(nil)).Elem() +} + +func (i RepositoryRulesetRulesFilePathRestrictionArgs) ToRepositoryRulesetRulesFilePathRestrictionOutput() RepositoryRulesetRulesFilePathRestrictionOutput { + return i.ToRepositoryRulesetRulesFilePathRestrictionOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesFilePathRestrictionArgs) ToRepositoryRulesetRulesFilePathRestrictionOutputWithContext(ctx context.Context) RepositoryRulesetRulesFilePathRestrictionOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesFilePathRestrictionOutput) +} + +func (i RepositoryRulesetRulesFilePathRestrictionArgs) ToRepositoryRulesetRulesFilePathRestrictionPtrOutput() RepositoryRulesetRulesFilePathRestrictionPtrOutput { + return i.ToRepositoryRulesetRulesFilePathRestrictionPtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesFilePathRestrictionArgs) ToRepositoryRulesetRulesFilePathRestrictionPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesFilePathRestrictionPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesFilePathRestrictionOutput).ToRepositoryRulesetRulesFilePathRestrictionPtrOutputWithContext(ctx) +} + +// RepositoryRulesetRulesFilePathRestrictionPtrInput is an input type that accepts RepositoryRulesetRulesFilePathRestrictionArgs, RepositoryRulesetRulesFilePathRestrictionPtr and RepositoryRulesetRulesFilePathRestrictionPtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesFilePathRestrictionPtrInput` via: +// +// RepositoryRulesetRulesFilePathRestrictionArgs{...} +// +// or: +// +// nil +type RepositoryRulesetRulesFilePathRestrictionPtrInput interface { + pulumi.Input + + ToRepositoryRulesetRulesFilePathRestrictionPtrOutput() RepositoryRulesetRulesFilePathRestrictionPtrOutput + ToRepositoryRulesetRulesFilePathRestrictionPtrOutputWithContext(context.Context) RepositoryRulesetRulesFilePathRestrictionPtrOutput +} + +type repositoryRulesetRulesFilePathRestrictionPtrType RepositoryRulesetRulesFilePathRestrictionArgs + +func RepositoryRulesetRulesFilePathRestrictionPtr(v *RepositoryRulesetRulesFilePathRestrictionArgs) RepositoryRulesetRulesFilePathRestrictionPtrInput { + return (*repositoryRulesetRulesFilePathRestrictionPtrType)(v) +} + +func (*repositoryRulesetRulesFilePathRestrictionPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesFilePathRestriction)(nil)).Elem() +} + +func (i *repositoryRulesetRulesFilePathRestrictionPtrType) ToRepositoryRulesetRulesFilePathRestrictionPtrOutput() RepositoryRulesetRulesFilePathRestrictionPtrOutput { + return i.ToRepositoryRulesetRulesFilePathRestrictionPtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetRulesFilePathRestrictionPtrType) ToRepositoryRulesetRulesFilePathRestrictionPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesFilePathRestrictionPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesFilePathRestrictionPtrOutput) +} + +type RepositoryRulesetRulesFilePathRestrictionOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesFilePathRestrictionOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesFilePathRestriction)(nil)).Elem() +} + +func (o RepositoryRulesetRulesFilePathRestrictionOutput) ToRepositoryRulesetRulesFilePathRestrictionOutput() RepositoryRulesetRulesFilePathRestrictionOutput { + return o +} + +func (o RepositoryRulesetRulesFilePathRestrictionOutput) ToRepositoryRulesetRulesFilePathRestrictionOutputWithContext(ctx context.Context) RepositoryRulesetRulesFilePathRestrictionOutput { + return o +} + +func (o RepositoryRulesetRulesFilePathRestrictionOutput) ToRepositoryRulesetRulesFilePathRestrictionPtrOutput() RepositoryRulesetRulesFilePathRestrictionPtrOutput { + return o.ToRepositoryRulesetRulesFilePathRestrictionPtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetRulesFilePathRestrictionOutput) ToRepositoryRulesetRulesFilePathRestrictionPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesFilePathRestrictionPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetRulesFilePathRestriction) *RepositoryRulesetRulesFilePathRestriction { + return &v + }).(RepositoryRulesetRulesFilePathRestrictionPtrOutput) +} + +// The file paths that are restricted from being pushed to the commit graph. +func (o RepositoryRulesetRulesFilePathRestrictionOutput) RestrictedFilePaths() pulumi.StringArrayOutput { + return o.ApplyT(func(v RepositoryRulesetRulesFilePathRestriction) []string { return v.RestrictedFilePaths }).(pulumi.StringArrayOutput) +} + +type RepositoryRulesetRulesFilePathRestrictionPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesFilePathRestrictionPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesFilePathRestriction)(nil)).Elem() +} + +func (o RepositoryRulesetRulesFilePathRestrictionPtrOutput) ToRepositoryRulesetRulesFilePathRestrictionPtrOutput() RepositoryRulesetRulesFilePathRestrictionPtrOutput { + return o +} + +func (o RepositoryRulesetRulesFilePathRestrictionPtrOutput) ToRepositoryRulesetRulesFilePathRestrictionPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesFilePathRestrictionPtrOutput { + return o +} + +func (o RepositoryRulesetRulesFilePathRestrictionPtrOutput) Elem() RepositoryRulesetRulesFilePathRestrictionOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesFilePathRestriction) RepositoryRulesetRulesFilePathRestriction { + if v != nil { + return *v + } + var ret RepositoryRulesetRulesFilePathRestriction + return ret + }).(RepositoryRulesetRulesFilePathRestrictionOutput) +} + +// The file paths that are restricted from being pushed to the commit graph. +func (o RepositoryRulesetRulesFilePathRestrictionPtrOutput) RestrictedFilePaths() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesFilePathRestriction) []string { + if v == nil { + return nil + } + return v.RestrictedFilePaths + }).(pulumi.StringArrayOutput) +} + +type RepositoryRulesetRulesMaxFilePathLength struct { + // The maximum allowed length of a file path. + MaxFilePathLength int `pulumi:"maxFilePathLength"` +} + +// RepositoryRulesetRulesMaxFilePathLengthInput is an input type that accepts RepositoryRulesetRulesMaxFilePathLengthArgs and RepositoryRulesetRulesMaxFilePathLengthOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesMaxFilePathLengthInput` via: +// +// RepositoryRulesetRulesMaxFilePathLengthArgs{...} +type RepositoryRulesetRulesMaxFilePathLengthInput interface { + pulumi.Input + + ToRepositoryRulesetRulesMaxFilePathLengthOutput() RepositoryRulesetRulesMaxFilePathLengthOutput + ToRepositoryRulesetRulesMaxFilePathLengthOutputWithContext(context.Context) RepositoryRulesetRulesMaxFilePathLengthOutput +} + +type RepositoryRulesetRulesMaxFilePathLengthArgs struct { + // The maximum allowed length of a file path. + MaxFilePathLength pulumi.IntInput `pulumi:"maxFilePathLength"` +} + +func (RepositoryRulesetRulesMaxFilePathLengthArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesMaxFilePathLength)(nil)).Elem() +} + +func (i RepositoryRulesetRulesMaxFilePathLengthArgs) ToRepositoryRulesetRulesMaxFilePathLengthOutput() RepositoryRulesetRulesMaxFilePathLengthOutput { + return i.ToRepositoryRulesetRulesMaxFilePathLengthOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesMaxFilePathLengthArgs) ToRepositoryRulesetRulesMaxFilePathLengthOutputWithContext(ctx context.Context) RepositoryRulesetRulesMaxFilePathLengthOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesMaxFilePathLengthOutput) +} + +func (i RepositoryRulesetRulesMaxFilePathLengthArgs) ToRepositoryRulesetRulesMaxFilePathLengthPtrOutput() RepositoryRulesetRulesMaxFilePathLengthPtrOutput { + return i.ToRepositoryRulesetRulesMaxFilePathLengthPtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesMaxFilePathLengthArgs) ToRepositoryRulesetRulesMaxFilePathLengthPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesMaxFilePathLengthPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesMaxFilePathLengthOutput).ToRepositoryRulesetRulesMaxFilePathLengthPtrOutputWithContext(ctx) +} + +// RepositoryRulesetRulesMaxFilePathLengthPtrInput is an input type that accepts RepositoryRulesetRulesMaxFilePathLengthArgs, RepositoryRulesetRulesMaxFilePathLengthPtr and RepositoryRulesetRulesMaxFilePathLengthPtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesMaxFilePathLengthPtrInput` via: +// +// RepositoryRulesetRulesMaxFilePathLengthArgs{...} +// +// or: +// +// nil +type RepositoryRulesetRulesMaxFilePathLengthPtrInput interface { + pulumi.Input + + ToRepositoryRulesetRulesMaxFilePathLengthPtrOutput() RepositoryRulesetRulesMaxFilePathLengthPtrOutput + ToRepositoryRulesetRulesMaxFilePathLengthPtrOutputWithContext(context.Context) RepositoryRulesetRulesMaxFilePathLengthPtrOutput +} + +type repositoryRulesetRulesMaxFilePathLengthPtrType RepositoryRulesetRulesMaxFilePathLengthArgs + +func RepositoryRulesetRulesMaxFilePathLengthPtr(v *RepositoryRulesetRulesMaxFilePathLengthArgs) RepositoryRulesetRulesMaxFilePathLengthPtrInput { + return (*repositoryRulesetRulesMaxFilePathLengthPtrType)(v) +} + +func (*repositoryRulesetRulesMaxFilePathLengthPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesMaxFilePathLength)(nil)).Elem() +} + +func (i *repositoryRulesetRulesMaxFilePathLengthPtrType) ToRepositoryRulesetRulesMaxFilePathLengthPtrOutput() RepositoryRulesetRulesMaxFilePathLengthPtrOutput { + return i.ToRepositoryRulesetRulesMaxFilePathLengthPtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetRulesMaxFilePathLengthPtrType) ToRepositoryRulesetRulesMaxFilePathLengthPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesMaxFilePathLengthPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesMaxFilePathLengthPtrOutput) +} + +type RepositoryRulesetRulesMaxFilePathLengthOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesMaxFilePathLengthOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesMaxFilePathLength)(nil)).Elem() +} + +func (o RepositoryRulesetRulesMaxFilePathLengthOutput) ToRepositoryRulesetRulesMaxFilePathLengthOutput() RepositoryRulesetRulesMaxFilePathLengthOutput { + return o +} + +func (o RepositoryRulesetRulesMaxFilePathLengthOutput) ToRepositoryRulesetRulesMaxFilePathLengthOutputWithContext(ctx context.Context) RepositoryRulesetRulesMaxFilePathLengthOutput { + return o +} + +func (o RepositoryRulesetRulesMaxFilePathLengthOutput) ToRepositoryRulesetRulesMaxFilePathLengthPtrOutput() RepositoryRulesetRulesMaxFilePathLengthPtrOutput { + return o.ToRepositoryRulesetRulesMaxFilePathLengthPtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetRulesMaxFilePathLengthOutput) ToRepositoryRulesetRulesMaxFilePathLengthPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesMaxFilePathLengthPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetRulesMaxFilePathLength) *RepositoryRulesetRulesMaxFilePathLength { + return &v + }).(RepositoryRulesetRulesMaxFilePathLengthPtrOutput) +} + +// The maximum allowed length of a file path. +func (o RepositoryRulesetRulesMaxFilePathLengthOutput) MaxFilePathLength() pulumi.IntOutput { + return o.ApplyT(func(v RepositoryRulesetRulesMaxFilePathLength) int { return v.MaxFilePathLength }).(pulumi.IntOutput) +} + +type RepositoryRulesetRulesMaxFilePathLengthPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesMaxFilePathLengthPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesMaxFilePathLength)(nil)).Elem() +} + +func (o RepositoryRulesetRulesMaxFilePathLengthPtrOutput) ToRepositoryRulesetRulesMaxFilePathLengthPtrOutput() RepositoryRulesetRulesMaxFilePathLengthPtrOutput { + return o +} + +func (o RepositoryRulesetRulesMaxFilePathLengthPtrOutput) ToRepositoryRulesetRulesMaxFilePathLengthPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesMaxFilePathLengthPtrOutput { + return o +} + +func (o RepositoryRulesetRulesMaxFilePathLengthPtrOutput) Elem() RepositoryRulesetRulesMaxFilePathLengthOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesMaxFilePathLength) RepositoryRulesetRulesMaxFilePathLength { + if v != nil { + return *v + } + var ret RepositoryRulesetRulesMaxFilePathLength + return ret + }).(RepositoryRulesetRulesMaxFilePathLengthOutput) +} + +// The maximum allowed length of a file path. +func (o RepositoryRulesetRulesMaxFilePathLengthPtrOutput) MaxFilePathLength() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesMaxFilePathLength) *int { + if v == nil { + return nil + } + return &v.MaxFilePathLength + }).(pulumi.IntPtrOutput) +} + +type RepositoryRulesetRulesMaxFileSize struct { + // The maximum allowed size of a file in megabytes (MB). Valid range is 1-100 MB. + MaxFileSize int `pulumi:"maxFileSize"` +} + +// RepositoryRulesetRulesMaxFileSizeInput is an input type that accepts RepositoryRulesetRulesMaxFileSizeArgs and RepositoryRulesetRulesMaxFileSizeOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesMaxFileSizeInput` via: +// +// RepositoryRulesetRulesMaxFileSizeArgs{...} +type RepositoryRulesetRulesMaxFileSizeInput interface { + pulumi.Input + + ToRepositoryRulesetRulesMaxFileSizeOutput() RepositoryRulesetRulesMaxFileSizeOutput + ToRepositoryRulesetRulesMaxFileSizeOutputWithContext(context.Context) RepositoryRulesetRulesMaxFileSizeOutput +} + +type RepositoryRulesetRulesMaxFileSizeArgs struct { + // The maximum allowed size of a file in megabytes (MB). Valid range is 1-100 MB. + MaxFileSize pulumi.IntInput `pulumi:"maxFileSize"` +} + +func (RepositoryRulesetRulesMaxFileSizeArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesMaxFileSize)(nil)).Elem() +} + +func (i RepositoryRulesetRulesMaxFileSizeArgs) ToRepositoryRulesetRulesMaxFileSizeOutput() RepositoryRulesetRulesMaxFileSizeOutput { + return i.ToRepositoryRulesetRulesMaxFileSizeOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesMaxFileSizeArgs) ToRepositoryRulesetRulesMaxFileSizeOutputWithContext(ctx context.Context) RepositoryRulesetRulesMaxFileSizeOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesMaxFileSizeOutput) +} + +func (i RepositoryRulesetRulesMaxFileSizeArgs) ToRepositoryRulesetRulesMaxFileSizePtrOutput() RepositoryRulesetRulesMaxFileSizePtrOutput { + return i.ToRepositoryRulesetRulesMaxFileSizePtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesMaxFileSizeArgs) ToRepositoryRulesetRulesMaxFileSizePtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesMaxFileSizePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesMaxFileSizeOutput).ToRepositoryRulesetRulesMaxFileSizePtrOutputWithContext(ctx) +} + +// RepositoryRulesetRulesMaxFileSizePtrInput is an input type that accepts RepositoryRulesetRulesMaxFileSizeArgs, RepositoryRulesetRulesMaxFileSizePtr and RepositoryRulesetRulesMaxFileSizePtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesMaxFileSizePtrInput` via: +// +// RepositoryRulesetRulesMaxFileSizeArgs{...} +// +// or: +// +// nil +type RepositoryRulesetRulesMaxFileSizePtrInput interface { + pulumi.Input + + ToRepositoryRulesetRulesMaxFileSizePtrOutput() RepositoryRulesetRulesMaxFileSizePtrOutput + ToRepositoryRulesetRulesMaxFileSizePtrOutputWithContext(context.Context) RepositoryRulesetRulesMaxFileSizePtrOutput +} + +type repositoryRulesetRulesMaxFileSizePtrType RepositoryRulesetRulesMaxFileSizeArgs + +func RepositoryRulesetRulesMaxFileSizePtr(v *RepositoryRulesetRulesMaxFileSizeArgs) RepositoryRulesetRulesMaxFileSizePtrInput { + return (*repositoryRulesetRulesMaxFileSizePtrType)(v) +} + +func (*repositoryRulesetRulesMaxFileSizePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesMaxFileSize)(nil)).Elem() +} + +func (i *repositoryRulesetRulesMaxFileSizePtrType) ToRepositoryRulesetRulesMaxFileSizePtrOutput() RepositoryRulesetRulesMaxFileSizePtrOutput { + return i.ToRepositoryRulesetRulesMaxFileSizePtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetRulesMaxFileSizePtrType) ToRepositoryRulesetRulesMaxFileSizePtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesMaxFileSizePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesMaxFileSizePtrOutput) +} + +type RepositoryRulesetRulesMaxFileSizeOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesMaxFileSizeOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesMaxFileSize)(nil)).Elem() +} + +func (o RepositoryRulesetRulesMaxFileSizeOutput) ToRepositoryRulesetRulesMaxFileSizeOutput() RepositoryRulesetRulesMaxFileSizeOutput { + return o +} + +func (o RepositoryRulesetRulesMaxFileSizeOutput) ToRepositoryRulesetRulesMaxFileSizeOutputWithContext(ctx context.Context) RepositoryRulesetRulesMaxFileSizeOutput { + return o +} + +func (o RepositoryRulesetRulesMaxFileSizeOutput) ToRepositoryRulesetRulesMaxFileSizePtrOutput() RepositoryRulesetRulesMaxFileSizePtrOutput { + return o.ToRepositoryRulesetRulesMaxFileSizePtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetRulesMaxFileSizeOutput) ToRepositoryRulesetRulesMaxFileSizePtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesMaxFileSizePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetRulesMaxFileSize) *RepositoryRulesetRulesMaxFileSize { + return &v + }).(RepositoryRulesetRulesMaxFileSizePtrOutput) +} + +// The maximum allowed size of a file in megabytes (MB). Valid range is 1-100 MB. +func (o RepositoryRulesetRulesMaxFileSizeOutput) MaxFileSize() pulumi.IntOutput { + return o.ApplyT(func(v RepositoryRulesetRulesMaxFileSize) int { return v.MaxFileSize }).(pulumi.IntOutput) +} + +type RepositoryRulesetRulesMaxFileSizePtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesMaxFileSizePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesMaxFileSize)(nil)).Elem() +} + +func (o RepositoryRulesetRulesMaxFileSizePtrOutput) ToRepositoryRulesetRulesMaxFileSizePtrOutput() RepositoryRulesetRulesMaxFileSizePtrOutput { + return o +} + +func (o RepositoryRulesetRulesMaxFileSizePtrOutput) ToRepositoryRulesetRulesMaxFileSizePtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesMaxFileSizePtrOutput { + return o +} + +func (o RepositoryRulesetRulesMaxFileSizePtrOutput) Elem() RepositoryRulesetRulesMaxFileSizeOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesMaxFileSize) RepositoryRulesetRulesMaxFileSize { + if v != nil { + return *v + } + var ret RepositoryRulesetRulesMaxFileSize + return ret + }).(RepositoryRulesetRulesMaxFileSizeOutput) +} + +// The maximum allowed size of a file in megabytes (MB). Valid range is 1-100 MB. +func (o RepositoryRulesetRulesMaxFileSizePtrOutput) MaxFileSize() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesMaxFileSize) *int { + if v == nil { + return nil + } + return &v.MaxFileSize + }).(pulumi.IntPtrOutput) +} + +type RepositoryRulesetRulesMergeQueue struct { + // Maximum time for a required status check to report a conclusion. After this much time has elapsed, checks that have not reported a conclusion will be assumed to have failed. Defaults to `60`. + CheckResponseTimeoutMinutes *int `pulumi:"checkResponseTimeoutMinutes"` + // When set to ALLGREEN, the merge commit created by merge queue for each PR in the group must pass all required checks to merge. When set to HEADGREEN, only the commit at the head of the merge group, i.e. the commit containing changes from all of the PRs in the group, must pass its required checks to merge. Can be one of: ALLGREEN, HEADGREEN. Defaults to `ALLGREEN`. + GroupingStrategy *string `pulumi:"groupingStrategy"` + // Limit the number of queued pull requests requesting checks and workflow runs at the same time. Defaults to `5`. + MaxEntriesToBuild *int `pulumi:"maxEntriesToBuild"` + // The maximum number of PRs that will be merged together in a group. Defaults to `5`. + MaxEntriesToMerge *int `pulumi:"maxEntriesToMerge"` + // Method to use when merging changes from queued pull requests. Can be one of: MERGE, SQUASH, REBASE. Defaults to `MERGE`. + MergeMethod *string `pulumi:"mergeMethod"` + // The minimum number of PRs that will be merged together in a group. Defaults to `1`. + MinEntriesToMerge *int `pulumi:"minEntriesToMerge"` + // The time merge queue should wait after the first PR is added to the queue for the minimum group size to be met. After this time has elapsed, the minimum group size will be ignored and a smaller group will be merged. Defaults to `5`. + MinEntriesToMergeWaitMinutes *int `pulumi:"minEntriesToMergeWaitMinutes"` +} + +// RepositoryRulesetRulesMergeQueueInput is an input type that accepts RepositoryRulesetRulesMergeQueueArgs and RepositoryRulesetRulesMergeQueueOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesMergeQueueInput` via: +// +// RepositoryRulesetRulesMergeQueueArgs{...} +type RepositoryRulesetRulesMergeQueueInput interface { + pulumi.Input + + ToRepositoryRulesetRulesMergeQueueOutput() RepositoryRulesetRulesMergeQueueOutput + ToRepositoryRulesetRulesMergeQueueOutputWithContext(context.Context) RepositoryRulesetRulesMergeQueueOutput +} + +type RepositoryRulesetRulesMergeQueueArgs struct { + // Maximum time for a required status check to report a conclusion. After this much time has elapsed, checks that have not reported a conclusion will be assumed to have failed. Defaults to `60`. + CheckResponseTimeoutMinutes pulumi.IntPtrInput `pulumi:"checkResponseTimeoutMinutes"` + // When set to ALLGREEN, the merge commit created by merge queue for each PR in the group must pass all required checks to merge. When set to HEADGREEN, only the commit at the head of the merge group, i.e. the commit containing changes from all of the PRs in the group, must pass its required checks to merge. Can be one of: ALLGREEN, HEADGREEN. Defaults to `ALLGREEN`. + GroupingStrategy pulumi.StringPtrInput `pulumi:"groupingStrategy"` + // Limit the number of queued pull requests requesting checks and workflow runs at the same time. Defaults to `5`. + MaxEntriesToBuild pulumi.IntPtrInput `pulumi:"maxEntriesToBuild"` + // The maximum number of PRs that will be merged together in a group. Defaults to `5`. + MaxEntriesToMerge pulumi.IntPtrInput `pulumi:"maxEntriesToMerge"` + // Method to use when merging changes from queued pull requests. Can be one of: MERGE, SQUASH, REBASE. Defaults to `MERGE`. + MergeMethod pulumi.StringPtrInput `pulumi:"mergeMethod"` + // The minimum number of PRs that will be merged together in a group. Defaults to `1`. + MinEntriesToMerge pulumi.IntPtrInput `pulumi:"minEntriesToMerge"` + // The time merge queue should wait after the first PR is added to the queue for the minimum group size to be met. After this time has elapsed, the minimum group size will be ignored and a smaller group will be merged. Defaults to `5`. + MinEntriesToMergeWaitMinutes pulumi.IntPtrInput `pulumi:"minEntriesToMergeWaitMinutes"` +} + +func (RepositoryRulesetRulesMergeQueueArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesMergeQueue)(nil)).Elem() +} + +func (i RepositoryRulesetRulesMergeQueueArgs) ToRepositoryRulesetRulesMergeQueueOutput() RepositoryRulesetRulesMergeQueueOutput { + return i.ToRepositoryRulesetRulesMergeQueueOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesMergeQueueArgs) ToRepositoryRulesetRulesMergeQueueOutputWithContext(ctx context.Context) RepositoryRulesetRulesMergeQueueOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesMergeQueueOutput) +} + +func (i RepositoryRulesetRulesMergeQueueArgs) ToRepositoryRulesetRulesMergeQueuePtrOutput() RepositoryRulesetRulesMergeQueuePtrOutput { + return i.ToRepositoryRulesetRulesMergeQueuePtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesMergeQueueArgs) ToRepositoryRulesetRulesMergeQueuePtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesMergeQueuePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesMergeQueueOutput).ToRepositoryRulesetRulesMergeQueuePtrOutputWithContext(ctx) +} + +// RepositoryRulesetRulesMergeQueuePtrInput is an input type that accepts RepositoryRulesetRulesMergeQueueArgs, RepositoryRulesetRulesMergeQueuePtr and RepositoryRulesetRulesMergeQueuePtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesMergeQueuePtrInput` via: +// +// RepositoryRulesetRulesMergeQueueArgs{...} +// +// or: +// +// nil +type RepositoryRulesetRulesMergeQueuePtrInput interface { + pulumi.Input + + ToRepositoryRulesetRulesMergeQueuePtrOutput() RepositoryRulesetRulesMergeQueuePtrOutput + ToRepositoryRulesetRulesMergeQueuePtrOutputWithContext(context.Context) RepositoryRulesetRulesMergeQueuePtrOutput +} + +type repositoryRulesetRulesMergeQueuePtrType RepositoryRulesetRulesMergeQueueArgs + +func RepositoryRulesetRulesMergeQueuePtr(v *RepositoryRulesetRulesMergeQueueArgs) RepositoryRulesetRulesMergeQueuePtrInput { + return (*repositoryRulesetRulesMergeQueuePtrType)(v) +} + +func (*repositoryRulesetRulesMergeQueuePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesMergeQueue)(nil)).Elem() +} + +func (i *repositoryRulesetRulesMergeQueuePtrType) ToRepositoryRulesetRulesMergeQueuePtrOutput() RepositoryRulesetRulesMergeQueuePtrOutput { + return i.ToRepositoryRulesetRulesMergeQueuePtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetRulesMergeQueuePtrType) ToRepositoryRulesetRulesMergeQueuePtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesMergeQueuePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesMergeQueuePtrOutput) +} + +type RepositoryRulesetRulesMergeQueueOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesMergeQueueOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesMergeQueue)(nil)).Elem() +} + +func (o RepositoryRulesetRulesMergeQueueOutput) ToRepositoryRulesetRulesMergeQueueOutput() RepositoryRulesetRulesMergeQueueOutput { + return o +} + +func (o RepositoryRulesetRulesMergeQueueOutput) ToRepositoryRulesetRulesMergeQueueOutputWithContext(ctx context.Context) RepositoryRulesetRulesMergeQueueOutput { + return o +} + +func (o RepositoryRulesetRulesMergeQueueOutput) ToRepositoryRulesetRulesMergeQueuePtrOutput() RepositoryRulesetRulesMergeQueuePtrOutput { + return o.ToRepositoryRulesetRulesMergeQueuePtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetRulesMergeQueueOutput) ToRepositoryRulesetRulesMergeQueuePtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesMergeQueuePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetRulesMergeQueue) *RepositoryRulesetRulesMergeQueue { + return &v + }).(RepositoryRulesetRulesMergeQueuePtrOutput) +} + +// Maximum time for a required status check to report a conclusion. After this much time has elapsed, checks that have not reported a conclusion will be assumed to have failed. Defaults to `60`. +func (o RepositoryRulesetRulesMergeQueueOutput) CheckResponseTimeoutMinutes() pulumi.IntPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesMergeQueue) *int { return v.CheckResponseTimeoutMinutes }).(pulumi.IntPtrOutput) +} + +// When set to ALLGREEN, the merge commit created by merge queue for each PR in the group must pass all required checks to merge. When set to HEADGREEN, only the commit at the head of the merge group, i.e. the commit containing changes from all of the PRs in the group, must pass its required checks to merge. Can be one of: ALLGREEN, HEADGREEN. Defaults to `ALLGREEN`. +func (o RepositoryRulesetRulesMergeQueueOutput) GroupingStrategy() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesMergeQueue) *string { return v.GroupingStrategy }).(pulumi.StringPtrOutput) +} + +// Limit the number of queued pull requests requesting checks and workflow runs at the same time. Defaults to `5`. +func (o RepositoryRulesetRulesMergeQueueOutput) MaxEntriesToBuild() pulumi.IntPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesMergeQueue) *int { return v.MaxEntriesToBuild }).(pulumi.IntPtrOutput) +} + +// The maximum number of PRs that will be merged together in a group. Defaults to `5`. +func (o RepositoryRulesetRulesMergeQueueOutput) MaxEntriesToMerge() pulumi.IntPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesMergeQueue) *int { return v.MaxEntriesToMerge }).(pulumi.IntPtrOutput) +} + +// Method to use when merging changes from queued pull requests. Can be one of: MERGE, SQUASH, REBASE. Defaults to `MERGE`. +func (o RepositoryRulesetRulesMergeQueueOutput) MergeMethod() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesMergeQueue) *string { return v.MergeMethod }).(pulumi.StringPtrOutput) +} + +// The minimum number of PRs that will be merged together in a group. Defaults to `1`. +func (o RepositoryRulesetRulesMergeQueueOutput) MinEntriesToMerge() pulumi.IntPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesMergeQueue) *int { return v.MinEntriesToMerge }).(pulumi.IntPtrOutput) +} + +// The time merge queue should wait after the first PR is added to the queue for the minimum group size to be met. After this time has elapsed, the minimum group size will be ignored and a smaller group will be merged. Defaults to `5`. +func (o RepositoryRulesetRulesMergeQueueOutput) MinEntriesToMergeWaitMinutes() pulumi.IntPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesMergeQueue) *int { return v.MinEntriesToMergeWaitMinutes }).(pulumi.IntPtrOutput) +} + +type RepositoryRulesetRulesMergeQueuePtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesMergeQueuePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesMergeQueue)(nil)).Elem() +} + +func (o RepositoryRulesetRulesMergeQueuePtrOutput) ToRepositoryRulesetRulesMergeQueuePtrOutput() RepositoryRulesetRulesMergeQueuePtrOutput { + return o +} + +func (o RepositoryRulesetRulesMergeQueuePtrOutput) ToRepositoryRulesetRulesMergeQueuePtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesMergeQueuePtrOutput { + return o +} + +func (o RepositoryRulesetRulesMergeQueuePtrOutput) Elem() RepositoryRulesetRulesMergeQueueOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesMergeQueue) RepositoryRulesetRulesMergeQueue { + if v != nil { + return *v + } + var ret RepositoryRulesetRulesMergeQueue + return ret + }).(RepositoryRulesetRulesMergeQueueOutput) +} + +// Maximum time for a required status check to report a conclusion. After this much time has elapsed, checks that have not reported a conclusion will be assumed to have failed. Defaults to `60`. +func (o RepositoryRulesetRulesMergeQueuePtrOutput) CheckResponseTimeoutMinutes() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesMergeQueue) *int { + if v == nil { + return nil + } + return v.CheckResponseTimeoutMinutes + }).(pulumi.IntPtrOutput) +} + +// When set to ALLGREEN, the merge commit created by merge queue for each PR in the group must pass all required checks to merge. When set to HEADGREEN, only the commit at the head of the merge group, i.e. the commit containing changes from all of the PRs in the group, must pass its required checks to merge. Can be one of: ALLGREEN, HEADGREEN. Defaults to `ALLGREEN`. +func (o RepositoryRulesetRulesMergeQueuePtrOutput) GroupingStrategy() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesMergeQueue) *string { + if v == nil { + return nil + } + return v.GroupingStrategy + }).(pulumi.StringPtrOutput) +} + +// Limit the number of queued pull requests requesting checks and workflow runs at the same time. Defaults to `5`. +func (o RepositoryRulesetRulesMergeQueuePtrOutput) MaxEntriesToBuild() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesMergeQueue) *int { + if v == nil { + return nil + } + return v.MaxEntriesToBuild + }).(pulumi.IntPtrOutput) +} + +// The maximum number of PRs that will be merged together in a group. Defaults to `5`. +func (o RepositoryRulesetRulesMergeQueuePtrOutput) MaxEntriesToMerge() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesMergeQueue) *int { + if v == nil { + return nil + } + return v.MaxEntriesToMerge + }).(pulumi.IntPtrOutput) +} + +// Method to use when merging changes from queued pull requests. Can be one of: MERGE, SQUASH, REBASE. Defaults to `MERGE`. +func (o RepositoryRulesetRulesMergeQueuePtrOutput) MergeMethod() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesMergeQueue) *string { + if v == nil { + return nil + } + return v.MergeMethod + }).(pulumi.StringPtrOutput) +} + +// The minimum number of PRs that will be merged together in a group. Defaults to `1`. +func (o RepositoryRulesetRulesMergeQueuePtrOutput) MinEntriesToMerge() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesMergeQueue) *int { + if v == nil { + return nil + } + return v.MinEntriesToMerge + }).(pulumi.IntPtrOutput) +} + +// The time merge queue should wait after the first PR is added to the queue for the minimum group size to be met. After this time has elapsed, the minimum group size will be ignored and a smaller group will be merged. Defaults to `5`. +func (o RepositoryRulesetRulesMergeQueuePtrOutput) MinEntriesToMergeWaitMinutes() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesMergeQueue) *int { + if v == nil { + return nil + } + return v.MinEntriesToMergeWaitMinutes + }).(pulumi.IntPtrOutput) +} + +type RepositoryRulesetRulesPullRequest struct { + // Array of allowed merge methods. Allowed values include `merge`, `squash`, and `rebase`. At least one option must be enabled. + AllowedMergeMethods []string `pulumi:"allowedMergeMethods"` + // New, reviewable commits pushed will dismiss previous pull request review approvals. Defaults to `false`. + DismissStaleReviewsOnPush *bool `pulumi:"dismissStaleReviewsOnPush"` + // Require an approving review in pull requests that modify files that have a designated code owner. Defaults to `false`. + RequireCodeOwnerReview *bool `pulumi:"requireCodeOwnerReview"` + // Whether the most recent reviewable push must be approved by someone other than the person who pushed it. Defaults to `false`. + RequireLastPushApproval *bool `pulumi:"requireLastPushApproval"` + // The number of approving reviews that are required before a pull request can be merged. Defaults to `0`. + RequiredApprovingReviewCount *int `pulumi:"requiredApprovingReviewCount"` + // All conversations on code must be resolved before a pull request can be merged. Defaults to `false`. + RequiredReviewThreadResolution *bool `pulumi:"requiredReviewThreadResolution"` + // Require specific reviewers to approve pull requests targeting matching branches. Note: This feature is in beta and subject to change. + RequiredReviewers []RepositoryRulesetRulesPullRequestRequiredReviewer `pulumi:"requiredReviewers"` +} + +// RepositoryRulesetRulesPullRequestInput is an input type that accepts RepositoryRulesetRulesPullRequestArgs and RepositoryRulesetRulesPullRequestOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesPullRequestInput` via: +// +// RepositoryRulesetRulesPullRequestArgs{...} +type RepositoryRulesetRulesPullRequestInput interface { + pulumi.Input + + ToRepositoryRulesetRulesPullRequestOutput() RepositoryRulesetRulesPullRequestOutput + ToRepositoryRulesetRulesPullRequestOutputWithContext(context.Context) RepositoryRulesetRulesPullRequestOutput +} + +type RepositoryRulesetRulesPullRequestArgs struct { + // Array of allowed merge methods. Allowed values include `merge`, `squash`, and `rebase`. At least one option must be enabled. + AllowedMergeMethods pulumi.StringArrayInput `pulumi:"allowedMergeMethods"` + // New, reviewable commits pushed will dismiss previous pull request review approvals. Defaults to `false`. + DismissStaleReviewsOnPush pulumi.BoolPtrInput `pulumi:"dismissStaleReviewsOnPush"` + // Require an approving review in pull requests that modify files that have a designated code owner. Defaults to `false`. + RequireCodeOwnerReview pulumi.BoolPtrInput `pulumi:"requireCodeOwnerReview"` + // Whether the most recent reviewable push must be approved by someone other than the person who pushed it. Defaults to `false`. + RequireLastPushApproval pulumi.BoolPtrInput `pulumi:"requireLastPushApproval"` + // The number of approving reviews that are required before a pull request can be merged. Defaults to `0`. + RequiredApprovingReviewCount pulumi.IntPtrInput `pulumi:"requiredApprovingReviewCount"` + // All conversations on code must be resolved before a pull request can be merged. Defaults to `false`. + RequiredReviewThreadResolution pulumi.BoolPtrInput `pulumi:"requiredReviewThreadResolution"` + // Require specific reviewers to approve pull requests targeting matching branches. Note: This feature is in beta and subject to change. + RequiredReviewers RepositoryRulesetRulesPullRequestRequiredReviewerArrayInput `pulumi:"requiredReviewers"` +} + +func (RepositoryRulesetRulesPullRequestArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesPullRequest)(nil)).Elem() +} + +func (i RepositoryRulesetRulesPullRequestArgs) ToRepositoryRulesetRulesPullRequestOutput() RepositoryRulesetRulesPullRequestOutput { + return i.ToRepositoryRulesetRulesPullRequestOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesPullRequestArgs) ToRepositoryRulesetRulesPullRequestOutputWithContext(ctx context.Context) RepositoryRulesetRulesPullRequestOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesPullRequestOutput) +} + +func (i RepositoryRulesetRulesPullRequestArgs) ToRepositoryRulesetRulesPullRequestPtrOutput() RepositoryRulesetRulesPullRequestPtrOutput { + return i.ToRepositoryRulesetRulesPullRequestPtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesPullRequestArgs) ToRepositoryRulesetRulesPullRequestPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesPullRequestPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesPullRequestOutput).ToRepositoryRulesetRulesPullRequestPtrOutputWithContext(ctx) +} + +// RepositoryRulesetRulesPullRequestPtrInput is an input type that accepts RepositoryRulesetRulesPullRequestArgs, RepositoryRulesetRulesPullRequestPtr and RepositoryRulesetRulesPullRequestPtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesPullRequestPtrInput` via: +// +// RepositoryRulesetRulesPullRequestArgs{...} +// +// or: +// +// nil +type RepositoryRulesetRulesPullRequestPtrInput interface { + pulumi.Input + + ToRepositoryRulesetRulesPullRequestPtrOutput() RepositoryRulesetRulesPullRequestPtrOutput + ToRepositoryRulesetRulesPullRequestPtrOutputWithContext(context.Context) RepositoryRulesetRulesPullRequestPtrOutput +} + +type repositoryRulesetRulesPullRequestPtrType RepositoryRulesetRulesPullRequestArgs + +func RepositoryRulesetRulesPullRequestPtr(v *RepositoryRulesetRulesPullRequestArgs) RepositoryRulesetRulesPullRequestPtrInput { + return (*repositoryRulesetRulesPullRequestPtrType)(v) +} + +func (*repositoryRulesetRulesPullRequestPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesPullRequest)(nil)).Elem() +} + +func (i *repositoryRulesetRulesPullRequestPtrType) ToRepositoryRulesetRulesPullRequestPtrOutput() RepositoryRulesetRulesPullRequestPtrOutput { + return i.ToRepositoryRulesetRulesPullRequestPtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetRulesPullRequestPtrType) ToRepositoryRulesetRulesPullRequestPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesPullRequestPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesPullRequestPtrOutput) +} + +type RepositoryRulesetRulesPullRequestOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesPullRequestOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesPullRequest)(nil)).Elem() +} + +func (o RepositoryRulesetRulesPullRequestOutput) ToRepositoryRulesetRulesPullRequestOutput() RepositoryRulesetRulesPullRequestOutput { + return o +} + +func (o RepositoryRulesetRulesPullRequestOutput) ToRepositoryRulesetRulesPullRequestOutputWithContext(ctx context.Context) RepositoryRulesetRulesPullRequestOutput { + return o +} + +func (o RepositoryRulesetRulesPullRequestOutput) ToRepositoryRulesetRulesPullRequestPtrOutput() RepositoryRulesetRulesPullRequestPtrOutput { + return o.ToRepositoryRulesetRulesPullRequestPtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetRulesPullRequestOutput) ToRepositoryRulesetRulesPullRequestPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesPullRequestPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetRulesPullRequest) *RepositoryRulesetRulesPullRequest { + return &v + }).(RepositoryRulesetRulesPullRequestPtrOutput) +} + +// Array of allowed merge methods. Allowed values include `merge`, `squash`, and `rebase`. At least one option must be enabled. +func (o RepositoryRulesetRulesPullRequestOutput) AllowedMergeMethods() pulumi.StringArrayOutput { + return o.ApplyT(func(v RepositoryRulesetRulesPullRequest) []string { return v.AllowedMergeMethods }).(pulumi.StringArrayOutput) +} + +// New, reviewable commits pushed will dismiss previous pull request review approvals. Defaults to `false`. +func (o RepositoryRulesetRulesPullRequestOutput) DismissStaleReviewsOnPush() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesPullRequest) *bool { return v.DismissStaleReviewsOnPush }).(pulumi.BoolPtrOutput) +} + +// Require an approving review in pull requests that modify files that have a designated code owner. Defaults to `false`. +func (o RepositoryRulesetRulesPullRequestOutput) RequireCodeOwnerReview() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesPullRequest) *bool { return v.RequireCodeOwnerReview }).(pulumi.BoolPtrOutput) +} + +// Whether the most recent reviewable push must be approved by someone other than the person who pushed it. Defaults to `false`. +func (o RepositoryRulesetRulesPullRequestOutput) RequireLastPushApproval() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesPullRequest) *bool { return v.RequireLastPushApproval }).(pulumi.BoolPtrOutput) +} + +// The number of approving reviews that are required before a pull request can be merged. Defaults to `0`. +func (o RepositoryRulesetRulesPullRequestOutput) RequiredApprovingReviewCount() pulumi.IntPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesPullRequest) *int { return v.RequiredApprovingReviewCount }).(pulumi.IntPtrOutput) +} + +// All conversations on code must be resolved before a pull request can be merged. Defaults to `false`. +func (o RepositoryRulesetRulesPullRequestOutput) RequiredReviewThreadResolution() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesPullRequest) *bool { return v.RequiredReviewThreadResolution }).(pulumi.BoolPtrOutput) +} + +// Require specific reviewers to approve pull requests targeting matching branches. Note: This feature is in beta and subject to change. +func (o RepositoryRulesetRulesPullRequestOutput) RequiredReviewers() RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput { + return o.ApplyT(func(v RepositoryRulesetRulesPullRequest) []RepositoryRulesetRulesPullRequestRequiredReviewer { + return v.RequiredReviewers + }).(RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput) +} + +type RepositoryRulesetRulesPullRequestPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesPullRequestPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesPullRequest)(nil)).Elem() +} + +func (o RepositoryRulesetRulesPullRequestPtrOutput) ToRepositoryRulesetRulesPullRequestPtrOutput() RepositoryRulesetRulesPullRequestPtrOutput { + return o +} + +func (o RepositoryRulesetRulesPullRequestPtrOutput) ToRepositoryRulesetRulesPullRequestPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesPullRequestPtrOutput { + return o +} + +func (o RepositoryRulesetRulesPullRequestPtrOutput) Elem() RepositoryRulesetRulesPullRequestOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesPullRequest) RepositoryRulesetRulesPullRequest { + if v != nil { + return *v + } + var ret RepositoryRulesetRulesPullRequest + return ret + }).(RepositoryRulesetRulesPullRequestOutput) +} + +// Array of allowed merge methods. Allowed values include `merge`, `squash`, and `rebase`. At least one option must be enabled. +func (o RepositoryRulesetRulesPullRequestPtrOutput) AllowedMergeMethods() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesPullRequest) []string { + if v == nil { + return nil + } + return v.AllowedMergeMethods + }).(pulumi.StringArrayOutput) +} + +// New, reviewable commits pushed will dismiss previous pull request review approvals. Defaults to `false`. +func (o RepositoryRulesetRulesPullRequestPtrOutput) DismissStaleReviewsOnPush() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesPullRequest) *bool { + if v == nil { + return nil + } + return v.DismissStaleReviewsOnPush + }).(pulumi.BoolPtrOutput) +} + +// Require an approving review in pull requests that modify files that have a designated code owner. Defaults to `false`. +func (o RepositoryRulesetRulesPullRequestPtrOutput) RequireCodeOwnerReview() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesPullRequest) *bool { + if v == nil { + return nil + } + return v.RequireCodeOwnerReview + }).(pulumi.BoolPtrOutput) +} + +// Whether the most recent reviewable push must be approved by someone other than the person who pushed it. Defaults to `false`. +func (o RepositoryRulesetRulesPullRequestPtrOutput) RequireLastPushApproval() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesPullRequest) *bool { + if v == nil { + return nil + } + return v.RequireLastPushApproval + }).(pulumi.BoolPtrOutput) +} + +// The number of approving reviews that are required before a pull request can be merged. Defaults to `0`. +func (o RepositoryRulesetRulesPullRequestPtrOutput) RequiredApprovingReviewCount() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesPullRequest) *int { + if v == nil { + return nil + } + return v.RequiredApprovingReviewCount + }).(pulumi.IntPtrOutput) +} + +// All conversations on code must be resolved before a pull request can be merged. Defaults to `false`. +func (o RepositoryRulesetRulesPullRequestPtrOutput) RequiredReviewThreadResolution() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesPullRequest) *bool { + if v == nil { + return nil + } + return v.RequiredReviewThreadResolution + }).(pulumi.BoolPtrOutput) +} + +// Require specific reviewers to approve pull requests targeting matching branches. Note: This feature is in beta and subject to change. +func (o RepositoryRulesetRulesPullRequestPtrOutput) RequiredReviewers() RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesPullRequest) []RepositoryRulesetRulesPullRequestRequiredReviewer { + if v == nil { + return nil + } + return v.RequiredReviewers + }).(RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput) +} + +type RepositoryRulesetRulesPullRequestRequiredReviewer struct { + // File patterns (fnmatch syntax) that this reviewer must approve. + FilePatterns []string `pulumi:"filePatterns"` + // Minimum number of approvals required from this reviewer. Set to 0 to make approval optional. + MinimumApprovals int `pulumi:"minimumApprovals"` + // The reviewer that must review matching files. + Reviewer RepositoryRulesetRulesPullRequestRequiredReviewerReviewer `pulumi:"reviewer"` +} + +// RepositoryRulesetRulesPullRequestRequiredReviewerInput is an input type that accepts RepositoryRulesetRulesPullRequestRequiredReviewerArgs and RepositoryRulesetRulesPullRequestRequiredReviewerOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesPullRequestRequiredReviewerInput` via: +// +// RepositoryRulesetRulesPullRequestRequiredReviewerArgs{...} +type RepositoryRulesetRulesPullRequestRequiredReviewerInput interface { + pulumi.Input + + ToRepositoryRulesetRulesPullRequestRequiredReviewerOutput() RepositoryRulesetRulesPullRequestRequiredReviewerOutput + ToRepositoryRulesetRulesPullRequestRequiredReviewerOutputWithContext(context.Context) RepositoryRulesetRulesPullRequestRequiredReviewerOutput +} + +type RepositoryRulesetRulesPullRequestRequiredReviewerArgs struct { + // File patterns (fnmatch syntax) that this reviewer must approve. + FilePatterns pulumi.StringArrayInput `pulumi:"filePatterns"` + // Minimum number of approvals required from this reviewer. Set to 0 to make approval optional. + MinimumApprovals pulumi.IntInput `pulumi:"minimumApprovals"` + // The reviewer that must review matching files. + Reviewer RepositoryRulesetRulesPullRequestRequiredReviewerReviewerInput `pulumi:"reviewer"` +} + +func (RepositoryRulesetRulesPullRequestRequiredReviewerArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesPullRequestRequiredReviewer)(nil)).Elem() +} + +func (i RepositoryRulesetRulesPullRequestRequiredReviewerArgs) ToRepositoryRulesetRulesPullRequestRequiredReviewerOutput() RepositoryRulesetRulesPullRequestRequiredReviewerOutput { + return i.ToRepositoryRulesetRulesPullRequestRequiredReviewerOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesPullRequestRequiredReviewerArgs) ToRepositoryRulesetRulesPullRequestRequiredReviewerOutputWithContext(ctx context.Context) RepositoryRulesetRulesPullRequestRequiredReviewerOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesPullRequestRequiredReviewerOutput) +} + +// RepositoryRulesetRulesPullRequestRequiredReviewerArrayInput is an input type that accepts RepositoryRulesetRulesPullRequestRequiredReviewerArray and RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesPullRequestRequiredReviewerArrayInput` via: +// +// RepositoryRulesetRulesPullRequestRequiredReviewerArray{ RepositoryRulesetRulesPullRequestRequiredReviewerArgs{...} } +type RepositoryRulesetRulesPullRequestRequiredReviewerArrayInput interface { + pulumi.Input + + ToRepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput() RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput + ToRepositoryRulesetRulesPullRequestRequiredReviewerArrayOutputWithContext(context.Context) RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput +} + +type RepositoryRulesetRulesPullRequestRequiredReviewerArray []RepositoryRulesetRulesPullRequestRequiredReviewerInput + +func (RepositoryRulesetRulesPullRequestRequiredReviewerArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]RepositoryRulesetRulesPullRequestRequiredReviewer)(nil)).Elem() +} + +func (i RepositoryRulesetRulesPullRequestRequiredReviewerArray) ToRepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput() RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput { + return i.ToRepositoryRulesetRulesPullRequestRequiredReviewerArrayOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesPullRequestRequiredReviewerArray) ToRepositoryRulesetRulesPullRequestRequiredReviewerArrayOutputWithContext(ctx context.Context) RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput) +} + +type RepositoryRulesetRulesPullRequestRequiredReviewerOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesPullRequestRequiredReviewerOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesPullRequestRequiredReviewer)(nil)).Elem() +} + +func (o RepositoryRulesetRulesPullRequestRequiredReviewerOutput) ToRepositoryRulesetRulesPullRequestRequiredReviewerOutput() RepositoryRulesetRulesPullRequestRequiredReviewerOutput { + return o +} + +func (o RepositoryRulesetRulesPullRequestRequiredReviewerOutput) ToRepositoryRulesetRulesPullRequestRequiredReviewerOutputWithContext(ctx context.Context) RepositoryRulesetRulesPullRequestRequiredReviewerOutput { + return o +} + +// File patterns (fnmatch syntax) that this reviewer must approve. +func (o RepositoryRulesetRulesPullRequestRequiredReviewerOutput) FilePatterns() pulumi.StringArrayOutput { + return o.ApplyT(func(v RepositoryRulesetRulesPullRequestRequiredReviewer) []string { return v.FilePatterns }).(pulumi.StringArrayOutput) +} + +// Minimum number of approvals required from this reviewer. Set to 0 to make approval optional. +func (o RepositoryRulesetRulesPullRequestRequiredReviewerOutput) MinimumApprovals() pulumi.IntOutput { + return o.ApplyT(func(v RepositoryRulesetRulesPullRequestRequiredReviewer) int { return v.MinimumApprovals }).(pulumi.IntOutput) +} + +// The reviewer that must review matching files. +func (o RepositoryRulesetRulesPullRequestRequiredReviewerOutput) Reviewer() RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput { + return o.ApplyT(func(v RepositoryRulesetRulesPullRequestRequiredReviewer) RepositoryRulesetRulesPullRequestRequiredReviewerReviewer { + return v.Reviewer + }).(RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput) +} + +type RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]RepositoryRulesetRulesPullRequestRequiredReviewer)(nil)).Elem() +} + +func (o RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput) ToRepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput() RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput { + return o +} + +func (o RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput) ToRepositoryRulesetRulesPullRequestRequiredReviewerArrayOutputWithContext(ctx context.Context) RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput { + return o +} + +func (o RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput) Index(i pulumi.IntInput) RepositoryRulesetRulesPullRequestRequiredReviewerOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) RepositoryRulesetRulesPullRequestRequiredReviewer { + return vs[0].([]RepositoryRulesetRulesPullRequestRequiredReviewer)[vs[1].(int)] + }).(RepositoryRulesetRulesPullRequestRequiredReviewerOutput) +} + +type RepositoryRulesetRulesPullRequestRequiredReviewerReviewer struct { + // The ID of the reviewer that must review. + Id int `pulumi:"id"` + // The type of reviewer. Currently only `Team` is supported. + Type string `pulumi:"type"` +} + +// RepositoryRulesetRulesPullRequestRequiredReviewerReviewerInput is an input type that accepts RepositoryRulesetRulesPullRequestRequiredReviewerReviewerArgs and RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesPullRequestRequiredReviewerReviewerInput` via: +// +// RepositoryRulesetRulesPullRequestRequiredReviewerReviewerArgs{...} +type RepositoryRulesetRulesPullRequestRequiredReviewerReviewerInput interface { + pulumi.Input + + ToRepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput() RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput + ToRepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutputWithContext(context.Context) RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput +} + +type RepositoryRulesetRulesPullRequestRequiredReviewerReviewerArgs struct { + // The ID of the reviewer that must review. + Id pulumi.IntInput `pulumi:"id"` + // The type of reviewer. Currently only `Team` is supported. + Type pulumi.StringInput `pulumi:"type"` +} + +func (RepositoryRulesetRulesPullRequestRequiredReviewerReviewerArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesPullRequestRequiredReviewerReviewer)(nil)).Elem() +} + +func (i RepositoryRulesetRulesPullRequestRequiredReviewerReviewerArgs) ToRepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput() RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput { + return i.ToRepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesPullRequestRequiredReviewerReviewerArgs) ToRepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutputWithContext(ctx context.Context) RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput) +} + +type RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesPullRequestRequiredReviewerReviewer)(nil)).Elem() +} + +func (o RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput) ToRepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput() RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput { + return o +} + +func (o RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput) ToRepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutputWithContext(ctx context.Context) RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput { + return o +} + +// The ID of the reviewer that must review. +func (o RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput) Id() pulumi.IntOutput { + return o.ApplyT(func(v RepositoryRulesetRulesPullRequestRequiredReviewerReviewer) int { return v.Id }).(pulumi.IntOutput) +} + +// The type of reviewer. Currently only `Team` is supported. +func (o RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetRulesPullRequestRequiredReviewerReviewer) string { return v.Type }).(pulumi.StringOutput) +} + +type RepositoryRulesetRulesRequiredCodeScanning struct { + // Tools that must provide code scanning results for this rule to pass. + RequiredCodeScanningTools []RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningTool `pulumi:"requiredCodeScanningTools"` +} + +// RepositoryRulesetRulesRequiredCodeScanningInput is an input type that accepts RepositoryRulesetRulesRequiredCodeScanningArgs and RepositoryRulesetRulesRequiredCodeScanningOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesRequiredCodeScanningInput` via: +// +// RepositoryRulesetRulesRequiredCodeScanningArgs{...} +type RepositoryRulesetRulesRequiredCodeScanningInput interface { + pulumi.Input + + ToRepositoryRulesetRulesRequiredCodeScanningOutput() RepositoryRulesetRulesRequiredCodeScanningOutput + ToRepositoryRulesetRulesRequiredCodeScanningOutputWithContext(context.Context) RepositoryRulesetRulesRequiredCodeScanningOutput +} + +type RepositoryRulesetRulesRequiredCodeScanningArgs struct { + // Tools that must provide code scanning results for this rule to pass. + RequiredCodeScanningTools RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayInput `pulumi:"requiredCodeScanningTools"` +} + +func (RepositoryRulesetRulesRequiredCodeScanningArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesRequiredCodeScanning)(nil)).Elem() +} + +func (i RepositoryRulesetRulesRequiredCodeScanningArgs) ToRepositoryRulesetRulesRequiredCodeScanningOutput() RepositoryRulesetRulesRequiredCodeScanningOutput { + return i.ToRepositoryRulesetRulesRequiredCodeScanningOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesRequiredCodeScanningArgs) ToRepositoryRulesetRulesRequiredCodeScanningOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredCodeScanningOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesRequiredCodeScanningOutput) +} + +func (i RepositoryRulesetRulesRequiredCodeScanningArgs) ToRepositoryRulesetRulesRequiredCodeScanningPtrOutput() RepositoryRulesetRulesRequiredCodeScanningPtrOutput { + return i.ToRepositoryRulesetRulesRequiredCodeScanningPtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesRequiredCodeScanningArgs) ToRepositoryRulesetRulesRequiredCodeScanningPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredCodeScanningPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesRequiredCodeScanningOutput).ToRepositoryRulesetRulesRequiredCodeScanningPtrOutputWithContext(ctx) +} + +// RepositoryRulesetRulesRequiredCodeScanningPtrInput is an input type that accepts RepositoryRulesetRulesRequiredCodeScanningArgs, RepositoryRulesetRulesRequiredCodeScanningPtr and RepositoryRulesetRulesRequiredCodeScanningPtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesRequiredCodeScanningPtrInput` via: +// +// RepositoryRulesetRulesRequiredCodeScanningArgs{...} +// +// or: +// +// nil +type RepositoryRulesetRulesRequiredCodeScanningPtrInput interface { + pulumi.Input + + ToRepositoryRulesetRulesRequiredCodeScanningPtrOutput() RepositoryRulesetRulesRequiredCodeScanningPtrOutput + ToRepositoryRulesetRulesRequiredCodeScanningPtrOutputWithContext(context.Context) RepositoryRulesetRulesRequiredCodeScanningPtrOutput +} + +type repositoryRulesetRulesRequiredCodeScanningPtrType RepositoryRulesetRulesRequiredCodeScanningArgs + +func RepositoryRulesetRulesRequiredCodeScanningPtr(v *RepositoryRulesetRulesRequiredCodeScanningArgs) RepositoryRulesetRulesRequiredCodeScanningPtrInput { + return (*repositoryRulesetRulesRequiredCodeScanningPtrType)(v) +} + +func (*repositoryRulesetRulesRequiredCodeScanningPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesRequiredCodeScanning)(nil)).Elem() +} + +func (i *repositoryRulesetRulesRequiredCodeScanningPtrType) ToRepositoryRulesetRulesRequiredCodeScanningPtrOutput() RepositoryRulesetRulesRequiredCodeScanningPtrOutput { + return i.ToRepositoryRulesetRulesRequiredCodeScanningPtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetRulesRequiredCodeScanningPtrType) ToRepositoryRulesetRulesRequiredCodeScanningPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredCodeScanningPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesRequiredCodeScanningPtrOutput) +} + +type RepositoryRulesetRulesRequiredCodeScanningOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesRequiredCodeScanningOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesRequiredCodeScanning)(nil)).Elem() +} + +func (o RepositoryRulesetRulesRequiredCodeScanningOutput) ToRepositoryRulesetRulesRequiredCodeScanningOutput() RepositoryRulesetRulesRequiredCodeScanningOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredCodeScanningOutput) ToRepositoryRulesetRulesRequiredCodeScanningOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredCodeScanningOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredCodeScanningOutput) ToRepositoryRulesetRulesRequiredCodeScanningPtrOutput() RepositoryRulesetRulesRequiredCodeScanningPtrOutput { + return o.ToRepositoryRulesetRulesRequiredCodeScanningPtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetRulesRequiredCodeScanningOutput) ToRepositoryRulesetRulesRequiredCodeScanningPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredCodeScanningPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetRulesRequiredCodeScanning) *RepositoryRulesetRulesRequiredCodeScanning { + return &v + }).(RepositoryRulesetRulesRequiredCodeScanningPtrOutput) +} + +// Tools that must provide code scanning results for this rule to pass. +func (o RepositoryRulesetRulesRequiredCodeScanningOutput) RequiredCodeScanningTools() RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput { + return o.ApplyT(func(v RepositoryRulesetRulesRequiredCodeScanning) []RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningTool { + return v.RequiredCodeScanningTools + }).(RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput) +} + +type RepositoryRulesetRulesRequiredCodeScanningPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesRequiredCodeScanningPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesRequiredCodeScanning)(nil)).Elem() +} + +func (o RepositoryRulesetRulesRequiredCodeScanningPtrOutput) ToRepositoryRulesetRulesRequiredCodeScanningPtrOutput() RepositoryRulesetRulesRequiredCodeScanningPtrOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredCodeScanningPtrOutput) ToRepositoryRulesetRulesRequiredCodeScanningPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredCodeScanningPtrOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredCodeScanningPtrOutput) Elem() RepositoryRulesetRulesRequiredCodeScanningOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesRequiredCodeScanning) RepositoryRulesetRulesRequiredCodeScanning { + if v != nil { + return *v + } + var ret RepositoryRulesetRulesRequiredCodeScanning + return ret + }).(RepositoryRulesetRulesRequiredCodeScanningOutput) +} + +// Tools that must provide code scanning results for this rule to pass. +func (o RepositoryRulesetRulesRequiredCodeScanningPtrOutput) RequiredCodeScanningTools() RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesRequiredCodeScanning) []RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningTool { + if v == nil { + return nil + } + return v.RequiredCodeScanningTools + }).(RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput) +} + +type RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningTool struct { + // The severity level at which code scanning results that raise alerts block a reference update. Can be one of: `none`, `errors`, `errorsAndWarnings`, `all`. + AlertsThreshold string `pulumi:"alertsThreshold"` + // The severity level at which code scanning results that raise security alerts block a reference update. Can be one of: `none`, `critical`, `highOrHigher`, `mediumOrHigher`, `all`. + SecurityAlertsThreshold string `pulumi:"securityAlertsThreshold"` + // The name of a code scanning tool + Tool string `pulumi:"tool"` +} + +// RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolInput is an input type that accepts RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs and RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolInput` via: +// +// RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs{...} +type RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolInput interface { + pulumi.Input + + ToRepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput() RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput + ToRepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutputWithContext(context.Context) RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput +} + +type RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs struct { + // The severity level at which code scanning results that raise alerts block a reference update. Can be one of: `none`, `errors`, `errorsAndWarnings`, `all`. + AlertsThreshold pulumi.StringInput `pulumi:"alertsThreshold"` + // The severity level at which code scanning results that raise security alerts block a reference update. Can be one of: `none`, `critical`, `highOrHigher`, `mediumOrHigher`, `all`. + SecurityAlertsThreshold pulumi.StringInput `pulumi:"securityAlertsThreshold"` + // The name of a code scanning tool + Tool pulumi.StringInput `pulumi:"tool"` +} + +func (RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningTool)(nil)).Elem() +} + +func (i RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs) ToRepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput() RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput { + return i.ToRepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs) ToRepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput) +} + +// RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayInput is an input type that accepts RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArray and RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayInput` via: +// +// RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArray{ RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs{...} } +type RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayInput interface { + pulumi.Input + + ToRepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput() RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput + ToRepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutputWithContext(context.Context) RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput +} + +type RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArray []RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolInput + +func (RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningTool)(nil)).Elem() +} + +func (i RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArray) ToRepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput() RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput { + return i.ToRepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArray) ToRepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput) +} + +type RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningTool)(nil)).Elem() +} + +func (o RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput) ToRepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput() RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput) ToRepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput { + return o +} + +// The severity level at which code scanning results that raise alerts block a reference update. Can be one of: `none`, `errors`, `errorsAndWarnings`, `all`. +func (o RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput) AlertsThreshold() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningTool) string { + return v.AlertsThreshold + }).(pulumi.StringOutput) +} + +// The severity level at which code scanning results that raise security alerts block a reference update. Can be one of: `none`, `critical`, `highOrHigher`, `mediumOrHigher`, `all`. +func (o RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput) SecurityAlertsThreshold() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningTool) string { + return v.SecurityAlertsThreshold + }).(pulumi.StringOutput) +} + +// The name of a code scanning tool +func (o RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput) Tool() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningTool) string { return v.Tool }).(pulumi.StringOutput) +} + +type RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningTool)(nil)).Elem() +} + +func (o RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput) ToRepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput() RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput) ToRepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput) Index(i pulumi.IntInput) RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningTool { + return vs[0].([]RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningTool)[vs[1].(int)] + }).(RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput) +} + +type RepositoryRulesetRulesRequiredDeployments struct { + // The environments that must be successfully deployed to before branches can be merged. + RequiredDeploymentEnvironments []string `pulumi:"requiredDeploymentEnvironments"` +} + +// RepositoryRulesetRulesRequiredDeploymentsInput is an input type that accepts RepositoryRulesetRulesRequiredDeploymentsArgs and RepositoryRulesetRulesRequiredDeploymentsOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesRequiredDeploymentsInput` via: +// +// RepositoryRulesetRulesRequiredDeploymentsArgs{...} +type RepositoryRulesetRulesRequiredDeploymentsInput interface { + pulumi.Input + + ToRepositoryRulesetRulesRequiredDeploymentsOutput() RepositoryRulesetRulesRequiredDeploymentsOutput + ToRepositoryRulesetRulesRequiredDeploymentsOutputWithContext(context.Context) RepositoryRulesetRulesRequiredDeploymentsOutput +} + +type RepositoryRulesetRulesRequiredDeploymentsArgs struct { + // The environments that must be successfully deployed to before branches can be merged. + RequiredDeploymentEnvironments pulumi.StringArrayInput `pulumi:"requiredDeploymentEnvironments"` +} + +func (RepositoryRulesetRulesRequiredDeploymentsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesRequiredDeployments)(nil)).Elem() +} + +func (i RepositoryRulesetRulesRequiredDeploymentsArgs) ToRepositoryRulesetRulesRequiredDeploymentsOutput() RepositoryRulesetRulesRequiredDeploymentsOutput { + return i.ToRepositoryRulesetRulesRequiredDeploymentsOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesRequiredDeploymentsArgs) ToRepositoryRulesetRulesRequiredDeploymentsOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredDeploymentsOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesRequiredDeploymentsOutput) +} + +func (i RepositoryRulesetRulesRequiredDeploymentsArgs) ToRepositoryRulesetRulesRequiredDeploymentsPtrOutput() RepositoryRulesetRulesRequiredDeploymentsPtrOutput { + return i.ToRepositoryRulesetRulesRequiredDeploymentsPtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesRequiredDeploymentsArgs) ToRepositoryRulesetRulesRequiredDeploymentsPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredDeploymentsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesRequiredDeploymentsOutput).ToRepositoryRulesetRulesRequiredDeploymentsPtrOutputWithContext(ctx) +} + +// RepositoryRulesetRulesRequiredDeploymentsPtrInput is an input type that accepts RepositoryRulesetRulesRequiredDeploymentsArgs, RepositoryRulesetRulesRequiredDeploymentsPtr and RepositoryRulesetRulesRequiredDeploymentsPtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesRequiredDeploymentsPtrInput` via: +// +// RepositoryRulesetRulesRequiredDeploymentsArgs{...} +// +// or: +// +// nil +type RepositoryRulesetRulesRequiredDeploymentsPtrInput interface { + pulumi.Input + + ToRepositoryRulesetRulesRequiredDeploymentsPtrOutput() RepositoryRulesetRulesRequiredDeploymentsPtrOutput + ToRepositoryRulesetRulesRequiredDeploymentsPtrOutputWithContext(context.Context) RepositoryRulesetRulesRequiredDeploymentsPtrOutput +} + +type repositoryRulesetRulesRequiredDeploymentsPtrType RepositoryRulesetRulesRequiredDeploymentsArgs + +func RepositoryRulesetRulesRequiredDeploymentsPtr(v *RepositoryRulesetRulesRequiredDeploymentsArgs) RepositoryRulesetRulesRequiredDeploymentsPtrInput { + return (*repositoryRulesetRulesRequiredDeploymentsPtrType)(v) +} + +func (*repositoryRulesetRulesRequiredDeploymentsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesRequiredDeployments)(nil)).Elem() +} + +func (i *repositoryRulesetRulesRequiredDeploymentsPtrType) ToRepositoryRulesetRulesRequiredDeploymentsPtrOutput() RepositoryRulesetRulesRequiredDeploymentsPtrOutput { + return i.ToRepositoryRulesetRulesRequiredDeploymentsPtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetRulesRequiredDeploymentsPtrType) ToRepositoryRulesetRulesRequiredDeploymentsPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredDeploymentsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesRequiredDeploymentsPtrOutput) +} + +type RepositoryRulesetRulesRequiredDeploymentsOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesRequiredDeploymentsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesRequiredDeployments)(nil)).Elem() +} + +func (o RepositoryRulesetRulesRequiredDeploymentsOutput) ToRepositoryRulesetRulesRequiredDeploymentsOutput() RepositoryRulesetRulesRequiredDeploymentsOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredDeploymentsOutput) ToRepositoryRulesetRulesRequiredDeploymentsOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredDeploymentsOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredDeploymentsOutput) ToRepositoryRulesetRulesRequiredDeploymentsPtrOutput() RepositoryRulesetRulesRequiredDeploymentsPtrOutput { + return o.ToRepositoryRulesetRulesRequiredDeploymentsPtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetRulesRequiredDeploymentsOutput) ToRepositoryRulesetRulesRequiredDeploymentsPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredDeploymentsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetRulesRequiredDeployments) *RepositoryRulesetRulesRequiredDeployments { + return &v + }).(RepositoryRulesetRulesRequiredDeploymentsPtrOutput) +} + +// The environments that must be successfully deployed to before branches can be merged. +func (o RepositoryRulesetRulesRequiredDeploymentsOutput) RequiredDeploymentEnvironments() pulumi.StringArrayOutput { + return o.ApplyT(func(v RepositoryRulesetRulesRequiredDeployments) []string { return v.RequiredDeploymentEnvironments }).(pulumi.StringArrayOutput) +} + +type RepositoryRulesetRulesRequiredDeploymentsPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesRequiredDeploymentsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesRequiredDeployments)(nil)).Elem() +} + +func (o RepositoryRulesetRulesRequiredDeploymentsPtrOutput) ToRepositoryRulesetRulesRequiredDeploymentsPtrOutput() RepositoryRulesetRulesRequiredDeploymentsPtrOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredDeploymentsPtrOutput) ToRepositoryRulesetRulesRequiredDeploymentsPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredDeploymentsPtrOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredDeploymentsPtrOutput) Elem() RepositoryRulesetRulesRequiredDeploymentsOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesRequiredDeployments) RepositoryRulesetRulesRequiredDeployments { + if v != nil { + return *v + } + var ret RepositoryRulesetRulesRequiredDeployments + return ret + }).(RepositoryRulesetRulesRequiredDeploymentsOutput) +} + +// The environments that must be successfully deployed to before branches can be merged. +func (o RepositoryRulesetRulesRequiredDeploymentsPtrOutput) RequiredDeploymentEnvironments() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesRequiredDeployments) []string { + if v == nil { + return nil + } + return v.RequiredDeploymentEnvironments + }).(pulumi.StringArrayOutput) +} + +type RepositoryRulesetRulesRequiredStatusChecks struct { + // Allow repositories and branches to be created if a check would otherwise prohibit it. + DoNotEnforceOnCreate *bool `pulumi:"doNotEnforceOnCreate"` + // Status checks that are required. Several can be defined. + RequiredChecks []RepositoryRulesetRulesRequiredStatusChecksRequiredCheck `pulumi:"requiredChecks"` + // Whether pull requests targeting a matching branch must be tested with the latest code. This setting will not take effect unless at least one status check is enabled. Defaults to `false`. + StrictRequiredStatusChecksPolicy *bool `pulumi:"strictRequiredStatusChecksPolicy"` +} + +// RepositoryRulesetRulesRequiredStatusChecksInput is an input type that accepts RepositoryRulesetRulesRequiredStatusChecksArgs and RepositoryRulesetRulesRequiredStatusChecksOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesRequiredStatusChecksInput` via: +// +// RepositoryRulesetRulesRequiredStatusChecksArgs{...} +type RepositoryRulesetRulesRequiredStatusChecksInput interface { + pulumi.Input + + ToRepositoryRulesetRulesRequiredStatusChecksOutput() RepositoryRulesetRulesRequiredStatusChecksOutput + ToRepositoryRulesetRulesRequiredStatusChecksOutputWithContext(context.Context) RepositoryRulesetRulesRequiredStatusChecksOutput +} + +type RepositoryRulesetRulesRequiredStatusChecksArgs struct { + // Allow repositories and branches to be created if a check would otherwise prohibit it. + DoNotEnforceOnCreate pulumi.BoolPtrInput `pulumi:"doNotEnforceOnCreate"` + // Status checks that are required. Several can be defined. + RequiredChecks RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayInput `pulumi:"requiredChecks"` + // Whether pull requests targeting a matching branch must be tested with the latest code. This setting will not take effect unless at least one status check is enabled. Defaults to `false`. + StrictRequiredStatusChecksPolicy pulumi.BoolPtrInput `pulumi:"strictRequiredStatusChecksPolicy"` +} + +func (RepositoryRulesetRulesRequiredStatusChecksArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesRequiredStatusChecks)(nil)).Elem() +} + +func (i RepositoryRulesetRulesRequiredStatusChecksArgs) ToRepositoryRulesetRulesRequiredStatusChecksOutput() RepositoryRulesetRulesRequiredStatusChecksOutput { + return i.ToRepositoryRulesetRulesRequiredStatusChecksOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesRequiredStatusChecksArgs) ToRepositoryRulesetRulesRequiredStatusChecksOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredStatusChecksOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesRequiredStatusChecksOutput) +} + +func (i RepositoryRulesetRulesRequiredStatusChecksArgs) ToRepositoryRulesetRulesRequiredStatusChecksPtrOutput() RepositoryRulesetRulesRequiredStatusChecksPtrOutput { + return i.ToRepositoryRulesetRulesRequiredStatusChecksPtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesRequiredStatusChecksArgs) ToRepositoryRulesetRulesRequiredStatusChecksPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredStatusChecksPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesRequiredStatusChecksOutput).ToRepositoryRulesetRulesRequiredStatusChecksPtrOutputWithContext(ctx) +} + +// RepositoryRulesetRulesRequiredStatusChecksPtrInput is an input type that accepts RepositoryRulesetRulesRequiredStatusChecksArgs, RepositoryRulesetRulesRequiredStatusChecksPtr and RepositoryRulesetRulesRequiredStatusChecksPtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesRequiredStatusChecksPtrInput` via: +// +// RepositoryRulesetRulesRequiredStatusChecksArgs{...} +// +// or: +// +// nil +type RepositoryRulesetRulesRequiredStatusChecksPtrInput interface { + pulumi.Input + + ToRepositoryRulesetRulesRequiredStatusChecksPtrOutput() RepositoryRulesetRulesRequiredStatusChecksPtrOutput + ToRepositoryRulesetRulesRequiredStatusChecksPtrOutputWithContext(context.Context) RepositoryRulesetRulesRequiredStatusChecksPtrOutput +} + +type repositoryRulesetRulesRequiredStatusChecksPtrType RepositoryRulesetRulesRequiredStatusChecksArgs + +func RepositoryRulesetRulesRequiredStatusChecksPtr(v *RepositoryRulesetRulesRequiredStatusChecksArgs) RepositoryRulesetRulesRequiredStatusChecksPtrInput { + return (*repositoryRulesetRulesRequiredStatusChecksPtrType)(v) +} + +func (*repositoryRulesetRulesRequiredStatusChecksPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesRequiredStatusChecks)(nil)).Elem() +} + +func (i *repositoryRulesetRulesRequiredStatusChecksPtrType) ToRepositoryRulesetRulesRequiredStatusChecksPtrOutput() RepositoryRulesetRulesRequiredStatusChecksPtrOutput { + return i.ToRepositoryRulesetRulesRequiredStatusChecksPtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetRulesRequiredStatusChecksPtrType) ToRepositoryRulesetRulesRequiredStatusChecksPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredStatusChecksPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesRequiredStatusChecksPtrOutput) +} + +type RepositoryRulesetRulesRequiredStatusChecksOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesRequiredStatusChecksOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesRequiredStatusChecks)(nil)).Elem() +} + +func (o RepositoryRulesetRulesRequiredStatusChecksOutput) ToRepositoryRulesetRulesRequiredStatusChecksOutput() RepositoryRulesetRulesRequiredStatusChecksOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredStatusChecksOutput) ToRepositoryRulesetRulesRequiredStatusChecksOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredStatusChecksOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredStatusChecksOutput) ToRepositoryRulesetRulesRequiredStatusChecksPtrOutput() RepositoryRulesetRulesRequiredStatusChecksPtrOutput { + return o.ToRepositoryRulesetRulesRequiredStatusChecksPtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetRulesRequiredStatusChecksOutput) ToRepositoryRulesetRulesRequiredStatusChecksPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredStatusChecksPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetRulesRequiredStatusChecks) *RepositoryRulesetRulesRequiredStatusChecks { + return &v + }).(RepositoryRulesetRulesRequiredStatusChecksPtrOutput) +} + +// Allow repositories and branches to be created if a check would otherwise prohibit it. +func (o RepositoryRulesetRulesRequiredStatusChecksOutput) DoNotEnforceOnCreate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesRequiredStatusChecks) *bool { return v.DoNotEnforceOnCreate }).(pulumi.BoolPtrOutput) +} + +// Status checks that are required. Several can be defined. +func (o RepositoryRulesetRulesRequiredStatusChecksOutput) RequiredChecks() RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput { + return o.ApplyT(func(v RepositoryRulesetRulesRequiredStatusChecks) []RepositoryRulesetRulesRequiredStatusChecksRequiredCheck { + return v.RequiredChecks + }).(RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput) +} + +// Whether pull requests targeting a matching branch must be tested with the latest code. This setting will not take effect unless at least one status check is enabled. Defaults to `false`. +func (o RepositoryRulesetRulesRequiredStatusChecksOutput) StrictRequiredStatusChecksPolicy() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesRequiredStatusChecks) *bool { return v.StrictRequiredStatusChecksPolicy }).(pulumi.BoolPtrOutput) +} + +type RepositoryRulesetRulesRequiredStatusChecksPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesRequiredStatusChecksPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesRequiredStatusChecks)(nil)).Elem() +} + +func (o RepositoryRulesetRulesRequiredStatusChecksPtrOutput) ToRepositoryRulesetRulesRequiredStatusChecksPtrOutput() RepositoryRulesetRulesRequiredStatusChecksPtrOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredStatusChecksPtrOutput) ToRepositoryRulesetRulesRequiredStatusChecksPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredStatusChecksPtrOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredStatusChecksPtrOutput) Elem() RepositoryRulesetRulesRequiredStatusChecksOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesRequiredStatusChecks) RepositoryRulesetRulesRequiredStatusChecks { + if v != nil { + return *v + } + var ret RepositoryRulesetRulesRequiredStatusChecks + return ret + }).(RepositoryRulesetRulesRequiredStatusChecksOutput) +} + +// Allow repositories and branches to be created if a check would otherwise prohibit it. +func (o RepositoryRulesetRulesRequiredStatusChecksPtrOutput) DoNotEnforceOnCreate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesRequiredStatusChecks) *bool { + if v == nil { + return nil + } + return v.DoNotEnforceOnCreate + }).(pulumi.BoolPtrOutput) +} + +// Status checks that are required. Several can be defined. +func (o RepositoryRulesetRulesRequiredStatusChecksPtrOutput) RequiredChecks() RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesRequiredStatusChecks) []RepositoryRulesetRulesRequiredStatusChecksRequiredCheck { + if v == nil { + return nil + } + return v.RequiredChecks + }).(RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput) +} + +// Whether pull requests targeting a matching branch must be tested with the latest code. This setting will not take effect unless at least one status check is enabled. Defaults to `false`. +func (o RepositoryRulesetRulesRequiredStatusChecksPtrOutput) StrictRequiredStatusChecksPolicy() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesRequiredStatusChecks) *bool { + if v == nil { + return nil + } + return v.StrictRequiredStatusChecksPolicy + }).(pulumi.BoolPtrOutput) +} + +type RepositoryRulesetRulesRequiredStatusChecksRequiredCheck struct { + // The status check context name that must be present on the commit. + Context string `pulumi:"context"` + // The optional integration ID that this status check must originate from. + IntegrationId *int `pulumi:"integrationId"` +} + +// RepositoryRulesetRulesRequiredStatusChecksRequiredCheckInput is an input type that accepts RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArgs and RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesRequiredStatusChecksRequiredCheckInput` via: +// +// RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArgs{...} +type RepositoryRulesetRulesRequiredStatusChecksRequiredCheckInput interface { + pulumi.Input + + ToRepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput() RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput + ToRepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutputWithContext(context.Context) RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput +} + +type RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArgs struct { + // The status check context name that must be present on the commit. + Context pulumi.StringInput `pulumi:"context"` + // The optional integration ID that this status check must originate from. + IntegrationId pulumi.IntPtrInput `pulumi:"integrationId"` +} + +func (RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesRequiredStatusChecksRequiredCheck)(nil)).Elem() +} + +func (i RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArgs) ToRepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput() RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput { + return i.ToRepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArgs) ToRepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput) +} + +// RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayInput is an input type that accepts RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArray and RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayInput` via: +// +// RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArray{ RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArgs{...} } +type RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayInput interface { + pulumi.Input + + ToRepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput() RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput + ToRepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutputWithContext(context.Context) RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput +} + +type RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArray []RepositoryRulesetRulesRequiredStatusChecksRequiredCheckInput + +func (RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]RepositoryRulesetRulesRequiredStatusChecksRequiredCheck)(nil)).Elem() +} + +func (i RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArray) ToRepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput() RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput { + return i.ToRepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArray) ToRepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput) +} + +type RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesRequiredStatusChecksRequiredCheck)(nil)).Elem() +} + +func (o RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput) ToRepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput() RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput) ToRepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput { + return o +} + +// The status check context name that must be present on the commit. +func (o RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput) Context() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetRulesRequiredStatusChecksRequiredCheck) string { return v.Context }).(pulumi.StringOutput) +} + +// The optional integration ID that this status check must originate from. +func (o RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput) IntegrationId() pulumi.IntPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesRequiredStatusChecksRequiredCheck) *int { return v.IntegrationId }).(pulumi.IntPtrOutput) +} + +type RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]RepositoryRulesetRulesRequiredStatusChecksRequiredCheck)(nil)).Elem() +} + +func (o RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput) ToRepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput() RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput) ToRepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutputWithContext(ctx context.Context) RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput { + return o +} + +func (o RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput) Index(i pulumi.IntInput) RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) RepositoryRulesetRulesRequiredStatusChecksRequiredCheck { + return vs[0].([]RepositoryRulesetRulesRequiredStatusChecksRequiredCheck)[vs[1].(int)] + }).(RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput) +} + +type RepositoryRulesetRulesTagNamePattern struct { + // (String) The name of the ruleset. + Name *string `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate *bool `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator string `pulumi:"operator"` + // The pattern to match with. + Pattern string `pulumi:"pattern"` +} + +// RepositoryRulesetRulesTagNamePatternInput is an input type that accepts RepositoryRulesetRulesTagNamePatternArgs and RepositoryRulesetRulesTagNamePatternOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesTagNamePatternInput` via: +// +// RepositoryRulesetRulesTagNamePatternArgs{...} +type RepositoryRulesetRulesTagNamePatternInput interface { + pulumi.Input + + ToRepositoryRulesetRulesTagNamePatternOutput() RepositoryRulesetRulesTagNamePatternOutput + ToRepositoryRulesetRulesTagNamePatternOutputWithContext(context.Context) RepositoryRulesetRulesTagNamePatternOutput +} + +type RepositoryRulesetRulesTagNamePatternArgs struct { + // (String) The name of the ruleset. + Name pulumi.StringPtrInput `pulumi:"name"` + // If true, the rule will fail if the pattern matches. + Negate pulumi.BoolPtrInput `pulumi:"negate"` + // The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. + Operator pulumi.StringInput `pulumi:"operator"` + // The pattern to match with. + Pattern pulumi.StringInput `pulumi:"pattern"` +} + +func (RepositoryRulesetRulesTagNamePatternArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesTagNamePattern)(nil)).Elem() +} + +func (i RepositoryRulesetRulesTagNamePatternArgs) ToRepositoryRulesetRulesTagNamePatternOutput() RepositoryRulesetRulesTagNamePatternOutput { + return i.ToRepositoryRulesetRulesTagNamePatternOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesTagNamePatternArgs) ToRepositoryRulesetRulesTagNamePatternOutputWithContext(ctx context.Context) RepositoryRulesetRulesTagNamePatternOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesTagNamePatternOutput) +} + +func (i RepositoryRulesetRulesTagNamePatternArgs) ToRepositoryRulesetRulesTagNamePatternPtrOutput() RepositoryRulesetRulesTagNamePatternPtrOutput { + return i.ToRepositoryRulesetRulesTagNamePatternPtrOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetRulesTagNamePatternArgs) ToRepositoryRulesetRulesTagNamePatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesTagNamePatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesTagNamePatternOutput).ToRepositoryRulesetRulesTagNamePatternPtrOutputWithContext(ctx) +} + +// RepositoryRulesetRulesTagNamePatternPtrInput is an input type that accepts RepositoryRulesetRulesTagNamePatternArgs, RepositoryRulesetRulesTagNamePatternPtr and RepositoryRulesetRulesTagNamePatternPtrOutput values. +// You can construct a concrete instance of `RepositoryRulesetRulesTagNamePatternPtrInput` via: +// +// RepositoryRulesetRulesTagNamePatternArgs{...} +// +// or: +// +// nil +type RepositoryRulesetRulesTagNamePatternPtrInput interface { + pulumi.Input + + ToRepositoryRulesetRulesTagNamePatternPtrOutput() RepositoryRulesetRulesTagNamePatternPtrOutput + ToRepositoryRulesetRulesTagNamePatternPtrOutputWithContext(context.Context) RepositoryRulesetRulesTagNamePatternPtrOutput +} + +type repositoryRulesetRulesTagNamePatternPtrType RepositoryRulesetRulesTagNamePatternArgs + +func RepositoryRulesetRulesTagNamePatternPtr(v *RepositoryRulesetRulesTagNamePatternArgs) RepositoryRulesetRulesTagNamePatternPtrInput { + return (*repositoryRulesetRulesTagNamePatternPtrType)(v) +} + +func (*repositoryRulesetRulesTagNamePatternPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesTagNamePattern)(nil)).Elem() +} + +func (i *repositoryRulesetRulesTagNamePatternPtrType) ToRepositoryRulesetRulesTagNamePatternPtrOutput() RepositoryRulesetRulesTagNamePatternPtrOutput { + return i.ToRepositoryRulesetRulesTagNamePatternPtrOutputWithContext(context.Background()) +} + +func (i *repositoryRulesetRulesTagNamePatternPtrType) ToRepositoryRulesetRulesTagNamePatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesTagNamePatternPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetRulesTagNamePatternPtrOutput) +} + +type RepositoryRulesetRulesTagNamePatternOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesTagNamePatternOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryRulesetRulesTagNamePattern)(nil)).Elem() +} + +func (o RepositoryRulesetRulesTagNamePatternOutput) ToRepositoryRulesetRulesTagNamePatternOutput() RepositoryRulesetRulesTagNamePatternOutput { + return o +} + +func (o RepositoryRulesetRulesTagNamePatternOutput) ToRepositoryRulesetRulesTagNamePatternOutputWithContext(ctx context.Context) RepositoryRulesetRulesTagNamePatternOutput { + return o +} + +func (o RepositoryRulesetRulesTagNamePatternOutput) ToRepositoryRulesetRulesTagNamePatternPtrOutput() RepositoryRulesetRulesTagNamePatternPtrOutput { + return o.ToRepositoryRulesetRulesTagNamePatternPtrOutputWithContext(context.Background()) +} + +func (o RepositoryRulesetRulesTagNamePatternOutput) ToRepositoryRulesetRulesTagNamePatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesTagNamePatternPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryRulesetRulesTagNamePattern) *RepositoryRulesetRulesTagNamePattern { + return &v + }).(RepositoryRulesetRulesTagNamePatternPtrOutput) +} + +// (String) The name of the ruleset. +func (o RepositoryRulesetRulesTagNamePatternOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesTagNamePattern) *string { return v.Name }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o RepositoryRulesetRulesTagNamePatternOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryRulesetRulesTagNamePattern) *bool { return v.Negate }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o RepositoryRulesetRulesTagNamePatternOutput) Operator() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetRulesTagNamePattern) string { return v.Operator }).(pulumi.StringOutput) +} + +// The pattern to match with. +func (o RepositoryRulesetRulesTagNamePatternOutput) Pattern() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryRulesetRulesTagNamePattern) string { return v.Pattern }).(pulumi.StringOutput) +} + +type RepositoryRulesetRulesTagNamePatternPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetRulesTagNamePatternPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRulesetRulesTagNamePattern)(nil)).Elem() +} + +func (o RepositoryRulesetRulesTagNamePatternPtrOutput) ToRepositoryRulesetRulesTagNamePatternPtrOutput() RepositoryRulesetRulesTagNamePatternPtrOutput { + return o +} + +func (o RepositoryRulesetRulesTagNamePatternPtrOutput) ToRepositoryRulesetRulesTagNamePatternPtrOutputWithContext(ctx context.Context) RepositoryRulesetRulesTagNamePatternPtrOutput { + return o +} + +func (o RepositoryRulesetRulesTagNamePatternPtrOutput) Elem() RepositoryRulesetRulesTagNamePatternOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesTagNamePattern) RepositoryRulesetRulesTagNamePattern { + if v != nil { + return *v + } + var ret RepositoryRulesetRulesTagNamePattern + return ret + }).(RepositoryRulesetRulesTagNamePatternOutput) +} + +// (String) The name of the ruleset. +func (o RepositoryRulesetRulesTagNamePatternPtrOutput) Name() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesTagNamePattern) *string { + if v == nil { + return nil + } + return v.Name + }).(pulumi.StringPtrOutput) +} + +// If true, the rule will fail if the pattern matches. +func (o RepositoryRulesetRulesTagNamePatternPtrOutput) Negate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesTagNamePattern) *bool { + if v == nil { + return nil + } + return v.Negate + }).(pulumi.BoolPtrOutput) +} + +// The operator to use for matching. Can be one of: `startsWith`, `endsWith`, `contains`, `regex`. +func (o RepositoryRulesetRulesTagNamePatternPtrOutput) Operator() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesTagNamePattern) *string { + if v == nil { + return nil + } + return &v.Operator + }).(pulumi.StringPtrOutput) +} + +// The pattern to match with. +func (o RepositoryRulesetRulesTagNamePatternPtrOutput) Pattern() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryRulesetRulesTagNamePattern) *string { + if v == nil { + return nil + } + return &v.Pattern + }).(pulumi.StringPtrOutput) +} + +type RepositorySecurityAndAnalysis struct { + // The advanced security configuration for the repository. See Advanced Security Configuration below for details. If a repository's visibility is `public`, advanced security is always enabled and cannot be changed, so this setting cannot be supplied. + AdvancedSecurity *RepositorySecurityAndAnalysisAdvancedSecurity `pulumi:"advancedSecurity"` + // The code security configuration for the repository. See Code Security below for details. + CodeSecurity *RepositorySecurityAndAnalysisCodeSecurity `pulumi:"codeSecurity"` + // The secret scanning configuration for the repository. See Secret Scanning Configuration below for details. + SecretScanning *RepositorySecurityAndAnalysisSecretScanning `pulumi:"secretScanning"` + // The secret scanning ai detection configuration for the repository. See Secret Scanning AI Detection Configuration below for details. + SecretScanningAiDetection *RepositorySecurityAndAnalysisSecretScanningAiDetection `pulumi:"secretScanningAiDetection"` + // The secret scanning non-provider patterns configuration for this repository. See Secret Scanning Non-Provider Patterns Configuration below for more details. + SecretScanningNonProviderPatterns *RepositorySecurityAndAnalysisSecretScanningNonProviderPatterns `pulumi:"secretScanningNonProviderPatterns"` + // The secret scanning push protection configuration for the repository. See Secret Scanning Push Protection Configuration below for details. + SecretScanningPushProtection *RepositorySecurityAndAnalysisSecretScanningPushProtection `pulumi:"secretScanningPushProtection"` +} + +// RepositorySecurityAndAnalysisInput is an input type that accepts RepositorySecurityAndAnalysisArgs and RepositorySecurityAndAnalysisOutput values. +// You can construct a concrete instance of `RepositorySecurityAndAnalysisInput` via: +// +// RepositorySecurityAndAnalysisArgs{...} +type RepositorySecurityAndAnalysisInput interface { + pulumi.Input + + ToRepositorySecurityAndAnalysisOutput() RepositorySecurityAndAnalysisOutput + ToRepositorySecurityAndAnalysisOutputWithContext(context.Context) RepositorySecurityAndAnalysisOutput +} + +type RepositorySecurityAndAnalysisArgs struct { + // The advanced security configuration for the repository. See Advanced Security Configuration below for details. If a repository's visibility is `public`, advanced security is always enabled and cannot be changed, so this setting cannot be supplied. + AdvancedSecurity RepositorySecurityAndAnalysisAdvancedSecurityPtrInput `pulumi:"advancedSecurity"` + // The code security configuration for the repository. See Code Security below for details. + CodeSecurity RepositorySecurityAndAnalysisCodeSecurityPtrInput `pulumi:"codeSecurity"` + // The secret scanning configuration for the repository. See Secret Scanning Configuration below for details. + SecretScanning RepositorySecurityAndAnalysisSecretScanningPtrInput `pulumi:"secretScanning"` + // The secret scanning ai detection configuration for the repository. See Secret Scanning AI Detection Configuration below for details. + SecretScanningAiDetection RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrInput `pulumi:"secretScanningAiDetection"` + // The secret scanning non-provider patterns configuration for this repository. See Secret Scanning Non-Provider Patterns Configuration below for more details. + SecretScanningNonProviderPatterns RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrInput `pulumi:"secretScanningNonProviderPatterns"` + // The secret scanning push protection configuration for the repository. See Secret Scanning Push Protection Configuration below for details. + SecretScanningPushProtection RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrInput `pulumi:"secretScanningPushProtection"` +} + +func (RepositorySecurityAndAnalysisArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositorySecurityAndAnalysis)(nil)).Elem() +} + +func (i RepositorySecurityAndAnalysisArgs) ToRepositorySecurityAndAnalysisOutput() RepositorySecurityAndAnalysisOutput { + return i.ToRepositorySecurityAndAnalysisOutputWithContext(context.Background()) +} + +func (i RepositorySecurityAndAnalysisArgs) ToRepositorySecurityAndAnalysisOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisOutput) +} + +func (i RepositorySecurityAndAnalysisArgs) ToRepositorySecurityAndAnalysisPtrOutput() RepositorySecurityAndAnalysisPtrOutput { + return i.ToRepositorySecurityAndAnalysisPtrOutputWithContext(context.Background()) +} + +func (i RepositorySecurityAndAnalysisArgs) ToRepositorySecurityAndAnalysisPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisOutput).ToRepositorySecurityAndAnalysisPtrOutputWithContext(ctx) +} + +// RepositorySecurityAndAnalysisPtrInput is an input type that accepts RepositorySecurityAndAnalysisArgs, RepositorySecurityAndAnalysisPtr and RepositorySecurityAndAnalysisPtrOutput values. +// You can construct a concrete instance of `RepositorySecurityAndAnalysisPtrInput` via: +// +// RepositorySecurityAndAnalysisArgs{...} +// +// or: +// +// nil +type RepositorySecurityAndAnalysisPtrInput interface { + pulumi.Input + + ToRepositorySecurityAndAnalysisPtrOutput() RepositorySecurityAndAnalysisPtrOutput + ToRepositorySecurityAndAnalysisPtrOutputWithContext(context.Context) RepositorySecurityAndAnalysisPtrOutput +} + +type repositorySecurityAndAnalysisPtrType RepositorySecurityAndAnalysisArgs + +func RepositorySecurityAndAnalysisPtr(v *RepositorySecurityAndAnalysisArgs) RepositorySecurityAndAnalysisPtrInput { + return (*repositorySecurityAndAnalysisPtrType)(v) +} + +func (*repositorySecurityAndAnalysisPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositorySecurityAndAnalysis)(nil)).Elem() +} + +func (i *repositorySecurityAndAnalysisPtrType) ToRepositorySecurityAndAnalysisPtrOutput() RepositorySecurityAndAnalysisPtrOutput { + return i.ToRepositorySecurityAndAnalysisPtrOutputWithContext(context.Background()) +} + +func (i *repositorySecurityAndAnalysisPtrType) ToRepositorySecurityAndAnalysisPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisPtrOutput) +} + +type RepositorySecurityAndAnalysisOutput struct{ *pulumi.OutputState } + +func (RepositorySecurityAndAnalysisOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositorySecurityAndAnalysis)(nil)).Elem() +} + +func (o RepositorySecurityAndAnalysisOutput) ToRepositorySecurityAndAnalysisOutput() RepositorySecurityAndAnalysisOutput { + return o +} + +func (o RepositorySecurityAndAnalysisOutput) ToRepositorySecurityAndAnalysisOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisOutput { + return o +} + +func (o RepositorySecurityAndAnalysisOutput) ToRepositorySecurityAndAnalysisPtrOutput() RepositorySecurityAndAnalysisPtrOutput { + return o.ToRepositorySecurityAndAnalysisPtrOutputWithContext(context.Background()) +} + +func (o RepositorySecurityAndAnalysisOutput) ToRepositorySecurityAndAnalysisPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositorySecurityAndAnalysis) *RepositorySecurityAndAnalysis { + return &v + }).(RepositorySecurityAndAnalysisPtrOutput) +} + +// The advanced security configuration for the repository. See Advanced Security Configuration below for details. If a repository's visibility is `public`, advanced security is always enabled and cannot be changed, so this setting cannot be supplied. +func (o RepositorySecurityAndAnalysisOutput) AdvancedSecurity() RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput { + return o.ApplyT(func(v RepositorySecurityAndAnalysis) *RepositorySecurityAndAnalysisAdvancedSecurity { + return v.AdvancedSecurity + }).(RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput) +} + +// The code security configuration for the repository. See Code Security below for details. +func (o RepositorySecurityAndAnalysisOutput) CodeSecurity() RepositorySecurityAndAnalysisCodeSecurityPtrOutput { + return o.ApplyT(func(v RepositorySecurityAndAnalysis) *RepositorySecurityAndAnalysisCodeSecurity { + return v.CodeSecurity + }).(RepositorySecurityAndAnalysisCodeSecurityPtrOutput) +} + +// The secret scanning configuration for the repository. See Secret Scanning Configuration below for details. +func (o RepositorySecurityAndAnalysisOutput) SecretScanning() RepositorySecurityAndAnalysisSecretScanningPtrOutput { + return o.ApplyT(func(v RepositorySecurityAndAnalysis) *RepositorySecurityAndAnalysisSecretScanning { + return v.SecretScanning + }).(RepositorySecurityAndAnalysisSecretScanningPtrOutput) +} + +// The secret scanning ai detection configuration for the repository. See Secret Scanning AI Detection Configuration below for details. +func (o RepositorySecurityAndAnalysisOutput) SecretScanningAiDetection() RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput { + return o.ApplyT(func(v RepositorySecurityAndAnalysis) *RepositorySecurityAndAnalysisSecretScanningAiDetection { + return v.SecretScanningAiDetection + }).(RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput) +} + +// The secret scanning non-provider patterns configuration for this repository. See Secret Scanning Non-Provider Patterns Configuration below for more details. +func (o RepositorySecurityAndAnalysisOutput) SecretScanningNonProviderPatterns() RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput { + return o.ApplyT(func(v RepositorySecurityAndAnalysis) *RepositorySecurityAndAnalysisSecretScanningNonProviderPatterns { + return v.SecretScanningNonProviderPatterns + }).(RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput) +} + +// The secret scanning push protection configuration for the repository. See Secret Scanning Push Protection Configuration below for details. +func (o RepositorySecurityAndAnalysisOutput) SecretScanningPushProtection() RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput { + return o.ApplyT(func(v RepositorySecurityAndAnalysis) *RepositorySecurityAndAnalysisSecretScanningPushProtection { + return v.SecretScanningPushProtection + }).(RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput) +} + +type RepositorySecurityAndAnalysisPtrOutput struct{ *pulumi.OutputState } + +func (RepositorySecurityAndAnalysisPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositorySecurityAndAnalysis)(nil)).Elem() +} + +func (o RepositorySecurityAndAnalysisPtrOutput) ToRepositorySecurityAndAnalysisPtrOutput() RepositorySecurityAndAnalysisPtrOutput { + return o +} + +func (o RepositorySecurityAndAnalysisPtrOutput) ToRepositorySecurityAndAnalysisPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisPtrOutput { + return o +} + +func (o RepositorySecurityAndAnalysisPtrOutput) Elem() RepositorySecurityAndAnalysisOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysis) RepositorySecurityAndAnalysis { + if v != nil { + return *v + } + var ret RepositorySecurityAndAnalysis + return ret + }).(RepositorySecurityAndAnalysisOutput) +} + +// The advanced security configuration for the repository. See Advanced Security Configuration below for details. If a repository's visibility is `public`, advanced security is always enabled and cannot be changed, so this setting cannot be supplied. +func (o RepositorySecurityAndAnalysisPtrOutput) AdvancedSecurity() RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysis) *RepositorySecurityAndAnalysisAdvancedSecurity { + if v == nil { + return nil + } + return v.AdvancedSecurity + }).(RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput) +} + +// The code security configuration for the repository. See Code Security below for details. +func (o RepositorySecurityAndAnalysisPtrOutput) CodeSecurity() RepositorySecurityAndAnalysisCodeSecurityPtrOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysis) *RepositorySecurityAndAnalysisCodeSecurity { + if v == nil { + return nil + } + return v.CodeSecurity + }).(RepositorySecurityAndAnalysisCodeSecurityPtrOutput) +} + +// The secret scanning configuration for the repository. See Secret Scanning Configuration below for details. +func (o RepositorySecurityAndAnalysisPtrOutput) SecretScanning() RepositorySecurityAndAnalysisSecretScanningPtrOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysis) *RepositorySecurityAndAnalysisSecretScanning { + if v == nil { + return nil + } + return v.SecretScanning + }).(RepositorySecurityAndAnalysisSecretScanningPtrOutput) +} + +// The secret scanning ai detection configuration for the repository. See Secret Scanning AI Detection Configuration below for details. +func (o RepositorySecurityAndAnalysisPtrOutput) SecretScanningAiDetection() RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysis) *RepositorySecurityAndAnalysisSecretScanningAiDetection { + if v == nil { + return nil + } + return v.SecretScanningAiDetection + }).(RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput) +} + +// The secret scanning non-provider patterns configuration for this repository. See Secret Scanning Non-Provider Patterns Configuration below for more details. +func (o RepositorySecurityAndAnalysisPtrOutput) SecretScanningNonProviderPatterns() RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysis) *RepositorySecurityAndAnalysisSecretScanningNonProviderPatterns { + if v == nil { + return nil + } + return v.SecretScanningNonProviderPatterns + }).(RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput) +} + +// The secret scanning push protection configuration for the repository. See Secret Scanning Push Protection Configuration below for details. +func (o RepositorySecurityAndAnalysisPtrOutput) SecretScanningPushProtection() RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysis) *RepositorySecurityAndAnalysisSecretScanningPushProtection { + if v == nil { + return nil + } + return v.SecretScanningPushProtection + }).(RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput) +} + +type RepositorySecurityAndAnalysisAdvancedSecurity struct { + // Set to `enabled` to enable advanced security features on the repository. Can be `enabled` or `disabled`. + Status string `pulumi:"status"` +} + +// RepositorySecurityAndAnalysisAdvancedSecurityInput is an input type that accepts RepositorySecurityAndAnalysisAdvancedSecurityArgs and RepositorySecurityAndAnalysisAdvancedSecurityOutput values. +// You can construct a concrete instance of `RepositorySecurityAndAnalysisAdvancedSecurityInput` via: +// +// RepositorySecurityAndAnalysisAdvancedSecurityArgs{...} +type RepositorySecurityAndAnalysisAdvancedSecurityInput interface { + pulumi.Input + + ToRepositorySecurityAndAnalysisAdvancedSecurityOutput() RepositorySecurityAndAnalysisAdvancedSecurityOutput + ToRepositorySecurityAndAnalysisAdvancedSecurityOutputWithContext(context.Context) RepositorySecurityAndAnalysisAdvancedSecurityOutput +} + +type RepositorySecurityAndAnalysisAdvancedSecurityArgs struct { + // Set to `enabled` to enable advanced security features on the repository. Can be `enabled` or `disabled`. + Status pulumi.StringInput `pulumi:"status"` +} + +func (RepositorySecurityAndAnalysisAdvancedSecurityArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositorySecurityAndAnalysisAdvancedSecurity)(nil)).Elem() +} + +func (i RepositorySecurityAndAnalysisAdvancedSecurityArgs) ToRepositorySecurityAndAnalysisAdvancedSecurityOutput() RepositorySecurityAndAnalysisAdvancedSecurityOutput { + return i.ToRepositorySecurityAndAnalysisAdvancedSecurityOutputWithContext(context.Background()) +} + +func (i RepositorySecurityAndAnalysisAdvancedSecurityArgs) ToRepositorySecurityAndAnalysisAdvancedSecurityOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisAdvancedSecurityOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisAdvancedSecurityOutput) +} + +func (i RepositorySecurityAndAnalysisAdvancedSecurityArgs) ToRepositorySecurityAndAnalysisAdvancedSecurityPtrOutput() RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput { + return i.ToRepositorySecurityAndAnalysisAdvancedSecurityPtrOutputWithContext(context.Background()) +} + +func (i RepositorySecurityAndAnalysisAdvancedSecurityArgs) ToRepositorySecurityAndAnalysisAdvancedSecurityPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisAdvancedSecurityOutput).ToRepositorySecurityAndAnalysisAdvancedSecurityPtrOutputWithContext(ctx) +} + +// RepositorySecurityAndAnalysisAdvancedSecurityPtrInput is an input type that accepts RepositorySecurityAndAnalysisAdvancedSecurityArgs, RepositorySecurityAndAnalysisAdvancedSecurityPtr and RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput values. +// You can construct a concrete instance of `RepositorySecurityAndAnalysisAdvancedSecurityPtrInput` via: +// +// RepositorySecurityAndAnalysisAdvancedSecurityArgs{...} +// +// or: +// +// nil +type RepositorySecurityAndAnalysisAdvancedSecurityPtrInput interface { + pulumi.Input + + ToRepositorySecurityAndAnalysisAdvancedSecurityPtrOutput() RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput + ToRepositorySecurityAndAnalysisAdvancedSecurityPtrOutputWithContext(context.Context) RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput +} + +type repositorySecurityAndAnalysisAdvancedSecurityPtrType RepositorySecurityAndAnalysisAdvancedSecurityArgs + +func RepositorySecurityAndAnalysisAdvancedSecurityPtr(v *RepositorySecurityAndAnalysisAdvancedSecurityArgs) RepositorySecurityAndAnalysisAdvancedSecurityPtrInput { + return (*repositorySecurityAndAnalysisAdvancedSecurityPtrType)(v) +} + +func (*repositorySecurityAndAnalysisAdvancedSecurityPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositorySecurityAndAnalysisAdvancedSecurity)(nil)).Elem() +} + +func (i *repositorySecurityAndAnalysisAdvancedSecurityPtrType) ToRepositorySecurityAndAnalysisAdvancedSecurityPtrOutput() RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput { + return i.ToRepositorySecurityAndAnalysisAdvancedSecurityPtrOutputWithContext(context.Background()) +} + +func (i *repositorySecurityAndAnalysisAdvancedSecurityPtrType) ToRepositorySecurityAndAnalysisAdvancedSecurityPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput) +} + +type RepositorySecurityAndAnalysisAdvancedSecurityOutput struct{ *pulumi.OutputState } + +func (RepositorySecurityAndAnalysisAdvancedSecurityOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositorySecurityAndAnalysisAdvancedSecurity)(nil)).Elem() +} + +func (o RepositorySecurityAndAnalysisAdvancedSecurityOutput) ToRepositorySecurityAndAnalysisAdvancedSecurityOutput() RepositorySecurityAndAnalysisAdvancedSecurityOutput { + return o +} + +func (o RepositorySecurityAndAnalysisAdvancedSecurityOutput) ToRepositorySecurityAndAnalysisAdvancedSecurityOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisAdvancedSecurityOutput { + return o +} + +func (o RepositorySecurityAndAnalysisAdvancedSecurityOutput) ToRepositorySecurityAndAnalysisAdvancedSecurityPtrOutput() RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput { + return o.ToRepositorySecurityAndAnalysisAdvancedSecurityPtrOutputWithContext(context.Background()) +} + +func (o RepositorySecurityAndAnalysisAdvancedSecurityOutput) ToRepositorySecurityAndAnalysisAdvancedSecurityPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositorySecurityAndAnalysisAdvancedSecurity) *RepositorySecurityAndAnalysisAdvancedSecurity { + return &v + }).(RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput) +} + +// Set to `enabled` to enable advanced security features on the repository. Can be `enabled` or `disabled`. +func (o RepositorySecurityAndAnalysisAdvancedSecurityOutput) Status() pulumi.StringOutput { + return o.ApplyT(func(v RepositorySecurityAndAnalysisAdvancedSecurity) string { return v.Status }).(pulumi.StringOutput) +} + +type RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput struct{ *pulumi.OutputState } + +func (RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositorySecurityAndAnalysisAdvancedSecurity)(nil)).Elem() +} + +func (o RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput) ToRepositorySecurityAndAnalysisAdvancedSecurityPtrOutput() RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput { + return o +} + +func (o RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput) ToRepositorySecurityAndAnalysisAdvancedSecurityPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput { + return o +} + +func (o RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput) Elem() RepositorySecurityAndAnalysisAdvancedSecurityOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysisAdvancedSecurity) RepositorySecurityAndAnalysisAdvancedSecurity { + if v != nil { + return *v + } + var ret RepositorySecurityAndAnalysisAdvancedSecurity + return ret + }).(RepositorySecurityAndAnalysisAdvancedSecurityOutput) +} + +// Set to `enabled` to enable advanced security features on the repository. Can be `enabled` or `disabled`. +func (o RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput) Status() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysisAdvancedSecurity) *string { + if v == nil { + return nil + } + return &v.Status + }).(pulumi.StringPtrOutput) +} + +type RepositorySecurityAndAnalysisCodeSecurity struct { + // The GitHub Pages site's build status e.g. `building` or `built`. + Status string `pulumi:"status"` +} + +// RepositorySecurityAndAnalysisCodeSecurityInput is an input type that accepts RepositorySecurityAndAnalysisCodeSecurityArgs and RepositorySecurityAndAnalysisCodeSecurityOutput values. +// You can construct a concrete instance of `RepositorySecurityAndAnalysisCodeSecurityInput` via: +// +// RepositorySecurityAndAnalysisCodeSecurityArgs{...} +type RepositorySecurityAndAnalysisCodeSecurityInput interface { + pulumi.Input + + ToRepositorySecurityAndAnalysisCodeSecurityOutput() RepositorySecurityAndAnalysisCodeSecurityOutput + ToRepositorySecurityAndAnalysisCodeSecurityOutputWithContext(context.Context) RepositorySecurityAndAnalysisCodeSecurityOutput +} + +type RepositorySecurityAndAnalysisCodeSecurityArgs struct { + // The GitHub Pages site's build status e.g. `building` or `built`. + Status pulumi.StringInput `pulumi:"status"` +} + +func (RepositorySecurityAndAnalysisCodeSecurityArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositorySecurityAndAnalysisCodeSecurity)(nil)).Elem() +} + +func (i RepositorySecurityAndAnalysisCodeSecurityArgs) ToRepositorySecurityAndAnalysisCodeSecurityOutput() RepositorySecurityAndAnalysisCodeSecurityOutput { + return i.ToRepositorySecurityAndAnalysisCodeSecurityOutputWithContext(context.Background()) +} + +func (i RepositorySecurityAndAnalysisCodeSecurityArgs) ToRepositorySecurityAndAnalysisCodeSecurityOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisCodeSecurityOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisCodeSecurityOutput) +} + +func (i RepositorySecurityAndAnalysisCodeSecurityArgs) ToRepositorySecurityAndAnalysisCodeSecurityPtrOutput() RepositorySecurityAndAnalysisCodeSecurityPtrOutput { + return i.ToRepositorySecurityAndAnalysisCodeSecurityPtrOutputWithContext(context.Background()) +} + +func (i RepositorySecurityAndAnalysisCodeSecurityArgs) ToRepositorySecurityAndAnalysisCodeSecurityPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisCodeSecurityPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisCodeSecurityOutput).ToRepositorySecurityAndAnalysisCodeSecurityPtrOutputWithContext(ctx) +} + +// RepositorySecurityAndAnalysisCodeSecurityPtrInput is an input type that accepts RepositorySecurityAndAnalysisCodeSecurityArgs, RepositorySecurityAndAnalysisCodeSecurityPtr and RepositorySecurityAndAnalysisCodeSecurityPtrOutput values. +// You can construct a concrete instance of `RepositorySecurityAndAnalysisCodeSecurityPtrInput` via: +// +// RepositorySecurityAndAnalysisCodeSecurityArgs{...} +// +// or: +// +// nil +type RepositorySecurityAndAnalysisCodeSecurityPtrInput interface { + pulumi.Input + + ToRepositorySecurityAndAnalysisCodeSecurityPtrOutput() RepositorySecurityAndAnalysisCodeSecurityPtrOutput + ToRepositorySecurityAndAnalysisCodeSecurityPtrOutputWithContext(context.Context) RepositorySecurityAndAnalysisCodeSecurityPtrOutput +} + +type repositorySecurityAndAnalysisCodeSecurityPtrType RepositorySecurityAndAnalysisCodeSecurityArgs + +func RepositorySecurityAndAnalysisCodeSecurityPtr(v *RepositorySecurityAndAnalysisCodeSecurityArgs) RepositorySecurityAndAnalysisCodeSecurityPtrInput { + return (*repositorySecurityAndAnalysisCodeSecurityPtrType)(v) +} + +func (*repositorySecurityAndAnalysisCodeSecurityPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositorySecurityAndAnalysisCodeSecurity)(nil)).Elem() +} + +func (i *repositorySecurityAndAnalysisCodeSecurityPtrType) ToRepositorySecurityAndAnalysisCodeSecurityPtrOutput() RepositorySecurityAndAnalysisCodeSecurityPtrOutput { + return i.ToRepositorySecurityAndAnalysisCodeSecurityPtrOutputWithContext(context.Background()) +} + +func (i *repositorySecurityAndAnalysisCodeSecurityPtrType) ToRepositorySecurityAndAnalysisCodeSecurityPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisCodeSecurityPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisCodeSecurityPtrOutput) +} + +type RepositorySecurityAndAnalysisCodeSecurityOutput struct{ *pulumi.OutputState } + +func (RepositorySecurityAndAnalysisCodeSecurityOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositorySecurityAndAnalysisCodeSecurity)(nil)).Elem() +} + +func (o RepositorySecurityAndAnalysisCodeSecurityOutput) ToRepositorySecurityAndAnalysisCodeSecurityOutput() RepositorySecurityAndAnalysisCodeSecurityOutput { + return o +} + +func (o RepositorySecurityAndAnalysisCodeSecurityOutput) ToRepositorySecurityAndAnalysisCodeSecurityOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisCodeSecurityOutput { + return o +} + +func (o RepositorySecurityAndAnalysisCodeSecurityOutput) ToRepositorySecurityAndAnalysisCodeSecurityPtrOutput() RepositorySecurityAndAnalysisCodeSecurityPtrOutput { + return o.ToRepositorySecurityAndAnalysisCodeSecurityPtrOutputWithContext(context.Background()) +} + +func (o RepositorySecurityAndAnalysisCodeSecurityOutput) ToRepositorySecurityAndAnalysisCodeSecurityPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisCodeSecurityPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositorySecurityAndAnalysisCodeSecurity) *RepositorySecurityAndAnalysisCodeSecurity { + return &v + }).(RepositorySecurityAndAnalysisCodeSecurityPtrOutput) +} + +// The GitHub Pages site's build status e.g. `building` or `built`. +func (o RepositorySecurityAndAnalysisCodeSecurityOutput) Status() pulumi.StringOutput { + return o.ApplyT(func(v RepositorySecurityAndAnalysisCodeSecurity) string { return v.Status }).(pulumi.StringOutput) +} + +type RepositorySecurityAndAnalysisCodeSecurityPtrOutput struct{ *pulumi.OutputState } + +func (RepositorySecurityAndAnalysisCodeSecurityPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositorySecurityAndAnalysisCodeSecurity)(nil)).Elem() +} + +func (o RepositorySecurityAndAnalysisCodeSecurityPtrOutput) ToRepositorySecurityAndAnalysisCodeSecurityPtrOutput() RepositorySecurityAndAnalysisCodeSecurityPtrOutput { + return o +} + +func (o RepositorySecurityAndAnalysisCodeSecurityPtrOutput) ToRepositorySecurityAndAnalysisCodeSecurityPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisCodeSecurityPtrOutput { + return o +} + +func (o RepositorySecurityAndAnalysisCodeSecurityPtrOutput) Elem() RepositorySecurityAndAnalysisCodeSecurityOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysisCodeSecurity) RepositorySecurityAndAnalysisCodeSecurity { + if v != nil { + return *v + } + var ret RepositorySecurityAndAnalysisCodeSecurity + return ret + }).(RepositorySecurityAndAnalysisCodeSecurityOutput) +} + +// The GitHub Pages site's build status e.g. `building` or `built`. +func (o RepositorySecurityAndAnalysisCodeSecurityPtrOutput) Status() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysisCodeSecurity) *string { + if v == nil { + return nil + } + return &v.Status + }).(pulumi.StringPtrOutput) +} + +type RepositorySecurityAndAnalysisSecretScanning struct { + // The GitHub Pages site's build status e.g. `building` or `built`. + Status string `pulumi:"status"` +} + +// RepositorySecurityAndAnalysisSecretScanningInput is an input type that accepts RepositorySecurityAndAnalysisSecretScanningArgs and RepositorySecurityAndAnalysisSecretScanningOutput values. +// You can construct a concrete instance of `RepositorySecurityAndAnalysisSecretScanningInput` via: +// +// RepositorySecurityAndAnalysisSecretScanningArgs{...} +type RepositorySecurityAndAnalysisSecretScanningInput interface { + pulumi.Input + + ToRepositorySecurityAndAnalysisSecretScanningOutput() RepositorySecurityAndAnalysisSecretScanningOutput + ToRepositorySecurityAndAnalysisSecretScanningOutputWithContext(context.Context) RepositorySecurityAndAnalysisSecretScanningOutput +} + +type RepositorySecurityAndAnalysisSecretScanningArgs struct { + // The GitHub Pages site's build status e.g. `building` or `built`. + Status pulumi.StringInput `pulumi:"status"` +} + +func (RepositorySecurityAndAnalysisSecretScanningArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositorySecurityAndAnalysisSecretScanning)(nil)).Elem() +} + +func (i RepositorySecurityAndAnalysisSecretScanningArgs) ToRepositorySecurityAndAnalysisSecretScanningOutput() RepositorySecurityAndAnalysisSecretScanningOutput { + return i.ToRepositorySecurityAndAnalysisSecretScanningOutputWithContext(context.Background()) +} + +func (i RepositorySecurityAndAnalysisSecretScanningArgs) ToRepositorySecurityAndAnalysisSecretScanningOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisSecretScanningOutput) +} + +func (i RepositorySecurityAndAnalysisSecretScanningArgs) ToRepositorySecurityAndAnalysisSecretScanningPtrOutput() RepositorySecurityAndAnalysisSecretScanningPtrOutput { + return i.ToRepositorySecurityAndAnalysisSecretScanningPtrOutputWithContext(context.Background()) +} + +func (i RepositorySecurityAndAnalysisSecretScanningArgs) ToRepositorySecurityAndAnalysisSecretScanningPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisSecretScanningOutput).ToRepositorySecurityAndAnalysisSecretScanningPtrOutputWithContext(ctx) +} + +// RepositorySecurityAndAnalysisSecretScanningPtrInput is an input type that accepts RepositorySecurityAndAnalysisSecretScanningArgs, RepositorySecurityAndAnalysisSecretScanningPtr and RepositorySecurityAndAnalysisSecretScanningPtrOutput values. +// You can construct a concrete instance of `RepositorySecurityAndAnalysisSecretScanningPtrInput` via: +// +// RepositorySecurityAndAnalysisSecretScanningArgs{...} +// +// or: +// +// nil +type RepositorySecurityAndAnalysisSecretScanningPtrInput interface { + pulumi.Input + + ToRepositorySecurityAndAnalysisSecretScanningPtrOutput() RepositorySecurityAndAnalysisSecretScanningPtrOutput + ToRepositorySecurityAndAnalysisSecretScanningPtrOutputWithContext(context.Context) RepositorySecurityAndAnalysisSecretScanningPtrOutput +} + +type repositorySecurityAndAnalysisSecretScanningPtrType RepositorySecurityAndAnalysisSecretScanningArgs + +func RepositorySecurityAndAnalysisSecretScanningPtr(v *RepositorySecurityAndAnalysisSecretScanningArgs) RepositorySecurityAndAnalysisSecretScanningPtrInput { + return (*repositorySecurityAndAnalysisSecretScanningPtrType)(v) +} + +func (*repositorySecurityAndAnalysisSecretScanningPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositorySecurityAndAnalysisSecretScanning)(nil)).Elem() +} + +func (i *repositorySecurityAndAnalysisSecretScanningPtrType) ToRepositorySecurityAndAnalysisSecretScanningPtrOutput() RepositorySecurityAndAnalysisSecretScanningPtrOutput { + return i.ToRepositorySecurityAndAnalysisSecretScanningPtrOutputWithContext(context.Background()) +} + +func (i *repositorySecurityAndAnalysisSecretScanningPtrType) ToRepositorySecurityAndAnalysisSecretScanningPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisSecretScanningPtrOutput) +} + +type RepositorySecurityAndAnalysisSecretScanningOutput struct{ *pulumi.OutputState } + +func (RepositorySecurityAndAnalysisSecretScanningOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositorySecurityAndAnalysisSecretScanning)(nil)).Elem() +} + +func (o RepositorySecurityAndAnalysisSecretScanningOutput) ToRepositorySecurityAndAnalysisSecretScanningOutput() RepositorySecurityAndAnalysisSecretScanningOutput { + return o +} + +func (o RepositorySecurityAndAnalysisSecretScanningOutput) ToRepositorySecurityAndAnalysisSecretScanningOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningOutput { + return o +} + +func (o RepositorySecurityAndAnalysisSecretScanningOutput) ToRepositorySecurityAndAnalysisSecretScanningPtrOutput() RepositorySecurityAndAnalysisSecretScanningPtrOutput { + return o.ToRepositorySecurityAndAnalysisSecretScanningPtrOutputWithContext(context.Background()) +} + +func (o RepositorySecurityAndAnalysisSecretScanningOutput) ToRepositorySecurityAndAnalysisSecretScanningPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositorySecurityAndAnalysisSecretScanning) *RepositorySecurityAndAnalysisSecretScanning { + return &v + }).(RepositorySecurityAndAnalysisSecretScanningPtrOutput) +} + +// The GitHub Pages site's build status e.g. `building` or `built`. +func (o RepositorySecurityAndAnalysisSecretScanningOutput) Status() pulumi.StringOutput { + return o.ApplyT(func(v RepositorySecurityAndAnalysisSecretScanning) string { return v.Status }).(pulumi.StringOutput) +} + +type RepositorySecurityAndAnalysisSecretScanningPtrOutput struct{ *pulumi.OutputState } + +func (RepositorySecurityAndAnalysisSecretScanningPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositorySecurityAndAnalysisSecretScanning)(nil)).Elem() +} + +func (o RepositorySecurityAndAnalysisSecretScanningPtrOutput) ToRepositorySecurityAndAnalysisSecretScanningPtrOutput() RepositorySecurityAndAnalysisSecretScanningPtrOutput { + return o +} + +func (o RepositorySecurityAndAnalysisSecretScanningPtrOutput) ToRepositorySecurityAndAnalysisSecretScanningPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningPtrOutput { + return o +} + +func (o RepositorySecurityAndAnalysisSecretScanningPtrOutput) Elem() RepositorySecurityAndAnalysisSecretScanningOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysisSecretScanning) RepositorySecurityAndAnalysisSecretScanning { + if v != nil { + return *v + } + var ret RepositorySecurityAndAnalysisSecretScanning + return ret + }).(RepositorySecurityAndAnalysisSecretScanningOutput) +} + +// The GitHub Pages site's build status e.g. `building` or `built`. +func (o RepositorySecurityAndAnalysisSecretScanningPtrOutput) Status() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysisSecretScanning) *string { + if v == nil { + return nil + } + return &v.Status + }).(pulumi.StringPtrOutput) +} + +type RepositorySecurityAndAnalysisSecretScanningAiDetection struct { + // Set to `enabled` to enable secret scanning AI detection on the repository. Can be `enabled` or `disabled`. If set to `enabled`, the repository's visibility must be `public`, `security_and_analysis[0].advanced_security[0].status` must also be set to `enabled`, or your Organization must have split licensing for Advanced security. + Status string `pulumi:"status"` +} + +// RepositorySecurityAndAnalysisSecretScanningAiDetectionInput is an input type that accepts RepositorySecurityAndAnalysisSecretScanningAiDetectionArgs and RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput values. +// You can construct a concrete instance of `RepositorySecurityAndAnalysisSecretScanningAiDetectionInput` via: +// +// RepositorySecurityAndAnalysisSecretScanningAiDetectionArgs{...} +type RepositorySecurityAndAnalysisSecretScanningAiDetectionInput interface { + pulumi.Input + + ToRepositorySecurityAndAnalysisSecretScanningAiDetectionOutput() RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput + ToRepositorySecurityAndAnalysisSecretScanningAiDetectionOutputWithContext(context.Context) RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput +} + +type RepositorySecurityAndAnalysisSecretScanningAiDetectionArgs struct { + // Set to `enabled` to enable secret scanning AI detection on the repository. Can be `enabled` or `disabled`. If set to `enabled`, the repository's visibility must be `public`, `security_and_analysis[0].advanced_security[0].status` must also be set to `enabled`, or your Organization must have split licensing for Advanced security. + Status pulumi.StringInput `pulumi:"status"` +} + +func (RepositorySecurityAndAnalysisSecretScanningAiDetectionArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositorySecurityAndAnalysisSecretScanningAiDetection)(nil)).Elem() +} + +func (i RepositorySecurityAndAnalysisSecretScanningAiDetectionArgs) ToRepositorySecurityAndAnalysisSecretScanningAiDetectionOutput() RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput { + return i.ToRepositorySecurityAndAnalysisSecretScanningAiDetectionOutputWithContext(context.Background()) +} + +func (i RepositorySecurityAndAnalysisSecretScanningAiDetectionArgs) ToRepositorySecurityAndAnalysisSecretScanningAiDetectionOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput) +} + +func (i RepositorySecurityAndAnalysisSecretScanningAiDetectionArgs) ToRepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput() RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput { + return i.ToRepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutputWithContext(context.Background()) +} + +func (i RepositorySecurityAndAnalysisSecretScanningAiDetectionArgs) ToRepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput).ToRepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutputWithContext(ctx) +} + +// RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrInput is an input type that accepts RepositorySecurityAndAnalysisSecretScanningAiDetectionArgs, RepositorySecurityAndAnalysisSecretScanningAiDetectionPtr and RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput values. +// You can construct a concrete instance of `RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrInput` via: +// +// RepositorySecurityAndAnalysisSecretScanningAiDetectionArgs{...} +// +// or: +// +// nil +type RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrInput interface { + pulumi.Input + + ToRepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput() RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput + ToRepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutputWithContext(context.Context) RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput +} + +type repositorySecurityAndAnalysisSecretScanningAiDetectionPtrType RepositorySecurityAndAnalysisSecretScanningAiDetectionArgs + +func RepositorySecurityAndAnalysisSecretScanningAiDetectionPtr(v *RepositorySecurityAndAnalysisSecretScanningAiDetectionArgs) RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrInput { + return (*repositorySecurityAndAnalysisSecretScanningAiDetectionPtrType)(v) +} + +func (*repositorySecurityAndAnalysisSecretScanningAiDetectionPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositorySecurityAndAnalysisSecretScanningAiDetection)(nil)).Elem() +} + +func (i *repositorySecurityAndAnalysisSecretScanningAiDetectionPtrType) ToRepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput() RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput { + return i.ToRepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutputWithContext(context.Background()) +} + +func (i *repositorySecurityAndAnalysisSecretScanningAiDetectionPtrType) ToRepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput) +} + +type RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput struct{ *pulumi.OutputState } + +func (RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositorySecurityAndAnalysisSecretScanningAiDetection)(nil)).Elem() +} + +func (o RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput) ToRepositorySecurityAndAnalysisSecretScanningAiDetectionOutput() RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput { + return o +} + +func (o RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput) ToRepositorySecurityAndAnalysisSecretScanningAiDetectionOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput { + return o +} + +func (o RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput) ToRepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput() RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput { + return o.ToRepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutputWithContext(context.Background()) +} + +func (o RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput) ToRepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositorySecurityAndAnalysisSecretScanningAiDetection) *RepositorySecurityAndAnalysisSecretScanningAiDetection { + return &v + }).(RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput) +} + +// Set to `enabled` to enable secret scanning AI detection on the repository. Can be `enabled` or `disabled`. If set to `enabled`, the repository's visibility must be `public`, `security_and_analysis[0].advanced_security[0].status` must also be set to `enabled`, or your Organization must have split licensing for Advanced security. +func (o RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput) Status() pulumi.StringOutput { + return o.ApplyT(func(v RepositorySecurityAndAnalysisSecretScanningAiDetection) string { return v.Status }).(pulumi.StringOutput) +} + +type RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput struct{ *pulumi.OutputState } + +func (RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositorySecurityAndAnalysisSecretScanningAiDetection)(nil)).Elem() +} + +func (o RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput) ToRepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput() RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput { + return o +} + +func (o RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput) ToRepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput { + return o +} + +func (o RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput) Elem() RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysisSecretScanningAiDetection) RepositorySecurityAndAnalysisSecretScanningAiDetection { + if v != nil { + return *v + } + var ret RepositorySecurityAndAnalysisSecretScanningAiDetection + return ret + }).(RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput) +} + +// Set to `enabled` to enable secret scanning AI detection on the repository. Can be `enabled` or `disabled`. If set to `enabled`, the repository's visibility must be `public`, `security_and_analysis[0].advanced_security[0].status` must also be set to `enabled`, or your Organization must have split licensing for Advanced security. +func (o RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput) Status() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysisSecretScanningAiDetection) *string { + if v == nil { + return nil + } + return &v.Status + }).(pulumi.StringPtrOutput) +} + +type RepositorySecurityAndAnalysisSecretScanningNonProviderPatterns struct { + // The GitHub Pages site's build status e.g. `building` or `built`. + Status string `pulumi:"status"` +} + +// RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsInput is an input type that accepts RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsArgs and RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput values. +// You can construct a concrete instance of `RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsInput` via: +// +// RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsArgs{...} +type RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsInput interface { + pulumi.Input + + ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput() RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput + ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutputWithContext(context.Context) RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput +} + +type RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsArgs struct { + // The GitHub Pages site's build status e.g. `building` or `built`. + Status pulumi.StringInput `pulumi:"status"` +} + +func (RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositorySecurityAndAnalysisSecretScanningNonProviderPatterns)(nil)).Elem() +} + +func (i RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsArgs) ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput() RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput { + return i.ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutputWithContext(context.Background()) +} + +func (i RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsArgs) ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput) +} + +func (i RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsArgs) ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput() RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput { + return i.ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutputWithContext(context.Background()) +} + +func (i RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsArgs) ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput).ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutputWithContext(ctx) +} + +// RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrInput is an input type that accepts RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsArgs, RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtr and RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput values. +// You can construct a concrete instance of `RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrInput` via: +// +// RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsArgs{...} +// +// or: +// +// nil +type RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrInput interface { + pulumi.Input + + ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput() RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput + ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutputWithContext(context.Context) RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput +} + +type repositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrType RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsArgs + +func RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtr(v *RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsArgs) RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrInput { + return (*repositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrType)(v) +} + +func (*repositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositorySecurityAndAnalysisSecretScanningNonProviderPatterns)(nil)).Elem() +} + +func (i *repositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrType) ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput() RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput { + return i.ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutputWithContext(context.Background()) +} + +func (i *repositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrType) ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput) +} + +type RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput struct{ *pulumi.OutputState } + +func (RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositorySecurityAndAnalysisSecretScanningNonProviderPatterns)(nil)).Elem() +} + +func (o RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput) ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput() RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput { + return o +} + +func (o RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput) ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput { + return o +} + +func (o RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput) ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput() RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput { + return o.ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutputWithContext(context.Background()) +} + +func (o RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput) ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositorySecurityAndAnalysisSecretScanningNonProviderPatterns) *RepositorySecurityAndAnalysisSecretScanningNonProviderPatterns { + return &v + }).(RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput) +} + +// The GitHub Pages site's build status e.g. `building` or `built`. +func (o RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput) Status() pulumi.StringOutput { + return o.ApplyT(func(v RepositorySecurityAndAnalysisSecretScanningNonProviderPatterns) string { return v.Status }).(pulumi.StringOutput) +} + +type RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput struct{ *pulumi.OutputState } + +func (RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositorySecurityAndAnalysisSecretScanningNonProviderPatterns)(nil)).Elem() +} + +func (o RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput) ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput() RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput { + return o +} + +func (o RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput) ToRepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput { + return o +} + +func (o RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput) Elem() RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysisSecretScanningNonProviderPatterns) RepositorySecurityAndAnalysisSecretScanningNonProviderPatterns { + if v != nil { + return *v + } + var ret RepositorySecurityAndAnalysisSecretScanningNonProviderPatterns + return ret + }).(RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput) +} + +// The GitHub Pages site's build status e.g. `building` or `built`. +func (o RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput) Status() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysisSecretScanningNonProviderPatterns) *string { + if v == nil { + return nil + } + return &v.Status + }).(pulumi.StringPtrOutput) +} + +type RepositorySecurityAndAnalysisSecretScanningPushProtection struct { + // The GitHub Pages site's build status e.g. `building` or `built`. + Status string `pulumi:"status"` +} + +// RepositorySecurityAndAnalysisSecretScanningPushProtectionInput is an input type that accepts RepositorySecurityAndAnalysisSecretScanningPushProtectionArgs and RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput values. +// You can construct a concrete instance of `RepositorySecurityAndAnalysisSecretScanningPushProtectionInput` via: +// +// RepositorySecurityAndAnalysisSecretScanningPushProtectionArgs{...} +type RepositorySecurityAndAnalysisSecretScanningPushProtectionInput interface { + pulumi.Input + + ToRepositorySecurityAndAnalysisSecretScanningPushProtectionOutput() RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput + ToRepositorySecurityAndAnalysisSecretScanningPushProtectionOutputWithContext(context.Context) RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput +} + +type RepositorySecurityAndAnalysisSecretScanningPushProtectionArgs struct { + // The GitHub Pages site's build status e.g. `building` or `built`. + Status pulumi.StringInput `pulumi:"status"` +} + +func (RepositorySecurityAndAnalysisSecretScanningPushProtectionArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositorySecurityAndAnalysisSecretScanningPushProtection)(nil)).Elem() +} + +func (i RepositorySecurityAndAnalysisSecretScanningPushProtectionArgs) ToRepositorySecurityAndAnalysisSecretScanningPushProtectionOutput() RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput { + return i.ToRepositorySecurityAndAnalysisSecretScanningPushProtectionOutputWithContext(context.Background()) +} + +func (i RepositorySecurityAndAnalysisSecretScanningPushProtectionArgs) ToRepositorySecurityAndAnalysisSecretScanningPushProtectionOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput) +} + +func (i RepositorySecurityAndAnalysisSecretScanningPushProtectionArgs) ToRepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput() RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput { + return i.ToRepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutputWithContext(context.Background()) +} + +func (i RepositorySecurityAndAnalysisSecretScanningPushProtectionArgs) ToRepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput).ToRepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutputWithContext(ctx) +} + +// RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrInput is an input type that accepts RepositorySecurityAndAnalysisSecretScanningPushProtectionArgs, RepositorySecurityAndAnalysisSecretScanningPushProtectionPtr and RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput values. +// You can construct a concrete instance of `RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrInput` via: +// +// RepositorySecurityAndAnalysisSecretScanningPushProtectionArgs{...} +// +// or: +// +// nil +type RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrInput interface { + pulumi.Input + + ToRepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput() RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput + ToRepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutputWithContext(context.Context) RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput +} + +type repositorySecurityAndAnalysisSecretScanningPushProtectionPtrType RepositorySecurityAndAnalysisSecretScanningPushProtectionArgs + +func RepositorySecurityAndAnalysisSecretScanningPushProtectionPtr(v *RepositorySecurityAndAnalysisSecretScanningPushProtectionArgs) RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrInput { + return (*repositorySecurityAndAnalysisSecretScanningPushProtectionPtrType)(v) +} + +func (*repositorySecurityAndAnalysisSecretScanningPushProtectionPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositorySecurityAndAnalysisSecretScanningPushProtection)(nil)).Elem() +} + +func (i *repositorySecurityAndAnalysisSecretScanningPushProtectionPtrType) ToRepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput() RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput { + return i.ToRepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutputWithContext(context.Background()) +} + +func (i *repositorySecurityAndAnalysisSecretScanningPushProtectionPtrType) ToRepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput) +} + +type RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput struct{ *pulumi.OutputState } + +func (RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositorySecurityAndAnalysisSecretScanningPushProtection)(nil)).Elem() +} + +func (o RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput) ToRepositorySecurityAndAnalysisSecretScanningPushProtectionOutput() RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput { + return o +} + +func (o RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput) ToRepositorySecurityAndAnalysisSecretScanningPushProtectionOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput { + return o +} + +func (o RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput) ToRepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput() RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput { + return o.ToRepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutputWithContext(context.Background()) +} + +func (o RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput) ToRepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositorySecurityAndAnalysisSecretScanningPushProtection) *RepositorySecurityAndAnalysisSecretScanningPushProtection { + return &v + }).(RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput) +} + +// The GitHub Pages site's build status e.g. `building` or `built`. +func (o RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput) Status() pulumi.StringOutput { + return o.ApplyT(func(v RepositorySecurityAndAnalysisSecretScanningPushProtection) string { return v.Status }).(pulumi.StringOutput) +} + +type RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput struct{ *pulumi.OutputState } + +func (RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositorySecurityAndAnalysisSecretScanningPushProtection)(nil)).Elem() +} + +func (o RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput) ToRepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput() RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput { + return o +} + +func (o RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput) ToRepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutputWithContext(ctx context.Context) RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput { + return o +} + +func (o RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput) Elem() RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysisSecretScanningPushProtection) RepositorySecurityAndAnalysisSecretScanningPushProtection { + if v != nil { + return *v + } + var ret RepositorySecurityAndAnalysisSecretScanningPushProtection + return ret + }).(RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput) +} + +// The GitHub Pages site's build status e.g. `building` or `built`. +func (o RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput) Status() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositorySecurityAndAnalysisSecretScanningPushProtection) *string { + if v == nil { + return nil + } + return &v.Status + }).(pulumi.StringPtrOutput) +} + +type RepositoryTemplate struct { + // Whether the new repository should include all the branches from the template repository (defaults to false, which includes only the default branch from the template). + // + // > **Note on `internal` visibility with templates**: When creating a repository from a template with `visibility = "internal"`, the provider uses a two-step process due to GitHub API limitations. The template creation API only supports a `private` boolean parameter. Therefore, repositories with `visibility = "internal"` are initially created as private and then immediately updated to internal visibility. This ensures internal repositories are never exposed publicly during creation. + IncludeAllBranches *bool `pulumi:"includeAllBranches"` + // The GitHub organization or user the template repository is owned by. + Owner string `pulumi:"owner"` + // The name of the template repository. + Repository string `pulumi:"repository"` +} + +// RepositoryTemplateInput is an input type that accepts RepositoryTemplateArgs and RepositoryTemplateOutput values. +// You can construct a concrete instance of `RepositoryTemplateInput` via: +// +// RepositoryTemplateArgs{...} +type RepositoryTemplateInput interface { + pulumi.Input + + ToRepositoryTemplateOutput() RepositoryTemplateOutput + ToRepositoryTemplateOutputWithContext(context.Context) RepositoryTemplateOutput +} + +type RepositoryTemplateArgs struct { + // Whether the new repository should include all the branches from the template repository (defaults to false, which includes only the default branch from the template). + // + // > **Note on `internal` visibility with templates**: When creating a repository from a template with `visibility = "internal"`, the provider uses a two-step process due to GitHub API limitations. The template creation API only supports a `private` boolean parameter. Therefore, repositories with `visibility = "internal"` are initially created as private and then immediately updated to internal visibility. This ensures internal repositories are never exposed publicly during creation. + IncludeAllBranches pulumi.BoolPtrInput `pulumi:"includeAllBranches"` + // The GitHub organization or user the template repository is owned by. + Owner pulumi.StringInput `pulumi:"owner"` + // The name of the template repository. + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (RepositoryTemplateArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryTemplate)(nil)).Elem() +} + +func (i RepositoryTemplateArgs) ToRepositoryTemplateOutput() RepositoryTemplateOutput { + return i.ToRepositoryTemplateOutputWithContext(context.Background()) +} + +func (i RepositoryTemplateArgs) ToRepositoryTemplateOutputWithContext(ctx context.Context) RepositoryTemplateOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryTemplateOutput) +} + +func (i RepositoryTemplateArgs) ToRepositoryTemplatePtrOutput() RepositoryTemplatePtrOutput { + return i.ToRepositoryTemplatePtrOutputWithContext(context.Background()) +} + +func (i RepositoryTemplateArgs) ToRepositoryTemplatePtrOutputWithContext(ctx context.Context) RepositoryTemplatePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryTemplateOutput).ToRepositoryTemplatePtrOutputWithContext(ctx) +} + +// RepositoryTemplatePtrInput is an input type that accepts RepositoryTemplateArgs, RepositoryTemplatePtr and RepositoryTemplatePtrOutput values. +// You can construct a concrete instance of `RepositoryTemplatePtrInput` via: +// +// RepositoryTemplateArgs{...} +// +// or: +// +// nil +type RepositoryTemplatePtrInput interface { + pulumi.Input + + ToRepositoryTemplatePtrOutput() RepositoryTemplatePtrOutput + ToRepositoryTemplatePtrOutputWithContext(context.Context) RepositoryTemplatePtrOutput +} + +type repositoryTemplatePtrType RepositoryTemplateArgs + +func RepositoryTemplatePtr(v *RepositoryTemplateArgs) RepositoryTemplatePtrInput { + return (*repositoryTemplatePtrType)(v) +} + +func (*repositoryTemplatePtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryTemplate)(nil)).Elem() +} + +func (i *repositoryTemplatePtrType) ToRepositoryTemplatePtrOutput() RepositoryTemplatePtrOutput { + return i.ToRepositoryTemplatePtrOutputWithContext(context.Background()) +} + +func (i *repositoryTemplatePtrType) ToRepositoryTemplatePtrOutputWithContext(ctx context.Context) RepositoryTemplatePtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryTemplatePtrOutput) +} + +type RepositoryTemplateOutput struct{ *pulumi.OutputState } + +func (RepositoryTemplateOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryTemplate)(nil)).Elem() +} + +func (o RepositoryTemplateOutput) ToRepositoryTemplateOutput() RepositoryTemplateOutput { + return o +} + +func (o RepositoryTemplateOutput) ToRepositoryTemplateOutputWithContext(ctx context.Context) RepositoryTemplateOutput { + return o +} + +func (o RepositoryTemplateOutput) ToRepositoryTemplatePtrOutput() RepositoryTemplatePtrOutput { + return o.ToRepositoryTemplatePtrOutputWithContext(context.Background()) +} + +func (o RepositoryTemplateOutput) ToRepositoryTemplatePtrOutputWithContext(ctx context.Context) RepositoryTemplatePtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryTemplate) *RepositoryTemplate { + return &v + }).(RepositoryTemplatePtrOutput) +} + +// Whether the new repository should include all the branches from the template repository (defaults to false, which includes only the default branch from the template). +// +// > **Note on `internal` visibility with templates**: When creating a repository from a template with `visibility = "internal"`, the provider uses a two-step process due to GitHub API limitations. The template creation API only supports a `private` boolean parameter. Therefore, repositories with `visibility = "internal"` are initially created as private and then immediately updated to internal visibility. This ensures internal repositories are never exposed publicly during creation. +func (o RepositoryTemplateOutput) IncludeAllBranches() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryTemplate) *bool { return v.IncludeAllBranches }).(pulumi.BoolPtrOutput) +} + +// The GitHub organization or user the template repository is owned by. +func (o RepositoryTemplateOutput) Owner() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryTemplate) string { return v.Owner }).(pulumi.StringOutput) +} + +// The name of the template repository. +func (o RepositoryTemplateOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryTemplate) string { return v.Repository }).(pulumi.StringOutput) +} + +type RepositoryTemplatePtrOutput struct{ *pulumi.OutputState } + +func (RepositoryTemplatePtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryTemplate)(nil)).Elem() +} + +func (o RepositoryTemplatePtrOutput) ToRepositoryTemplatePtrOutput() RepositoryTemplatePtrOutput { + return o +} + +func (o RepositoryTemplatePtrOutput) ToRepositoryTemplatePtrOutputWithContext(ctx context.Context) RepositoryTemplatePtrOutput { + return o +} + +func (o RepositoryTemplatePtrOutput) Elem() RepositoryTemplateOutput { + return o.ApplyT(func(v *RepositoryTemplate) RepositoryTemplate { + if v != nil { + return *v + } + var ret RepositoryTemplate + return ret + }).(RepositoryTemplateOutput) +} + +// Whether the new repository should include all the branches from the template repository (defaults to false, which includes only the default branch from the template). +// +// > **Note on `internal` visibility with templates**: When creating a repository from a template with `visibility = "internal"`, the provider uses a two-step process due to GitHub API limitations. The template creation API only supports a `private` boolean parameter. Therefore, repositories with `visibility = "internal"` are initially created as private and then immediately updated to internal visibility. This ensures internal repositories are never exposed publicly during creation. +func (o RepositoryTemplatePtrOutput) IncludeAllBranches() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryTemplate) *bool { + if v == nil { + return nil + } + return v.IncludeAllBranches + }).(pulumi.BoolPtrOutput) +} + +// The GitHub organization or user the template repository is owned by. +func (o RepositoryTemplatePtrOutput) Owner() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryTemplate) *string { + if v == nil { + return nil + } + return &v.Owner + }).(pulumi.StringPtrOutput) +} + +// The name of the template repository. +func (o RepositoryTemplatePtrOutput) Repository() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryTemplate) *string { + if v == nil { + return nil + } + return &v.Repository + }).(pulumi.StringPtrOutput) +} + +type RepositoryWebhookConfiguration struct { + // The content type for the payload. Valid values are either `form` or `json`. + ContentType *string `pulumi:"contentType"` + // Insecure SSL boolean toggle. Defaults to `false`. + InsecureSsl *bool `pulumi:"insecureSsl"` + // The shared secret for the webhook. [See API documentation](https://developer.github.com/v3/repos/hooks/#create-a-hook). + Secret *string `pulumi:"secret"` + // The URL of the webhook. + Url string `pulumi:"url"` +} + +// RepositoryWebhookConfigurationInput is an input type that accepts RepositoryWebhookConfigurationArgs and RepositoryWebhookConfigurationOutput values. +// You can construct a concrete instance of `RepositoryWebhookConfigurationInput` via: +// +// RepositoryWebhookConfigurationArgs{...} +type RepositoryWebhookConfigurationInput interface { + pulumi.Input + + ToRepositoryWebhookConfigurationOutput() RepositoryWebhookConfigurationOutput + ToRepositoryWebhookConfigurationOutputWithContext(context.Context) RepositoryWebhookConfigurationOutput +} + +type RepositoryWebhookConfigurationArgs struct { + // The content type for the payload. Valid values are either `form` or `json`. + ContentType pulumi.StringPtrInput `pulumi:"contentType"` + // Insecure SSL boolean toggle. Defaults to `false`. + InsecureSsl pulumi.BoolPtrInput `pulumi:"insecureSsl"` + // The shared secret for the webhook. [See API documentation](https://developer.github.com/v3/repos/hooks/#create-a-hook). + Secret pulumi.StringPtrInput `pulumi:"secret"` + // The URL of the webhook. + Url pulumi.StringInput `pulumi:"url"` +} + +func (RepositoryWebhookConfigurationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryWebhookConfiguration)(nil)).Elem() +} + +func (i RepositoryWebhookConfigurationArgs) ToRepositoryWebhookConfigurationOutput() RepositoryWebhookConfigurationOutput { + return i.ToRepositoryWebhookConfigurationOutputWithContext(context.Background()) +} + +func (i RepositoryWebhookConfigurationArgs) ToRepositoryWebhookConfigurationOutputWithContext(ctx context.Context) RepositoryWebhookConfigurationOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryWebhookConfigurationOutput) +} + +func (i RepositoryWebhookConfigurationArgs) ToRepositoryWebhookConfigurationPtrOutput() RepositoryWebhookConfigurationPtrOutput { + return i.ToRepositoryWebhookConfigurationPtrOutputWithContext(context.Background()) +} + +func (i RepositoryWebhookConfigurationArgs) ToRepositoryWebhookConfigurationPtrOutputWithContext(ctx context.Context) RepositoryWebhookConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryWebhookConfigurationOutput).ToRepositoryWebhookConfigurationPtrOutputWithContext(ctx) +} + +// RepositoryWebhookConfigurationPtrInput is an input type that accepts RepositoryWebhookConfigurationArgs, RepositoryWebhookConfigurationPtr and RepositoryWebhookConfigurationPtrOutput values. +// You can construct a concrete instance of `RepositoryWebhookConfigurationPtrInput` via: +// +// RepositoryWebhookConfigurationArgs{...} +// +// or: +// +// nil +type RepositoryWebhookConfigurationPtrInput interface { + pulumi.Input + + ToRepositoryWebhookConfigurationPtrOutput() RepositoryWebhookConfigurationPtrOutput + ToRepositoryWebhookConfigurationPtrOutputWithContext(context.Context) RepositoryWebhookConfigurationPtrOutput +} + +type repositoryWebhookConfigurationPtrType RepositoryWebhookConfigurationArgs + +func RepositoryWebhookConfigurationPtr(v *RepositoryWebhookConfigurationArgs) RepositoryWebhookConfigurationPtrInput { + return (*repositoryWebhookConfigurationPtrType)(v) +} + +func (*repositoryWebhookConfigurationPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryWebhookConfiguration)(nil)).Elem() +} + +func (i *repositoryWebhookConfigurationPtrType) ToRepositoryWebhookConfigurationPtrOutput() RepositoryWebhookConfigurationPtrOutput { + return i.ToRepositoryWebhookConfigurationPtrOutputWithContext(context.Background()) +} + +func (i *repositoryWebhookConfigurationPtrType) ToRepositoryWebhookConfigurationPtrOutputWithContext(ctx context.Context) RepositoryWebhookConfigurationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryWebhookConfigurationPtrOutput) +} + +type RepositoryWebhookConfigurationOutput struct{ *pulumi.OutputState } + +func (RepositoryWebhookConfigurationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*RepositoryWebhookConfiguration)(nil)).Elem() +} + +func (o RepositoryWebhookConfigurationOutput) ToRepositoryWebhookConfigurationOutput() RepositoryWebhookConfigurationOutput { + return o +} + +func (o RepositoryWebhookConfigurationOutput) ToRepositoryWebhookConfigurationOutputWithContext(ctx context.Context) RepositoryWebhookConfigurationOutput { + return o +} + +func (o RepositoryWebhookConfigurationOutput) ToRepositoryWebhookConfigurationPtrOutput() RepositoryWebhookConfigurationPtrOutput { + return o.ToRepositoryWebhookConfigurationPtrOutputWithContext(context.Background()) +} + +func (o RepositoryWebhookConfigurationOutput) ToRepositoryWebhookConfigurationPtrOutputWithContext(ctx context.Context) RepositoryWebhookConfigurationPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v RepositoryWebhookConfiguration) *RepositoryWebhookConfiguration { + return &v + }).(RepositoryWebhookConfigurationPtrOutput) +} + +// The content type for the payload. Valid values are either `form` or `json`. +func (o RepositoryWebhookConfigurationOutput) ContentType() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryWebhookConfiguration) *string { return v.ContentType }).(pulumi.StringPtrOutput) +} + +// Insecure SSL boolean toggle. Defaults to `false`. +func (o RepositoryWebhookConfigurationOutput) InsecureSsl() pulumi.BoolPtrOutput { + return o.ApplyT(func(v RepositoryWebhookConfiguration) *bool { return v.InsecureSsl }).(pulumi.BoolPtrOutput) +} + +// The shared secret for the webhook. [See API documentation](https://developer.github.com/v3/repos/hooks/#create-a-hook). +func (o RepositoryWebhookConfigurationOutput) Secret() pulumi.StringPtrOutput { + return o.ApplyT(func(v RepositoryWebhookConfiguration) *string { return v.Secret }).(pulumi.StringPtrOutput) +} + +// The URL of the webhook. +func (o RepositoryWebhookConfigurationOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v RepositoryWebhookConfiguration) string { return v.Url }).(pulumi.StringOutput) +} + +type RepositoryWebhookConfigurationPtrOutput struct{ *pulumi.OutputState } + +func (RepositoryWebhookConfigurationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryWebhookConfiguration)(nil)).Elem() +} + +func (o RepositoryWebhookConfigurationPtrOutput) ToRepositoryWebhookConfigurationPtrOutput() RepositoryWebhookConfigurationPtrOutput { + return o +} + +func (o RepositoryWebhookConfigurationPtrOutput) ToRepositoryWebhookConfigurationPtrOutputWithContext(ctx context.Context) RepositoryWebhookConfigurationPtrOutput { + return o +} + +func (o RepositoryWebhookConfigurationPtrOutput) Elem() RepositoryWebhookConfigurationOutput { + return o.ApplyT(func(v *RepositoryWebhookConfiguration) RepositoryWebhookConfiguration { + if v != nil { + return *v + } + var ret RepositoryWebhookConfiguration + return ret + }).(RepositoryWebhookConfigurationOutput) +} + +// The content type for the payload. Valid values are either `form` or `json`. +func (o RepositoryWebhookConfigurationPtrOutput) ContentType() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryWebhookConfiguration) *string { + if v == nil { + return nil + } + return v.ContentType + }).(pulumi.StringPtrOutput) +} + +// Insecure SSL boolean toggle. Defaults to `false`. +func (o RepositoryWebhookConfigurationPtrOutput) InsecureSsl() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryWebhookConfiguration) *bool { + if v == nil { + return nil + } + return v.InsecureSsl + }).(pulumi.BoolPtrOutput) +} + +// The shared secret for the webhook. [See API documentation](https://developer.github.com/v3/repos/hooks/#create-a-hook). +func (o RepositoryWebhookConfigurationPtrOutput) Secret() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryWebhookConfiguration) *string { + if v == nil { + return nil + } + return v.Secret + }).(pulumi.StringPtrOutput) +} + +// The URL of the webhook. +func (o RepositoryWebhookConfigurationPtrOutput) Url() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryWebhookConfiguration) *string { + if v == nil { + return nil + } + return &v.Url + }).(pulumi.StringPtrOutput) +} + +type TeamMembersMember struct { + // The role of the user within the team. + // Must be one of `member` or `maintainer`. Defaults to `member`. + Role *string `pulumi:"role"` + // The user to add to the team. + Username string `pulumi:"username"` +} + +// TeamMembersMemberInput is an input type that accepts TeamMembersMemberArgs and TeamMembersMemberOutput values. +// You can construct a concrete instance of `TeamMembersMemberInput` via: +// +// TeamMembersMemberArgs{...} +type TeamMembersMemberInput interface { + pulumi.Input + + ToTeamMembersMemberOutput() TeamMembersMemberOutput + ToTeamMembersMemberOutputWithContext(context.Context) TeamMembersMemberOutput +} + +type TeamMembersMemberArgs struct { + // The role of the user within the team. + // Must be one of `member` or `maintainer`. Defaults to `member`. + Role pulumi.StringPtrInput `pulumi:"role"` + // The user to add to the team. + Username pulumi.StringInput `pulumi:"username"` +} + +func (TeamMembersMemberArgs) ElementType() reflect.Type { + return reflect.TypeOf((*TeamMembersMember)(nil)).Elem() +} + +func (i TeamMembersMemberArgs) ToTeamMembersMemberOutput() TeamMembersMemberOutput { + return i.ToTeamMembersMemberOutputWithContext(context.Background()) +} + +func (i TeamMembersMemberArgs) ToTeamMembersMemberOutputWithContext(ctx context.Context) TeamMembersMemberOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamMembersMemberOutput) +} + +// TeamMembersMemberArrayInput is an input type that accepts TeamMembersMemberArray and TeamMembersMemberArrayOutput values. +// You can construct a concrete instance of `TeamMembersMemberArrayInput` via: +// +// TeamMembersMemberArray{ TeamMembersMemberArgs{...} } +type TeamMembersMemberArrayInput interface { + pulumi.Input + + ToTeamMembersMemberArrayOutput() TeamMembersMemberArrayOutput + ToTeamMembersMemberArrayOutputWithContext(context.Context) TeamMembersMemberArrayOutput +} + +type TeamMembersMemberArray []TeamMembersMemberInput + +func (TeamMembersMemberArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]TeamMembersMember)(nil)).Elem() +} + +func (i TeamMembersMemberArray) ToTeamMembersMemberArrayOutput() TeamMembersMemberArrayOutput { + return i.ToTeamMembersMemberArrayOutputWithContext(context.Background()) +} + +func (i TeamMembersMemberArray) ToTeamMembersMemberArrayOutputWithContext(ctx context.Context) TeamMembersMemberArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamMembersMemberArrayOutput) +} + +type TeamMembersMemberOutput struct{ *pulumi.OutputState } + +func (TeamMembersMemberOutput) ElementType() reflect.Type { + return reflect.TypeOf((*TeamMembersMember)(nil)).Elem() +} + +func (o TeamMembersMemberOutput) ToTeamMembersMemberOutput() TeamMembersMemberOutput { + return o +} + +func (o TeamMembersMemberOutput) ToTeamMembersMemberOutputWithContext(ctx context.Context) TeamMembersMemberOutput { + return o +} + +// The role of the user within the team. +// Must be one of `member` or `maintainer`. Defaults to `member`. +func (o TeamMembersMemberOutput) Role() pulumi.StringPtrOutput { + return o.ApplyT(func(v TeamMembersMember) *string { return v.Role }).(pulumi.StringPtrOutput) +} + +// The user to add to the team. +func (o TeamMembersMemberOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v TeamMembersMember) string { return v.Username }).(pulumi.StringOutput) +} + +type TeamMembersMemberArrayOutput struct{ *pulumi.OutputState } + +func (TeamMembersMemberArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]TeamMembersMember)(nil)).Elem() +} + +func (o TeamMembersMemberArrayOutput) ToTeamMembersMemberArrayOutput() TeamMembersMemberArrayOutput { + return o +} + +func (o TeamMembersMemberArrayOutput) ToTeamMembersMemberArrayOutputWithContext(ctx context.Context) TeamMembersMemberArrayOutput { + return o +} + +func (o TeamMembersMemberArrayOutput) Index(i pulumi.IntInput) TeamMembersMemberOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) TeamMembersMember { + return vs[0].([]TeamMembersMember)[vs[1].(int)] + }).(TeamMembersMemberOutput) +} + +type TeamSettingsReviewRequestDelegation struct { + // The algorithm to use when assigning pull requests to team members. Supported values are ROUND_ROBIN and LOAD_BALANCE. + Algorithm *string `pulumi:"algorithm"` + // The number of team members to assign to a pull request. + MemberCount *int `pulumi:"memberCount"` + // Whether to notify the entire team when at least one member is also assigned to the pull request. Can be set independently of `reviewRequestDelegation`. Default value is `false`. + // + // Deprecated: Use the top-level notify attribute instead. + Notify *bool `pulumi:"notify"` +} + +// TeamSettingsReviewRequestDelegationInput is an input type that accepts TeamSettingsReviewRequestDelegationArgs and TeamSettingsReviewRequestDelegationOutput values. +// You can construct a concrete instance of `TeamSettingsReviewRequestDelegationInput` via: +// +// TeamSettingsReviewRequestDelegationArgs{...} +type TeamSettingsReviewRequestDelegationInput interface { + pulumi.Input + + ToTeamSettingsReviewRequestDelegationOutput() TeamSettingsReviewRequestDelegationOutput + ToTeamSettingsReviewRequestDelegationOutputWithContext(context.Context) TeamSettingsReviewRequestDelegationOutput +} + +type TeamSettingsReviewRequestDelegationArgs struct { + // The algorithm to use when assigning pull requests to team members. Supported values are ROUND_ROBIN and LOAD_BALANCE. + Algorithm pulumi.StringPtrInput `pulumi:"algorithm"` + // The number of team members to assign to a pull request. + MemberCount pulumi.IntPtrInput `pulumi:"memberCount"` + // Whether to notify the entire team when at least one member is also assigned to the pull request. Can be set independently of `reviewRequestDelegation`. Default value is `false`. + // + // Deprecated: Use the top-level notify attribute instead. + Notify pulumi.BoolPtrInput `pulumi:"notify"` +} + +func (TeamSettingsReviewRequestDelegationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*TeamSettingsReviewRequestDelegation)(nil)).Elem() +} + +func (i TeamSettingsReviewRequestDelegationArgs) ToTeamSettingsReviewRequestDelegationOutput() TeamSettingsReviewRequestDelegationOutput { + return i.ToTeamSettingsReviewRequestDelegationOutputWithContext(context.Background()) +} + +func (i TeamSettingsReviewRequestDelegationArgs) ToTeamSettingsReviewRequestDelegationOutputWithContext(ctx context.Context) TeamSettingsReviewRequestDelegationOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamSettingsReviewRequestDelegationOutput) +} + +func (i TeamSettingsReviewRequestDelegationArgs) ToTeamSettingsReviewRequestDelegationPtrOutput() TeamSettingsReviewRequestDelegationPtrOutput { + return i.ToTeamSettingsReviewRequestDelegationPtrOutputWithContext(context.Background()) +} + +func (i TeamSettingsReviewRequestDelegationArgs) ToTeamSettingsReviewRequestDelegationPtrOutputWithContext(ctx context.Context) TeamSettingsReviewRequestDelegationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamSettingsReviewRequestDelegationOutput).ToTeamSettingsReviewRequestDelegationPtrOutputWithContext(ctx) +} + +// TeamSettingsReviewRequestDelegationPtrInput is an input type that accepts TeamSettingsReviewRequestDelegationArgs, TeamSettingsReviewRequestDelegationPtr and TeamSettingsReviewRequestDelegationPtrOutput values. +// You can construct a concrete instance of `TeamSettingsReviewRequestDelegationPtrInput` via: +// +// TeamSettingsReviewRequestDelegationArgs{...} +// +// or: +// +// nil +type TeamSettingsReviewRequestDelegationPtrInput interface { + pulumi.Input + + ToTeamSettingsReviewRequestDelegationPtrOutput() TeamSettingsReviewRequestDelegationPtrOutput + ToTeamSettingsReviewRequestDelegationPtrOutputWithContext(context.Context) TeamSettingsReviewRequestDelegationPtrOutput +} + +type teamSettingsReviewRequestDelegationPtrType TeamSettingsReviewRequestDelegationArgs + +func TeamSettingsReviewRequestDelegationPtr(v *TeamSettingsReviewRequestDelegationArgs) TeamSettingsReviewRequestDelegationPtrInput { + return (*teamSettingsReviewRequestDelegationPtrType)(v) +} + +func (*teamSettingsReviewRequestDelegationPtrType) ElementType() reflect.Type { + return reflect.TypeOf((**TeamSettingsReviewRequestDelegation)(nil)).Elem() +} + +func (i *teamSettingsReviewRequestDelegationPtrType) ToTeamSettingsReviewRequestDelegationPtrOutput() TeamSettingsReviewRequestDelegationPtrOutput { + return i.ToTeamSettingsReviewRequestDelegationPtrOutputWithContext(context.Background()) +} + +func (i *teamSettingsReviewRequestDelegationPtrType) ToTeamSettingsReviewRequestDelegationPtrOutputWithContext(ctx context.Context) TeamSettingsReviewRequestDelegationPtrOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamSettingsReviewRequestDelegationPtrOutput) +} + +type TeamSettingsReviewRequestDelegationOutput struct{ *pulumi.OutputState } + +func (TeamSettingsReviewRequestDelegationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*TeamSettingsReviewRequestDelegation)(nil)).Elem() +} + +func (o TeamSettingsReviewRequestDelegationOutput) ToTeamSettingsReviewRequestDelegationOutput() TeamSettingsReviewRequestDelegationOutput { + return o +} + +func (o TeamSettingsReviewRequestDelegationOutput) ToTeamSettingsReviewRequestDelegationOutputWithContext(ctx context.Context) TeamSettingsReviewRequestDelegationOutput { + return o +} + +func (o TeamSettingsReviewRequestDelegationOutput) ToTeamSettingsReviewRequestDelegationPtrOutput() TeamSettingsReviewRequestDelegationPtrOutput { + return o.ToTeamSettingsReviewRequestDelegationPtrOutputWithContext(context.Background()) +} + +func (o TeamSettingsReviewRequestDelegationOutput) ToTeamSettingsReviewRequestDelegationPtrOutputWithContext(ctx context.Context) TeamSettingsReviewRequestDelegationPtrOutput { + return o.ApplyTWithContext(ctx, func(_ context.Context, v TeamSettingsReviewRequestDelegation) *TeamSettingsReviewRequestDelegation { + return &v + }).(TeamSettingsReviewRequestDelegationPtrOutput) +} + +// The algorithm to use when assigning pull requests to team members. Supported values are ROUND_ROBIN and LOAD_BALANCE. +func (o TeamSettingsReviewRequestDelegationOutput) Algorithm() pulumi.StringPtrOutput { + return o.ApplyT(func(v TeamSettingsReviewRequestDelegation) *string { return v.Algorithm }).(pulumi.StringPtrOutput) +} + +// The number of team members to assign to a pull request. +func (o TeamSettingsReviewRequestDelegationOutput) MemberCount() pulumi.IntPtrOutput { + return o.ApplyT(func(v TeamSettingsReviewRequestDelegation) *int { return v.MemberCount }).(pulumi.IntPtrOutput) +} + +// Whether to notify the entire team when at least one member is also assigned to the pull request. Can be set independently of `reviewRequestDelegation`. Default value is `false`. +// +// Deprecated: Use the top-level notify attribute instead. +func (o TeamSettingsReviewRequestDelegationOutput) Notify() pulumi.BoolPtrOutput { + return o.ApplyT(func(v TeamSettingsReviewRequestDelegation) *bool { return v.Notify }).(pulumi.BoolPtrOutput) +} + +type TeamSettingsReviewRequestDelegationPtrOutput struct{ *pulumi.OutputState } + +func (TeamSettingsReviewRequestDelegationPtrOutput) ElementType() reflect.Type { + return reflect.TypeOf((**TeamSettingsReviewRequestDelegation)(nil)).Elem() +} + +func (o TeamSettingsReviewRequestDelegationPtrOutput) ToTeamSettingsReviewRequestDelegationPtrOutput() TeamSettingsReviewRequestDelegationPtrOutput { + return o +} + +func (o TeamSettingsReviewRequestDelegationPtrOutput) ToTeamSettingsReviewRequestDelegationPtrOutputWithContext(ctx context.Context) TeamSettingsReviewRequestDelegationPtrOutput { + return o +} + +func (o TeamSettingsReviewRequestDelegationPtrOutput) Elem() TeamSettingsReviewRequestDelegationOutput { + return o.ApplyT(func(v *TeamSettingsReviewRequestDelegation) TeamSettingsReviewRequestDelegation { + if v != nil { + return *v + } + var ret TeamSettingsReviewRequestDelegation + return ret + }).(TeamSettingsReviewRequestDelegationOutput) +} + +// The algorithm to use when assigning pull requests to team members. Supported values are ROUND_ROBIN and LOAD_BALANCE. +func (o TeamSettingsReviewRequestDelegationPtrOutput) Algorithm() pulumi.StringPtrOutput { + return o.ApplyT(func(v *TeamSettingsReviewRequestDelegation) *string { + if v == nil { + return nil + } + return v.Algorithm + }).(pulumi.StringPtrOutput) +} + +// The number of team members to assign to a pull request. +func (o TeamSettingsReviewRequestDelegationPtrOutput) MemberCount() pulumi.IntPtrOutput { + return o.ApplyT(func(v *TeamSettingsReviewRequestDelegation) *int { + if v == nil { + return nil + } + return v.MemberCount + }).(pulumi.IntPtrOutput) +} + +// Whether to notify the entire team when at least one member is also assigned to the pull request. Can be set independently of `reviewRequestDelegation`. Default value is `false`. +// +// Deprecated: Use the top-level notify attribute instead. +func (o TeamSettingsReviewRequestDelegationPtrOutput) Notify() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *TeamSettingsReviewRequestDelegation) *bool { + if v == nil { + return nil + } + return v.Notify + }).(pulumi.BoolPtrOutput) +} + +type TeamSyncGroupMappingGroup struct { + // The description of the IdP group. + GroupDescription string `pulumi:"groupDescription"` + // The ID of the IdP group. + GroupId string `pulumi:"groupId"` + // The name of the IdP group. + GroupName string `pulumi:"groupName"` +} + +// TeamSyncGroupMappingGroupInput is an input type that accepts TeamSyncGroupMappingGroupArgs and TeamSyncGroupMappingGroupOutput values. +// You can construct a concrete instance of `TeamSyncGroupMappingGroupInput` via: +// +// TeamSyncGroupMappingGroupArgs{...} +type TeamSyncGroupMappingGroupInput interface { + pulumi.Input + + ToTeamSyncGroupMappingGroupOutput() TeamSyncGroupMappingGroupOutput + ToTeamSyncGroupMappingGroupOutputWithContext(context.Context) TeamSyncGroupMappingGroupOutput +} + +type TeamSyncGroupMappingGroupArgs struct { + // The description of the IdP group. + GroupDescription pulumi.StringInput `pulumi:"groupDescription"` + // The ID of the IdP group. + GroupId pulumi.StringInput `pulumi:"groupId"` + // The name of the IdP group. + GroupName pulumi.StringInput `pulumi:"groupName"` +} + +func (TeamSyncGroupMappingGroupArgs) ElementType() reflect.Type { + return reflect.TypeOf((*TeamSyncGroupMappingGroup)(nil)).Elem() +} + +func (i TeamSyncGroupMappingGroupArgs) ToTeamSyncGroupMappingGroupOutput() TeamSyncGroupMappingGroupOutput { + return i.ToTeamSyncGroupMappingGroupOutputWithContext(context.Background()) +} + +func (i TeamSyncGroupMappingGroupArgs) ToTeamSyncGroupMappingGroupOutputWithContext(ctx context.Context) TeamSyncGroupMappingGroupOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamSyncGroupMappingGroupOutput) +} + +// TeamSyncGroupMappingGroupArrayInput is an input type that accepts TeamSyncGroupMappingGroupArray and TeamSyncGroupMappingGroupArrayOutput values. +// You can construct a concrete instance of `TeamSyncGroupMappingGroupArrayInput` via: +// +// TeamSyncGroupMappingGroupArray{ TeamSyncGroupMappingGroupArgs{...} } +type TeamSyncGroupMappingGroupArrayInput interface { + pulumi.Input + + ToTeamSyncGroupMappingGroupArrayOutput() TeamSyncGroupMappingGroupArrayOutput + ToTeamSyncGroupMappingGroupArrayOutputWithContext(context.Context) TeamSyncGroupMappingGroupArrayOutput +} + +type TeamSyncGroupMappingGroupArray []TeamSyncGroupMappingGroupInput + +func (TeamSyncGroupMappingGroupArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]TeamSyncGroupMappingGroup)(nil)).Elem() +} + +func (i TeamSyncGroupMappingGroupArray) ToTeamSyncGroupMappingGroupArrayOutput() TeamSyncGroupMappingGroupArrayOutput { + return i.ToTeamSyncGroupMappingGroupArrayOutputWithContext(context.Background()) +} + +func (i TeamSyncGroupMappingGroupArray) ToTeamSyncGroupMappingGroupArrayOutputWithContext(ctx context.Context) TeamSyncGroupMappingGroupArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamSyncGroupMappingGroupArrayOutput) +} + +type TeamSyncGroupMappingGroupOutput struct{ *pulumi.OutputState } + +func (TeamSyncGroupMappingGroupOutput) ElementType() reflect.Type { + return reflect.TypeOf((*TeamSyncGroupMappingGroup)(nil)).Elem() +} + +func (o TeamSyncGroupMappingGroupOutput) ToTeamSyncGroupMappingGroupOutput() TeamSyncGroupMappingGroupOutput { + return o +} + +func (o TeamSyncGroupMappingGroupOutput) ToTeamSyncGroupMappingGroupOutputWithContext(ctx context.Context) TeamSyncGroupMappingGroupOutput { + return o +} + +// The description of the IdP group. +func (o TeamSyncGroupMappingGroupOutput) GroupDescription() pulumi.StringOutput { + return o.ApplyT(func(v TeamSyncGroupMappingGroup) string { return v.GroupDescription }).(pulumi.StringOutput) +} + +// The ID of the IdP group. +func (o TeamSyncGroupMappingGroupOutput) GroupId() pulumi.StringOutput { + return o.ApplyT(func(v TeamSyncGroupMappingGroup) string { return v.GroupId }).(pulumi.StringOutput) +} + +// The name of the IdP group. +func (o TeamSyncGroupMappingGroupOutput) GroupName() pulumi.StringOutput { + return o.ApplyT(func(v TeamSyncGroupMappingGroup) string { return v.GroupName }).(pulumi.StringOutput) +} + +type TeamSyncGroupMappingGroupArrayOutput struct{ *pulumi.OutputState } + +func (TeamSyncGroupMappingGroupArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]TeamSyncGroupMappingGroup)(nil)).Elem() +} + +func (o TeamSyncGroupMappingGroupArrayOutput) ToTeamSyncGroupMappingGroupArrayOutput() TeamSyncGroupMappingGroupArrayOutput { + return o +} + +func (o TeamSyncGroupMappingGroupArrayOutput) ToTeamSyncGroupMappingGroupArrayOutputWithContext(ctx context.Context) TeamSyncGroupMappingGroupArrayOutput { + return o +} + +func (o TeamSyncGroupMappingGroupArrayOutput) Index(i pulumi.IntInput) TeamSyncGroupMappingGroupOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) TeamSyncGroupMappingGroup { + return vs[0].([]TeamSyncGroupMappingGroup)[vs[1].(int)] + }).(TeamSyncGroupMappingGroupOutput) +} + +type GetActionsEnvironmentSecretsSecret struct { + // Timestamp of the secret creation + CreatedAt string `pulumi:"createdAt"` + // Name of the secret + Name string `pulumi:"name"` + // Timestamp of the secret last update + UpdatedAt string `pulumi:"updatedAt"` +} + +// GetActionsEnvironmentSecretsSecretInput is an input type that accepts GetActionsEnvironmentSecretsSecretArgs and GetActionsEnvironmentSecretsSecretOutput values. +// You can construct a concrete instance of `GetActionsEnvironmentSecretsSecretInput` via: +// +// GetActionsEnvironmentSecretsSecretArgs{...} +type GetActionsEnvironmentSecretsSecretInput interface { + pulumi.Input + + ToGetActionsEnvironmentSecretsSecretOutput() GetActionsEnvironmentSecretsSecretOutput + ToGetActionsEnvironmentSecretsSecretOutputWithContext(context.Context) GetActionsEnvironmentSecretsSecretOutput +} + +type GetActionsEnvironmentSecretsSecretArgs struct { + // Timestamp of the secret creation + CreatedAt pulumi.StringInput `pulumi:"createdAt"` + // Name of the secret + Name pulumi.StringInput `pulumi:"name"` + // Timestamp of the secret last update + UpdatedAt pulumi.StringInput `pulumi:"updatedAt"` +} + +func (GetActionsEnvironmentSecretsSecretArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsEnvironmentSecretsSecret)(nil)).Elem() +} + +func (i GetActionsEnvironmentSecretsSecretArgs) ToGetActionsEnvironmentSecretsSecretOutput() GetActionsEnvironmentSecretsSecretOutput { + return i.ToGetActionsEnvironmentSecretsSecretOutputWithContext(context.Background()) +} + +func (i GetActionsEnvironmentSecretsSecretArgs) ToGetActionsEnvironmentSecretsSecretOutputWithContext(ctx context.Context) GetActionsEnvironmentSecretsSecretOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetActionsEnvironmentSecretsSecretOutput) +} + +// GetActionsEnvironmentSecretsSecretArrayInput is an input type that accepts GetActionsEnvironmentSecretsSecretArray and GetActionsEnvironmentSecretsSecretArrayOutput values. +// You can construct a concrete instance of `GetActionsEnvironmentSecretsSecretArrayInput` via: +// +// GetActionsEnvironmentSecretsSecretArray{ GetActionsEnvironmentSecretsSecretArgs{...} } +type GetActionsEnvironmentSecretsSecretArrayInput interface { + pulumi.Input + + ToGetActionsEnvironmentSecretsSecretArrayOutput() GetActionsEnvironmentSecretsSecretArrayOutput + ToGetActionsEnvironmentSecretsSecretArrayOutputWithContext(context.Context) GetActionsEnvironmentSecretsSecretArrayOutput +} + +type GetActionsEnvironmentSecretsSecretArray []GetActionsEnvironmentSecretsSecretInput + +func (GetActionsEnvironmentSecretsSecretArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetActionsEnvironmentSecretsSecret)(nil)).Elem() +} + +func (i GetActionsEnvironmentSecretsSecretArray) ToGetActionsEnvironmentSecretsSecretArrayOutput() GetActionsEnvironmentSecretsSecretArrayOutput { + return i.ToGetActionsEnvironmentSecretsSecretArrayOutputWithContext(context.Background()) +} + +func (i GetActionsEnvironmentSecretsSecretArray) ToGetActionsEnvironmentSecretsSecretArrayOutputWithContext(ctx context.Context) GetActionsEnvironmentSecretsSecretArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetActionsEnvironmentSecretsSecretArrayOutput) +} + +type GetActionsEnvironmentSecretsSecretOutput struct{ *pulumi.OutputState } + +func (GetActionsEnvironmentSecretsSecretOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsEnvironmentSecretsSecret)(nil)).Elem() +} + +func (o GetActionsEnvironmentSecretsSecretOutput) ToGetActionsEnvironmentSecretsSecretOutput() GetActionsEnvironmentSecretsSecretOutput { + return o +} + +func (o GetActionsEnvironmentSecretsSecretOutput) ToGetActionsEnvironmentSecretsSecretOutputWithContext(ctx context.Context) GetActionsEnvironmentSecretsSecretOutput { + return o +} + +// Timestamp of the secret creation +func (o GetActionsEnvironmentSecretsSecretOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentSecretsSecret) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// Name of the secret +func (o GetActionsEnvironmentSecretsSecretOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentSecretsSecret) string { return v.Name }).(pulumi.StringOutput) +} + +// Timestamp of the secret last update +func (o GetActionsEnvironmentSecretsSecretOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentSecretsSecret) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +type GetActionsEnvironmentSecretsSecretArrayOutput struct{ *pulumi.OutputState } + +func (GetActionsEnvironmentSecretsSecretArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetActionsEnvironmentSecretsSecret)(nil)).Elem() +} + +func (o GetActionsEnvironmentSecretsSecretArrayOutput) ToGetActionsEnvironmentSecretsSecretArrayOutput() GetActionsEnvironmentSecretsSecretArrayOutput { + return o +} + +func (o GetActionsEnvironmentSecretsSecretArrayOutput) ToGetActionsEnvironmentSecretsSecretArrayOutputWithContext(ctx context.Context) GetActionsEnvironmentSecretsSecretArrayOutput { + return o +} + +func (o GetActionsEnvironmentSecretsSecretArrayOutput) Index(i pulumi.IntInput) GetActionsEnvironmentSecretsSecretOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetActionsEnvironmentSecretsSecret { + return vs[0].([]GetActionsEnvironmentSecretsSecret)[vs[1].(int)] + }).(GetActionsEnvironmentSecretsSecretOutput) +} + +type GetActionsEnvironmentVariablesVariable struct { + // Timestamp of the variable creation + CreatedAt string `pulumi:"createdAt"` + // Name of the variable + Name string `pulumi:"name"` + // Timestamp of the variable last update + UpdatedAt string `pulumi:"updatedAt"` + // Value of the variable + Value string `pulumi:"value"` +} + +// GetActionsEnvironmentVariablesVariableInput is an input type that accepts GetActionsEnvironmentVariablesVariableArgs and GetActionsEnvironmentVariablesVariableOutput values. +// You can construct a concrete instance of `GetActionsEnvironmentVariablesVariableInput` via: +// +// GetActionsEnvironmentVariablesVariableArgs{...} +type GetActionsEnvironmentVariablesVariableInput interface { + pulumi.Input + + ToGetActionsEnvironmentVariablesVariableOutput() GetActionsEnvironmentVariablesVariableOutput + ToGetActionsEnvironmentVariablesVariableOutputWithContext(context.Context) GetActionsEnvironmentVariablesVariableOutput +} + +type GetActionsEnvironmentVariablesVariableArgs struct { + // Timestamp of the variable creation + CreatedAt pulumi.StringInput `pulumi:"createdAt"` + // Name of the variable + Name pulumi.StringInput `pulumi:"name"` + // Timestamp of the variable last update + UpdatedAt pulumi.StringInput `pulumi:"updatedAt"` + // Value of the variable + Value pulumi.StringInput `pulumi:"value"` +} + +func (GetActionsEnvironmentVariablesVariableArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsEnvironmentVariablesVariable)(nil)).Elem() +} + +func (i GetActionsEnvironmentVariablesVariableArgs) ToGetActionsEnvironmentVariablesVariableOutput() GetActionsEnvironmentVariablesVariableOutput { + return i.ToGetActionsEnvironmentVariablesVariableOutputWithContext(context.Background()) +} + +func (i GetActionsEnvironmentVariablesVariableArgs) ToGetActionsEnvironmentVariablesVariableOutputWithContext(ctx context.Context) GetActionsEnvironmentVariablesVariableOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetActionsEnvironmentVariablesVariableOutput) +} + +// GetActionsEnvironmentVariablesVariableArrayInput is an input type that accepts GetActionsEnvironmentVariablesVariableArray and GetActionsEnvironmentVariablesVariableArrayOutput values. +// You can construct a concrete instance of `GetActionsEnvironmentVariablesVariableArrayInput` via: +// +// GetActionsEnvironmentVariablesVariableArray{ GetActionsEnvironmentVariablesVariableArgs{...} } +type GetActionsEnvironmentVariablesVariableArrayInput interface { + pulumi.Input + + ToGetActionsEnvironmentVariablesVariableArrayOutput() GetActionsEnvironmentVariablesVariableArrayOutput + ToGetActionsEnvironmentVariablesVariableArrayOutputWithContext(context.Context) GetActionsEnvironmentVariablesVariableArrayOutput +} + +type GetActionsEnvironmentVariablesVariableArray []GetActionsEnvironmentVariablesVariableInput + +func (GetActionsEnvironmentVariablesVariableArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetActionsEnvironmentVariablesVariable)(nil)).Elem() +} + +func (i GetActionsEnvironmentVariablesVariableArray) ToGetActionsEnvironmentVariablesVariableArrayOutput() GetActionsEnvironmentVariablesVariableArrayOutput { + return i.ToGetActionsEnvironmentVariablesVariableArrayOutputWithContext(context.Background()) +} + +func (i GetActionsEnvironmentVariablesVariableArray) ToGetActionsEnvironmentVariablesVariableArrayOutputWithContext(ctx context.Context) GetActionsEnvironmentVariablesVariableArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetActionsEnvironmentVariablesVariableArrayOutput) +} + +type GetActionsEnvironmentVariablesVariableOutput struct{ *pulumi.OutputState } + +func (GetActionsEnvironmentVariablesVariableOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsEnvironmentVariablesVariable)(nil)).Elem() +} + +func (o GetActionsEnvironmentVariablesVariableOutput) ToGetActionsEnvironmentVariablesVariableOutput() GetActionsEnvironmentVariablesVariableOutput { + return o +} + +func (o GetActionsEnvironmentVariablesVariableOutput) ToGetActionsEnvironmentVariablesVariableOutputWithContext(ctx context.Context) GetActionsEnvironmentVariablesVariableOutput { + return o +} + +// Timestamp of the variable creation +func (o GetActionsEnvironmentVariablesVariableOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentVariablesVariable) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// Name of the variable +func (o GetActionsEnvironmentVariablesVariableOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentVariablesVariable) string { return v.Name }).(pulumi.StringOutput) +} + +// Timestamp of the variable last update +func (o GetActionsEnvironmentVariablesVariableOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentVariablesVariable) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// Value of the variable +func (o GetActionsEnvironmentVariablesVariableOutput) Value() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsEnvironmentVariablesVariable) string { return v.Value }).(pulumi.StringOutput) +} + +type GetActionsEnvironmentVariablesVariableArrayOutput struct{ *pulumi.OutputState } + +func (GetActionsEnvironmentVariablesVariableArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetActionsEnvironmentVariablesVariable)(nil)).Elem() +} + +func (o GetActionsEnvironmentVariablesVariableArrayOutput) ToGetActionsEnvironmentVariablesVariableArrayOutput() GetActionsEnvironmentVariablesVariableArrayOutput { + return o +} + +func (o GetActionsEnvironmentVariablesVariableArrayOutput) ToGetActionsEnvironmentVariablesVariableArrayOutputWithContext(ctx context.Context) GetActionsEnvironmentVariablesVariableArrayOutput { + return o +} + +func (o GetActionsEnvironmentVariablesVariableArrayOutput) Index(i pulumi.IntInput) GetActionsEnvironmentVariablesVariableOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetActionsEnvironmentVariablesVariable { + return vs[0].([]GetActionsEnvironmentVariablesVariable)[vs[1].(int)] + }).(GetActionsEnvironmentVariablesVariableOutput) +} + +type GetActionsOrganizationSecretsSecret struct { + // Timestamp of the secret creation + CreatedAt string `pulumi:"createdAt"` + // Secret name + Name string `pulumi:"name"` + // Timestamp of the secret last update + UpdatedAt string `pulumi:"updatedAt"` + // Secret visibility + Visibility string `pulumi:"visibility"` +} + +// GetActionsOrganizationSecretsSecretInput is an input type that accepts GetActionsOrganizationSecretsSecretArgs and GetActionsOrganizationSecretsSecretOutput values. +// You can construct a concrete instance of `GetActionsOrganizationSecretsSecretInput` via: +// +// GetActionsOrganizationSecretsSecretArgs{...} +type GetActionsOrganizationSecretsSecretInput interface { + pulumi.Input + + ToGetActionsOrganizationSecretsSecretOutput() GetActionsOrganizationSecretsSecretOutput + ToGetActionsOrganizationSecretsSecretOutputWithContext(context.Context) GetActionsOrganizationSecretsSecretOutput +} + +type GetActionsOrganizationSecretsSecretArgs struct { + // Timestamp of the secret creation + CreatedAt pulumi.StringInput `pulumi:"createdAt"` + // Secret name + Name pulumi.StringInput `pulumi:"name"` + // Timestamp of the secret last update + UpdatedAt pulumi.StringInput `pulumi:"updatedAt"` + // Secret visibility + Visibility pulumi.StringInput `pulumi:"visibility"` +} + +func (GetActionsOrganizationSecretsSecretArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsOrganizationSecretsSecret)(nil)).Elem() +} + +func (i GetActionsOrganizationSecretsSecretArgs) ToGetActionsOrganizationSecretsSecretOutput() GetActionsOrganizationSecretsSecretOutput { + return i.ToGetActionsOrganizationSecretsSecretOutputWithContext(context.Background()) +} + +func (i GetActionsOrganizationSecretsSecretArgs) ToGetActionsOrganizationSecretsSecretOutputWithContext(ctx context.Context) GetActionsOrganizationSecretsSecretOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetActionsOrganizationSecretsSecretOutput) +} + +// GetActionsOrganizationSecretsSecretArrayInput is an input type that accepts GetActionsOrganizationSecretsSecretArray and GetActionsOrganizationSecretsSecretArrayOutput values. +// You can construct a concrete instance of `GetActionsOrganizationSecretsSecretArrayInput` via: +// +// GetActionsOrganizationSecretsSecretArray{ GetActionsOrganizationSecretsSecretArgs{...} } +type GetActionsOrganizationSecretsSecretArrayInput interface { + pulumi.Input + + ToGetActionsOrganizationSecretsSecretArrayOutput() GetActionsOrganizationSecretsSecretArrayOutput + ToGetActionsOrganizationSecretsSecretArrayOutputWithContext(context.Context) GetActionsOrganizationSecretsSecretArrayOutput +} + +type GetActionsOrganizationSecretsSecretArray []GetActionsOrganizationSecretsSecretInput + +func (GetActionsOrganizationSecretsSecretArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetActionsOrganizationSecretsSecret)(nil)).Elem() +} + +func (i GetActionsOrganizationSecretsSecretArray) ToGetActionsOrganizationSecretsSecretArrayOutput() GetActionsOrganizationSecretsSecretArrayOutput { + return i.ToGetActionsOrganizationSecretsSecretArrayOutputWithContext(context.Background()) +} + +func (i GetActionsOrganizationSecretsSecretArray) ToGetActionsOrganizationSecretsSecretArrayOutputWithContext(ctx context.Context) GetActionsOrganizationSecretsSecretArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetActionsOrganizationSecretsSecretArrayOutput) +} + +type GetActionsOrganizationSecretsSecretOutput struct{ *pulumi.OutputState } + +func (GetActionsOrganizationSecretsSecretOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsOrganizationSecretsSecret)(nil)).Elem() +} + +func (o GetActionsOrganizationSecretsSecretOutput) ToGetActionsOrganizationSecretsSecretOutput() GetActionsOrganizationSecretsSecretOutput { + return o +} + +func (o GetActionsOrganizationSecretsSecretOutput) ToGetActionsOrganizationSecretsSecretOutputWithContext(ctx context.Context) GetActionsOrganizationSecretsSecretOutput { + return o +} + +// Timestamp of the secret creation +func (o GetActionsOrganizationSecretsSecretOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsOrganizationSecretsSecret) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// Secret name +func (o GetActionsOrganizationSecretsSecretOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsOrganizationSecretsSecret) string { return v.Name }).(pulumi.StringOutput) +} + +// Timestamp of the secret last update +func (o GetActionsOrganizationSecretsSecretOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsOrganizationSecretsSecret) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// Secret visibility +func (o GetActionsOrganizationSecretsSecretOutput) Visibility() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsOrganizationSecretsSecret) string { return v.Visibility }).(pulumi.StringOutput) +} + +type GetActionsOrganizationSecretsSecretArrayOutput struct{ *pulumi.OutputState } + +func (GetActionsOrganizationSecretsSecretArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetActionsOrganizationSecretsSecret)(nil)).Elem() +} + +func (o GetActionsOrganizationSecretsSecretArrayOutput) ToGetActionsOrganizationSecretsSecretArrayOutput() GetActionsOrganizationSecretsSecretArrayOutput { + return o +} + +func (o GetActionsOrganizationSecretsSecretArrayOutput) ToGetActionsOrganizationSecretsSecretArrayOutputWithContext(ctx context.Context) GetActionsOrganizationSecretsSecretArrayOutput { + return o +} + +func (o GetActionsOrganizationSecretsSecretArrayOutput) Index(i pulumi.IntInput) GetActionsOrganizationSecretsSecretOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetActionsOrganizationSecretsSecret { + return vs[0].([]GetActionsOrganizationSecretsSecret)[vs[1].(int)] + }).(GetActionsOrganizationSecretsSecretOutput) +} + +type GetActionsOrganizationVariablesVariable struct { + // Timestamp of the variable creation + CreatedAt string `pulumi:"createdAt"` + // Name of the variable + Name string `pulumi:"name"` + // Timestamp of the variable last update + UpdatedAt string `pulumi:"updatedAt"` + // Value of the variable + Value string `pulumi:"value"` + // Visibility of the variable + Visibility string `pulumi:"visibility"` +} + +// GetActionsOrganizationVariablesVariableInput is an input type that accepts GetActionsOrganizationVariablesVariableArgs and GetActionsOrganizationVariablesVariableOutput values. +// You can construct a concrete instance of `GetActionsOrganizationVariablesVariableInput` via: +// +// GetActionsOrganizationVariablesVariableArgs{...} +type GetActionsOrganizationVariablesVariableInput interface { + pulumi.Input + + ToGetActionsOrganizationVariablesVariableOutput() GetActionsOrganizationVariablesVariableOutput + ToGetActionsOrganizationVariablesVariableOutputWithContext(context.Context) GetActionsOrganizationVariablesVariableOutput +} + +type GetActionsOrganizationVariablesVariableArgs struct { + // Timestamp of the variable creation + CreatedAt pulumi.StringInput `pulumi:"createdAt"` + // Name of the variable + Name pulumi.StringInput `pulumi:"name"` + // Timestamp of the variable last update + UpdatedAt pulumi.StringInput `pulumi:"updatedAt"` + // Value of the variable + Value pulumi.StringInput `pulumi:"value"` + // Visibility of the variable + Visibility pulumi.StringInput `pulumi:"visibility"` +} + +func (GetActionsOrganizationVariablesVariableArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsOrganizationVariablesVariable)(nil)).Elem() +} + +func (i GetActionsOrganizationVariablesVariableArgs) ToGetActionsOrganizationVariablesVariableOutput() GetActionsOrganizationVariablesVariableOutput { + return i.ToGetActionsOrganizationVariablesVariableOutputWithContext(context.Background()) +} + +func (i GetActionsOrganizationVariablesVariableArgs) ToGetActionsOrganizationVariablesVariableOutputWithContext(ctx context.Context) GetActionsOrganizationVariablesVariableOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetActionsOrganizationVariablesVariableOutput) +} + +// GetActionsOrganizationVariablesVariableArrayInput is an input type that accepts GetActionsOrganizationVariablesVariableArray and GetActionsOrganizationVariablesVariableArrayOutput values. +// You can construct a concrete instance of `GetActionsOrganizationVariablesVariableArrayInput` via: +// +// GetActionsOrganizationVariablesVariableArray{ GetActionsOrganizationVariablesVariableArgs{...} } +type GetActionsOrganizationVariablesVariableArrayInput interface { + pulumi.Input + + ToGetActionsOrganizationVariablesVariableArrayOutput() GetActionsOrganizationVariablesVariableArrayOutput + ToGetActionsOrganizationVariablesVariableArrayOutputWithContext(context.Context) GetActionsOrganizationVariablesVariableArrayOutput +} + +type GetActionsOrganizationVariablesVariableArray []GetActionsOrganizationVariablesVariableInput + +func (GetActionsOrganizationVariablesVariableArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetActionsOrganizationVariablesVariable)(nil)).Elem() +} + +func (i GetActionsOrganizationVariablesVariableArray) ToGetActionsOrganizationVariablesVariableArrayOutput() GetActionsOrganizationVariablesVariableArrayOutput { + return i.ToGetActionsOrganizationVariablesVariableArrayOutputWithContext(context.Background()) +} + +func (i GetActionsOrganizationVariablesVariableArray) ToGetActionsOrganizationVariablesVariableArrayOutputWithContext(ctx context.Context) GetActionsOrganizationVariablesVariableArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetActionsOrganizationVariablesVariableArrayOutput) +} + +type GetActionsOrganizationVariablesVariableOutput struct{ *pulumi.OutputState } + +func (GetActionsOrganizationVariablesVariableOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsOrganizationVariablesVariable)(nil)).Elem() +} + +func (o GetActionsOrganizationVariablesVariableOutput) ToGetActionsOrganizationVariablesVariableOutput() GetActionsOrganizationVariablesVariableOutput { + return o +} + +func (o GetActionsOrganizationVariablesVariableOutput) ToGetActionsOrganizationVariablesVariableOutputWithContext(ctx context.Context) GetActionsOrganizationVariablesVariableOutput { + return o +} + +// Timestamp of the variable creation +func (o GetActionsOrganizationVariablesVariableOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsOrganizationVariablesVariable) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// Name of the variable +func (o GetActionsOrganizationVariablesVariableOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsOrganizationVariablesVariable) string { return v.Name }).(pulumi.StringOutput) +} + +// Timestamp of the variable last update +func (o GetActionsOrganizationVariablesVariableOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsOrganizationVariablesVariable) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// Value of the variable +func (o GetActionsOrganizationVariablesVariableOutput) Value() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsOrganizationVariablesVariable) string { return v.Value }).(pulumi.StringOutput) +} + +// Visibility of the variable +func (o GetActionsOrganizationVariablesVariableOutput) Visibility() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsOrganizationVariablesVariable) string { return v.Visibility }).(pulumi.StringOutput) +} + +type GetActionsOrganizationVariablesVariableArrayOutput struct{ *pulumi.OutputState } + +func (GetActionsOrganizationVariablesVariableArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetActionsOrganizationVariablesVariable)(nil)).Elem() +} + +func (o GetActionsOrganizationVariablesVariableArrayOutput) ToGetActionsOrganizationVariablesVariableArrayOutput() GetActionsOrganizationVariablesVariableArrayOutput { + return o +} + +func (o GetActionsOrganizationVariablesVariableArrayOutput) ToGetActionsOrganizationVariablesVariableArrayOutputWithContext(ctx context.Context) GetActionsOrganizationVariablesVariableArrayOutput { + return o +} + +func (o GetActionsOrganizationVariablesVariableArrayOutput) Index(i pulumi.IntInput) GetActionsOrganizationVariablesVariableOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetActionsOrganizationVariablesVariable { + return vs[0].([]GetActionsOrganizationVariablesVariable)[vs[1].(int)] + }).(GetActionsOrganizationVariablesVariableOutput) +} + +type GetActionsSecretsSecret struct { + // Timestamp of the secret creation + CreatedAt string `pulumi:"createdAt"` + // The name of the repository. + Name string `pulumi:"name"` + // Timestamp of the secret last update + UpdatedAt string `pulumi:"updatedAt"` +} + +// GetActionsSecretsSecretInput is an input type that accepts GetActionsSecretsSecretArgs and GetActionsSecretsSecretOutput values. +// You can construct a concrete instance of `GetActionsSecretsSecretInput` via: +// +// GetActionsSecretsSecretArgs{...} +type GetActionsSecretsSecretInput interface { + pulumi.Input + + ToGetActionsSecretsSecretOutput() GetActionsSecretsSecretOutput + ToGetActionsSecretsSecretOutputWithContext(context.Context) GetActionsSecretsSecretOutput +} + +type GetActionsSecretsSecretArgs struct { + // Timestamp of the secret creation + CreatedAt pulumi.StringInput `pulumi:"createdAt"` + // The name of the repository. + Name pulumi.StringInput `pulumi:"name"` + // Timestamp of the secret last update + UpdatedAt pulumi.StringInput `pulumi:"updatedAt"` +} + +func (GetActionsSecretsSecretArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsSecretsSecret)(nil)).Elem() +} + +func (i GetActionsSecretsSecretArgs) ToGetActionsSecretsSecretOutput() GetActionsSecretsSecretOutput { + return i.ToGetActionsSecretsSecretOutputWithContext(context.Background()) +} + +func (i GetActionsSecretsSecretArgs) ToGetActionsSecretsSecretOutputWithContext(ctx context.Context) GetActionsSecretsSecretOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetActionsSecretsSecretOutput) +} + +// GetActionsSecretsSecretArrayInput is an input type that accepts GetActionsSecretsSecretArray and GetActionsSecretsSecretArrayOutput values. +// You can construct a concrete instance of `GetActionsSecretsSecretArrayInput` via: +// +// GetActionsSecretsSecretArray{ GetActionsSecretsSecretArgs{...} } +type GetActionsSecretsSecretArrayInput interface { + pulumi.Input + + ToGetActionsSecretsSecretArrayOutput() GetActionsSecretsSecretArrayOutput + ToGetActionsSecretsSecretArrayOutputWithContext(context.Context) GetActionsSecretsSecretArrayOutput +} + +type GetActionsSecretsSecretArray []GetActionsSecretsSecretInput + +func (GetActionsSecretsSecretArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetActionsSecretsSecret)(nil)).Elem() +} + +func (i GetActionsSecretsSecretArray) ToGetActionsSecretsSecretArrayOutput() GetActionsSecretsSecretArrayOutput { + return i.ToGetActionsSecretsSecretArrayOutputWithContext(context.Background()) +} + +func (i GetActionsSecretsSecretArray) ToGetActionsSecretsSecretArrayOutputWithContext(ctx context.Context) GetActionsSecretsSecretArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetActionsSecretsSecretArrayOutput) +} + +type GetActionsSecretsSecretOutput struct{ *pulumi.OutputState } + +func (GetActionsSecretsSecretOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsSecretsSecret)(nil)).Elem() +} + +func (o GetActionsSecretsSecretOutput) ToGetActionsSecretsSecretOutput() GetActionsSecretsSecretOutput { + return o +} + +func (o GetActionsSecretsSecretOutput) ToGetActionsSecretsSecretOutputWithContext(ctx context.Context) GetActionsSecretsSecretOutput { + return o +} + +// Timestamp of the secret creation +func (o GetActionsSecretsSecretOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsSecretsSecret) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// The name of the repository. +func (o GetActionsSecretsSecretOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsSecretsSecret) string { return v.Name }).(pulumi.StringOutput) +} + +// Timestamp of the secret last update +func (o GetActionsSecretsSecretOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsSecretsSecret) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +type GetActionsSecretsSecretArrayOutput struct{ *pulumi.OutputState } + +func (GetActionsSecretsSecretArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetActionsSecretsSecret)(nil)).Elem() +} + +func (o GetActionsSecretsSecretArrayOutput) ToGetActionsSecretsSecretArrayOutput() GetActionsSecretsSecretArrayOutput { + return o +} + +func (o GetActionsSecretsSecretArrayOutput) ToGetActionsSecretsSecretArrayOutputWithContext(ctx context.Context) GetActionsSecretsSecretArrayOutput { + return o +} + +func (o GetActionsSecretsSecretArrayOutput) Index(i pulumi.IntInput) GetActionsSecretsSecretOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetActionsSecretsSecret { + return vs[0].([]GetActionsSecretsSecret)[vs[1].(int)] + }).(GetActionsSecretsSecretOutput) +} + +type GetActionsVariablesVariable struct { + // Timestamp of the variable creation + CreatedAt string `pulumi:"createdAt"` + // The name of the repository. + Name string `pulumi:"name"` + // Timestamp of the variable last update + UpdatedAt string `pulumi:"updatedAt"` + // Value of the variable + Value string `pulumi:"value"` +} + +// GetActionsVariablesVariableInput is an input type that accepts GetActionsVariablesVariableArgs and GetActionsVariablesVariableOutput values. +// You can construct a concrete instance of `GetActionsVariablesVariableInput` via: +// +// GetActionsVariablesVariableArgs{...} +type GetActionsVariablesVariableInput interface { + pulumi.Input + + ToGetActionsVariablesVariableOutput() GetActionsVariablesVariableOutput + ToGetActionsVariablesVariableOutputWithContext(context.Context) GetActionsVariablesVariableOutput +} + +type GetActionsVariablesVariableArgs struct { + // Timestamp of the variable creation + CreatedAt pulumi.StringInput `pulumi:"createdAt"` + // The name of the repository. + Name pulumi.StringInput `pulumi:"name"` + // Timestamp of the variable last update + UpdatedAt pulumi.StringInput `pulumi:"updatedAt"` + // Value of the variable + Value pulumi.StringInput `pulumi:"value"` +} + +func (GetActionsVariablesVariableArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsVariablesVariable)(nil)).Elem() +} + +func (i GetActionsVariablesVariableArgs) ToGetActionsVariablesVariableOutput() GetActionsVariablesVariableOutput { + return i.ToGetActionsVariablesVariableOutputWithContext(context.Background()) +} + +func (i GetActionsVariablesVariableArgs) ToGetActionsVariablesVariableOutputWithContext(ctx context.Context) GetActionsVariablesVariableOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetActionsVariablesVariableOutput) +} + +// GetActionsVariablesVariableArrayInput is an input type that accepts GetActionsVariablesVariableArray and GetActionsVariablesVariableArrayOutput values. +// You can construct a concrete instance of `GetActionsVariablesVariableArrayInput` via: +// +// GetActionsVariablesVariableArray{ GetActionsVariablesVariableArgs{...} } +type GetActionsVariablesVariableArrayInput interface { + pulumi.Input + + ToGetActionsVariablesVariableArrayOutput() GetActionsVariablesVariableArrayOutput + ToGetActionsVariablesVariableArrayOutputWithContext(context.Context) GetActionsVariablesVariableArrayOutput +} + +type GetActionsVariablesVariableArray []GetActionsVariablesVariableInput + +func (GetActionsVariablesVariableArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetActionsVariablesVariable)(nil)).Elem() +} + +func (i GetActionsVariablesVariableArray) ToGetActionsVariablesVariableArrayOutput() GetActionsVariablesVariableArrayOutput { + return i.ToGetActionsVariablesVariableArrayOutputWithContext(context.Background()) +} + +func (i GetActionsVariablesVariableArray) ToGetActionsVariablesVariableArrayOutputWithContext(ctx context.Context) GetActionsVariablesVariableArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetActionsVariablesVariableArrayOutput) +} + +type GetActionsVariablesVariableOutput struct{ *pulumi.OutputState } + +func (GetActionsVariablesVariableOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetActionsVariablesVariable)(nil)).Elem() +} + +func (o GetActionsVariablesVariableOutput) ToGetActionsVariablesVariableOutput() GetActionsVariablesVariableOutput { + return o +} + +func (o GetActionsVariablesVariableOutput) ToGetActionsVariablesVariableOutputWithContext(ctx context.Context) GetActionsVariablesVariableOutput { + return o +} + +// Timestamp of the variable creation +func (o GetActionsVariablesVariableOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsVariablesVariable) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// The name of the repository. +func (o GetActionsVariablesVariableOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsVariablesVariable) string { return v.Name }).(pulumi.StringOutput) +} + +// Timestamp of the variable last update +func (o GetActionsVariablesVariableOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsVariablesVariable) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// Value of the variable +func (o GetActionsVariablesVariableOutput) Value() pulumi.StringOutput { + return o.ApplyT(func(v GetActionsVariablesVariable) string { return v.Value }).(pulumi.StringOutput) +} + +type GetActionsVariablesVariableArrayOutput struct{ *pulumi.OutputState } + +func (GetActionsVariablesVariableArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetActionsVariablesVariable)(nil)).Elem() +} + +func (o GetActionsVariablesVariableArrayOutput) ToGetActionsVariablesVariableArrayOutput() GetActionsVariablesVariableArrayOutput { + return o +} + +func (o GetActionsVariablesVariableArrayOutput) ToGetActionsVariablesVariableArrayOutputWithContext(ctx context.Context) GetActionsVariablesVariableArrayOutput { + return o +} + +func (o GetActionsVariablesVariableArrayOutput) Index(i pulumi.IntInput) GetActionsVariablesVariableOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetActionsVariablesVariable { + return vs[0].([]GetActionsVariablesVariable)[vs[1].(int)] + }).(GetActionsVariablesVariableOutput) +} + +type GetBranchProtectionRulesRule struct { + // Identifies the protection rule pattern. + Pattern string `pulumi:"pattern"` +} + +// GetBranchProtectionRulesRuleInput is an input type that accepts GetBranchProtectionRulesRuleArgs and GetBranchProtectionRulesRuleOutput values. +// You can construct a concrete instance of `GetBranchProtectionRulesRuleInput` via: +// +// GetBranchProtectionRulesRuleArgs{...} +type GetBranchProtectionRulesRuleInput interface { + pulumi.Input + + ToGetBranchProtectionRulesRuleOutput() GetBranchProtectionRulesRuleOutput + ToGetBranchProtectionRulesRuleOutputWithContext(context.Context) GetBranchProtectionRulesRuleOutput +} + +type GetBranchProtectionRulesRuleArgs struct { + // Identifies the protection rule pattern. + Pattern pulumi.StringInput `pulumi:"pattern"` +} + +func (GetBranchProtectionRulesRuleArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetBranchProtectionRulesRule)(nil)).Elem() +} + +func (i GetBranchProtectionRulesRuleArgs) ToGetBranchProtectionRulesRuleOutput() GetBranchProtectionRulesRuleOutput { + return i.ToGetBranchProtectionRulesRuleOutputWithContext(context.Background()) +} + +func (i GetBranchProtectionRulesRuleArgs) ToGetBranchProtectionRulesRuleOutputWithContext(ctx context.Context) GetBranchProtectionRulesRuleOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetBranchProtectionRulesRuleOutput) +} + +// GetBranchProtectionRulesRuleArrayInput is an input type that accepts GetBranchProtectionRulesRuleArray and GetBranchProtectionRulesRuleArrayOutput values. +// You can construct a concrete instance of `GetBranchProtectionRulesRuleArrayInput` via: +// +// GetBranchProtectionRulesRuleArray{ GetBranchProtectionRulesRuleArgs{...} } +type GetBranchProtectionRulesRuleArrayInput interface { + pulumi.Input + + ToGetBranchProtectionRulesRuleArrayOutput() GetBranchProtectionRulesRuleArrayOutput + ToGetBranchProtectionRulesRuleArrayOutputWithContext(context.Context) GetBranchProtectionRulesRuleArrayOutput +} + +type GetBranchProtectionRulesRuleArray []GetBranchProtectionRulesRuleInput + +func (GetBranchProtectionRulesRuleArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetBranchProtectionRulesRule)(nil)).Elem() +} + +func (i GetBranchProtectionRulesRuleArray) ToGetBranchProtectionRulesRuleArrayOutput() GetBranchProtectionRulesRuleArrayOutput { + return i.ToGetBranchProtectionRulesRuleArrayOutputWithContext(context.Background()) +} + +func (i GetBranchProtectionRulesRuleArray) ToGetBranchProtectionRulesRuleArrayOutputWithContext(ctx context.Context) GetBranchProtectionRulesRuleArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetBranchProtectionRulesRuleArrayOutput) +} + +type GetBranchProtectionRulesRuleOutput struct{ *pulumi.OutputState } + +func (GetBranchProtectionRulesRuleOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetBranchProtectionRulesRule)(nil)).Elem() +} + +func (o GetBranchProtectionRulesRuleOutput) ToGetBranchProtectionRulesRuleOutput() GetBranchProtectionRulesRuleOutput { + return o +} + +func (o GetBranchProtectionRulesRuleOutput) ToGetBranchProtectionRulesRuleOutputWithContext(ctx context.Context) GetBranchProtectionRulesRuleOutput { + return o +} + +// Identifies the protection rule pattern. +func (o GetBranchProtectionRulesRuleOutput) Pattern() pulumi.StringOutput { + return o.ApplyT(func(v GetBranchProtectionRulesRule) string { return v.Pattern }).(pulumi.StringOutput) +} + +type GetBranchProtectionRulesRuleArrayOutput struct{ *pulumi.OutputState } + +func (GetBranchProtectionRulesRuleArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetBranchProtectionRulesRule)(nil)).Elem() +} + +func (o GetBranchProtectionRulesRuleArrayOutput) ToGetBranchProtectionRulesRuleArrayOutput() GetBranchProtectionRulesRuleArrayOutput { + return o +} + +func (o GetBranchProtectionRulesRuleArrayOutput) ToGetBranchProtectionRulesRuleArrayOutputWithContext(ctx context.Context) GetBranchProtectionRulesRuleArrayOutput { + return o +} + +func (o GetBranchProtectionRulesRuleArrayOutput) Index(i pulumi.IntInput) GetBranchProtectionRulesRuleOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetBranchProtectionRulesRule { + return vs[0].([]GetBranchProtectionRulesRule)[vs[1].(int)] + }).(GetBranchProtectionRulesRuleOutput) +} + +type GetCodespacesOrganizationSecretsSecret struct { + // Timestamp of the secret creation + CreatedAt string `pulumi:"createdAt"` + // Secret name + Name string `pulumi:"name"` + // Timestamp of the secret last update + UpdatedAt string `pulumi:"updatedAt"` + // Secret visibility + Visibility string `pulumi:"visibility"` +} + +// GetCodespacesOrganizationSecretsSecretInput is an input type that accepts GetCodespacesOrganizationSecretsSecretArgs and GetCodespacesOrganizationSecretsSecretOutput values. +// You can construct a concrete instance of `GetCodespacesOrganizationSecretsSecretInput` via: +// +// GetCodespacesOrganizationSecretsSecretArgs{...} +type GetCodespacesOrganizationSecretsSecretInput interface { + pulumi.Input + + ToGetCodespacesOrganizationSecretsSecretOutput() GetCodespacesOrganizationSecretsSecretOutput + ToGetCodespacesOrganizationSecretsSecretOutputWithContext(context.Context) GetCodespacesOrganizationSecretsSecretOutput +} + +type GetCodespacesOrganizationSecretsSecretArgs struct { + // Timestamp of the secret creation + CreatedAt pulumi.StringInput `pulumi:"createdAt"` + // Secret name + Name pulumi.StringInput `pulumi:"name"` + // Timestamp of the secret last update + UpdatedAt pulumi.StringInput `pulumi:"updatedAt"` + // Secret visibility + Visibility pulumi.StringInput `pulumi:"visibility"` +} + +func (GetCodespacesOrganizationSecretsSecretArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetCodespacesOrganizationSecretsSecret)(nil)).Elem() +} + +func (i GetCodespacesOrganizationSecretsSecretArgs) ToGetCodespacesOrganizationSecretsSecretOutput() GetCodespacesOrganizationSecretsSecretOutput { + return i.ToGetCodespacesOrganizationSecretsSecretOutputWithContext(context.Background()) +} + +func (i GetCodespacesOrganizationSecretsSecretArgs) ToGetCodespacesOrganizationSecretsSecretOutputWithContext(ctx context.Context) GetCodespacesOrganizationSecretsSecretOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetCodespacesOrganizationSecretsSecretOutput) +} + +// GetCodespacesOrganizationSecretsSecretArrayInput is an input type that accepts GetCodespacesOrganizationSecretsSecretArray and GetCodespacesOrganizationSecretsSecretArrayOutput values. +// You can construct a concrete instance of `GetCodespacesOrganizationSecretsSecretArrayInput` via: +// +// GetCodespacesOrganizationSecretsSecretArray{ GetCodespacesOrganizationSecretsSecretArgs{...} } +type GetCodespacesOrganizationSecretsSecretArrayInput interface { + pulumi.Input + + ToGetCodespacesOrganizationSecretsSecretArrayOutput() GetCodespacesOrganizationSecretsSecretArrayOutput + ToGetCodespacesOrganizationSecretsSecretArrayOutputWithContext(context.Context) GetCodespacesOrganizationSecretsSecretArrayOutput +} + +type GetCodespacesOrganizationSecretsSecretArray []GetCodespacesOrganizationSecretsSecretInput + +func (GetCodespacesOrganizationSecretsSecretArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetCodespacesOrganizationSecretsSecret)(nil)).Elem() +} + +func (i GetCodespacesOrganizationSecretsSecretArray) ToGetCodespacesOrganizationSecretsSecretArrayOutput() GetCodespacesOrganizationSecretsSecretArrayOutput { + return i.ToGetCodespacesOrganizationSecretsSecretArrayOutputWithContext(context.Background()) +} + +func (i GetCodespacesOrganizationSecretsSecretArray) ToGetCodespacesOrganizationSecretsSecretArrayOutputWithContext(ctx context.Context) GetCodespacesOrganizationSecretsSecretArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetCodespacesOrganizationSecretsSecretArrayOutput) +} + +type GetCodespacesOrganizationSecretsSecretOutput struct{ *pulumi.OutputState } + +func (GetCodespacesOrganizationSecretsSecretOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetCodespacesOrganizationSecretsSecret)(nil)).Elem() +} + +func (o GetCodespacesOrganizationSecretsSecretOutput) ToGetCodespacesOrganizationSecretsSecretOutput() GetCodespacesOrganizationSecretsSecretOutput { + return o +} + +func (o GetCodespacesOrganizationSecretsSecretOutput) ToGetCodespacesOrganizationSecretsSecretOutputWithContext(ctx context.Context) GetCodespacesOrganizationSecretsSecretOutput { + return o +} + +// Timestamp of the secret creation +func (o GetCodespacesOrganizationSecretsSecretOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesOrganizationSecretsSecret) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// Secret name +func (o GetCodespacesOrganizationSecretsSecretOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesOrganizationSecretsSecret) string { return v.Name }).(pulumi.StringOutput) +} + +// Timestamp of the secret last update +func (o GetCodespacesOrganizationSecretsSecretOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesOrganizationSecretsSecret) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// Secret visibility +func (o GetCodespacesOrganizationSecretsSecretOutput) Visibility() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesOrganizationSecretsSecret) string { return v.Visibility }).(pulumi.StringOutput) +} + +type GetCodespacesOrganizationSecretsSecretArrayOutput struct{ *pulumi.OutputState } + +func (GetCodespacesOrganizationSecretsSecretArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetCodespacesOrganizationSecretsSecret)(nil)).Elem() +} + +func (o GetCodespacesOrganizationSecretsSecretArrayOutput) ToGetCodespacesOrganizationSecretsSecretArrayOutput() GetCodespacesOrganizationSecretsSecretArrayOutput { + return o +} + +func (o GetCodespacesOrganizationSecretsSecretArrayOutput) ToGetCodespacesOrganizationSecretsSecretArrayOutputWithContext(ctx context.Context) GetCodespacesOrganizationSecretsSecretArrayOutput { + return o +} + +func (o GetCodespacesOrganizationSecretsSecretArrayOutput) Index(i pulumi.IntInput) GetCodespacesOrganizationSecretsSecretOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetCodespacesOrganizationSecretsSecret { + return vs[0].([]GetCodespacesOrganizationSecretsSecret)[vs[1].(int)] + }).(GetCodespacesOrganizationSecretsSecretOutput) +} + +type GetCodespacesSecretsSecret struct { + // Timestamp of the secret creation + CreatedAt string `pulumi:"createdAt"` + // The name of the repository. + Name string `pulumi:"name"` + // Timestamp of the secret last update + UpdatedAt string `pulumi:"updatedAt"` +} + +// GetCodespacesSecretsSecretInput is an input type that accepts GetCodespacesSecretsSecretArgs and GetCodespacesSecretsSecretOutput values. +// You can construct a concrete instance of `GetCodespacesSecretsSecretInput` via: +// +// GetCodespacesSecretsSecretArgs{...} +type GetCodespacesSecretsSecretInput interface { + pulumi.Input + + ToGetCodespacesSecretsSecretOutput() GetCodespacesSecretsSecretOutput + ToGetCodespacesSecretsSecretOutputWithContext(context.Context) GetCodespacesSecretsSecretOutput +} + +type GetCodespacesSecretsSecretArgs struct { + // Timestamp of the secret creation + CreatedAt pulumi.StringInput `pulumi:"createdAt"` + // The name of the repository. + Name pulumi.StringInput `pulumi:"name"` + // Timestamp of the secret last update + UpdatedAt pulumi.StringInput `pulumi:"updatedAt"` +} + +func (GetCodespacesSecretsSecretArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetCodespacesSecretsSecret)(nil)).Elem() +} + +func (i GetCodespacesSecretsSecretArgs) ToGetCodespacesSecretsSecretOutput() GetCodespacesSecretsSecretOutput { + return i.ToGetCodespacesSecretsSecretOutputWithContext(context.Background()) +} + +func (i GetCodespacesSecretsSecretArgs) ToGetCodespacesSecretsSecretOutputWithContext(ctx context.Context) GetCodespacesSecretsSecretOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetCodespacesSecretsSecretOutput) +} + +// GetCodespacesSecretsSecretArrayInput is an input type that accepts GetCodespacesSecretsSecretArray and GetCodespacesSecretsSecretArrayOutput values. +// You can construct a concrete instance of `GetCodespacesSecretsSecretArrayInput` via: +// +// GetCodespacesSecretsSecretArray{ GetCodespacesSecretsSecretArgs{...} } +type GetCodespacesSecretsSecretArrayInput interface { + pulumi.Input + + ToGetCodespacesSecretsSecretArrayOutput() GetCodespacesSecretsSecretArrayOutput + ToGetCodespacesSecretsSecretArrayOutputWithContext(context.Context) GetCodespacesSecretsSecretArrayOutput +} + +type GetCodespacesSecretsSecretArray []GetCodespacesSecretsSecretInput + +func (GetCodespacesSecretsSecretArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetCodespacesSecretsSecret)(nil)).Elem() +} + +func (i GetCodespacesSecretsSecretArray) ToGetCodespacesSecretsSecretArrayOutput() GetCodespacesSecretsSecretArrayOutput { + return i.ToGetCodespacesSecretsSecretArrayOutputWithContext(context.Background()) +} + +func (i GetCodespacesSecretsSecretArray) ToGetCodespacesSecretsSecretArrayOutputWithContext(ctx context.Context) GetCodespacesSecretsSecretArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetCodespacesSecretsSecretArrayOutput) +} + +type GetCodespacesSecretsSecretOutput struct{ *pulumi.OutputState } + +func (GetCodespacesSecretsSecretOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetCodespacesSecretsSecret)(nil)).Elem() +} + +func (o GetCodespacesSecretsSecretOutput) ToGetCodespacesSecretsSecretOutput() GetCodespacesSecretsSecretOutput { + return o +} + +func (o GetCodespacesSecretsSecretOutput) ToGetCodespacesSecretsSecretOutputWithContext(ctx context.Context) GetCodespacesSecretsSecretOutput { + return o +} + +// Timestamp of the secret creation +func (o GetCodespacesSecretsSecretOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesSecretsSecret) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// The name of the repository. +func (o GetCodespacesSecretsSecretOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesSecretsSecret) string { return v.Name }).(pulumi.StringOutput) +} + +// Timestamp of the secret last update +func (o GetCodespacesSecretsSecretOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesSecretsSecret) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +type GetCodespacesSecretsSecretArrayOutput struct{ *pulumi.OutputState } + +func (GetCodespacesSecretsSecretArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetCodespacesSecretsSecret)(nil)).Elem() +} + +func (o GetCodespacesSecretsSecretArrayOutput) ToGetCodespacesSecretsSecretArrayOutput() GetCodespacesSecretsSecretArrayOutput { + return o +} + +func (o GetCodespacesSecretsSecretArrayOutput) ToGetCodespacesSecretsSecretArrayOutputWithContext(ctx context.Context) GetCodespacesSecretsSecretArrayOutput { + return o +} + +func (o GetCodespacesSecretsSecretArrayOutput) Index(i pulumi.IntInput) GetCodespacesSecretsSecretOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetCodespacesSecretsSecret { + return vs[0].([]GetCodespacesSecretsSecret)[vs[1].(int)] + }).(GetCodespacesSecretsSecretOutput) +} + +type GetCodespacesUserSecretsSecret struct { + // Timestamp of the secret creation + CreatedAt string `pulumi:"createdAt"` + // Secret name + Name string `pulumi:"name"` + // Timestamp of the secret last update + UpdatedAt string `pulumi:"updatedAt"` + // Secret visibility + Visibility string `pulumi:"visibility"` +} + +// GetCodespacesUserSecretsSecretInput is an input type that accepts GetCodespacesUserSecretsSecretArgs and GetCodespacesUserSecretsSecretOutput values. +// You can construct a concrete instance of `GetCodespacesUserSecretsSecretInput` via: +// +// GetCodespacesUserSecretsSecretArgs{...} +type GetCodespacesUserSecretsSecretInput interface { + pulumi.Input + + ToGetCodespacesUserSecretsSecretOutput() GetCodespacesUserSecretsSecretOutput + ToGetCodespacesUserSecretsSecretOutputWithContext(context.Context) GetCodespacesUserSecretsSecretOutput +} + +type GetCodespacesUserSecretsSecretArgs struct { + // Timestamp of the secret creation + CreatedAt pulumi.StringInput `pulumi:"createdAt"` + // Secret name + Name pulumi.StringInput `pulumi:"name"` + // Timestamp of the secret last update + UpdatedAt pulumi.StringInput `pulumi:"updatedAt"` + // Secret visibility + Visibility pulumi.StringInput `pulumi:"visibility"` +} + +func (GetCodespacesUserSecretsSecretArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetCodespacesUserSecretsSecret)(nil)).Elem() +} + +func (i GetCodespacesUserSecretsSecretArgs) ToGetCodespacesUserSecretsSecretOutput() GetCodespacesUserSecretsSecretOutput { + return i.ToGetCodespacesUserSecretsSecretOutputWithContext(context.Background()) +} + +func (i GetCodespacesUserSecretsSecretArgs) ToGetCodespacesUserSecretsSecretOutputWithContext(ctx context.Context) GetCodespacesUserSecretsSecretOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetCodespacesUserSecretsSecretOutput) +} + +// GetCodespacesUserSecretsSecretArrayInput is an input type that accepts GetCodespacesUserSecretsSecretArray and GetCodespacesUserSecretsSecretArrayOutput values. +// You can construct a concrete instance of `GetCodespacesUserSecretsSecretArrayInput` via: +// +// GetCodespacesUserSecretsSecretArray{ GetCodespacesUserSecretsSecretArgs{...} } +type GetCodespacesUserSecretsSecretArrayInput interface { + pulumi.Input + + ToGetCodespacesUserSecretsSecretArrayOutput() GetCodespacesUserSecretsSecretArrayOutput + ToGetCodespacesUserSecretsSecretArrayOutputWithContext(context.Context) GetCodespacesUserSecretsSecretArrayOutput +} + +type GetCodespacesUserSecretsSecretArray []GetCodespacesUserSecretsSecretInput + +func (GetCodespacesUserSecretsSecretArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetCodespacesUserSecretsSecret)(nil)).Elem() +} + +func (i GetCodespacesUserSecretsSecretArray) ToGetCodespacesUserSecretsSecretArrayOutput() GetCodespacesUserSecretsSecretArrayOutput { + return i.ToGetCodespacesUserSecretsSecretArrayOutputWithContext(context.Background()) +} + +func (i GetCodespacesUserSecretsSecretArray) ToGetCodespacesUserSecretsSecretArrayOutputWithContext(ctx context.Context) GetCodespacesUserSecretsSecretArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetCodespacesUserSecretsSecretArrayOutput) +} + +type GetCodespacesUserSecretsSecretOutput struct{ *pulumi.OutputState } + +func (GetCodespacesUserSecretsSecretOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetCodespacesUserSecretsSecret)(nil)).Elem() +} + +func (o GetCodespacesUserSecretsSecretOutput) ToGetCodespacesUserSecretsSecretOutput() GetCodespacesUserSecretsSecretOutput { + return o +} + +func (o GetCodespacesUserSecretsSecretOutput) ToGetCodespacesUserSecretsSecretOutputWithContext(ctx context.Context) GetCodespacesUserSecretsSecretOutput { + return o +} + +// Timestamp of the secret creation +func (o GetCodespacesUserSecretsSecretOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesUserSecretsSecret) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// Secret name +func (o GetCodespacesUserSecretsSecretOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesUserSecretsSecret) string { return v.Name }).(pulumi.StringOutput) +} + +// Timestamp of the secret last update +func (o GetCodespacesUserSecretsSecretOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesUserSecretsSecret) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// Secret visibility +func (o GetCodespacesUserSecretsSecretOutput) Visibility() pulumi.StringOutput { + return o.ApplyT(func(v GetCodespacesUserSecretsSecret) string { return v.Visibility }).(pulumi.StringOutput) +} + +type GetCodespacesUserSecretsSecretArrayOutput struct{ *pulumi.OutputState } + +func (GetCodespacesUserSecretsSecretArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetCodespacesUserSecretsSecret)(nil)).Elem() +} + +func (o GetCodespacesUserSecretsSecretArrayOutput) ToGetCodespacesUserSecretsSecretArrayOutput() GetCodespacesUserSecretsSecretArrayOutput { + return o +} + +func (o GetCodespacesUserSecretsSecretArrayOutput) ToGetCodespacesUserSecretsSecretArrayOutputWithContext(ctx context.Context) GetCodespacesUserSecretsSecretArrayOutput { + return o +} + +func (o GetCodespacesUserSecretsSecretArrayOutput) Index(i pulumi.IntInput) GetCodespacesUserSecretsSecretOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetCodespacesUserSecretsSecret { + return vs[0].([]GetCodespacesUserSecretsSecret)[vs[1].(int)] + }).(GetCodespacesUserSecretsSecretOutput) +} + +type GetCollaboratorsCollaborator struct { + // The GitHub API URL for the collaborator's events. + EventsUrl string `pulumi:"eventsUrl"` + // The GitHub API URL for the collaborator's followers. + FollowersUrl string `pulumi:"followersUrl"` + // The GitHub API URL for those following the collaborator. + FollowingUrl string `pulumi:"followingUrl"` + // The GitHub API URL for the collaborator's gists. + GistsUrl string `pulumi:"gistsUrl"` + // The GitHub HTML URL for the collaborator. + HtmlUrl string `pulumi:"htmlUrl"` + // The ID of the collaborator. + Id int `pulumi:"id"` + // The collaborator's login. + Login string `pulumi:"login"` + // The GitHub API URL for the collaborator's organizations. + OrganizationsUrl string `pulumi:"organizationsUrl"` + // Filter collaborators returned by their permission. Can be one of: `pull`, `triage`, `push`, `maintain`, `admin`. Defaults to not doing any filtering on permission. + Permission string `pulumi:"permission"` + // The GitHub API URL for the collaborator's received events. + ReceivedEventsUrl string `pulumi:"receivedEventsUrl"` + // The GitHub API URL for the collaborator's repositories. + ReposUrl string `pulumi:"reposUrl"` + // Whether the user is a GitHub admin. + SiteAdmin bool `pulumi:"siteAdmin"` + // The GitHub API URL for the collaborator's starred repositories. + StarredUrl string `pulumi:"starredUrl"` + // The GitHub API URL for the collaborator's subscribed repositories. + SubscriptionsUrl string `pulumi:"subscriptionsUrl"` + // The type of the collaborator (ex. `user`). + Type string `pulumi:"type"` + // The GitHub API URL for the collaborator. + Url string `pulumi:"url"` +} + +// GetCollaboratorsCollaboratorInput is an input type that accepts GetCollaboratorsCollaboratorArgs and GetCollaboratorsCollaboratorOutput values. +// You can construct a concrete instance of `GetCollaboratorsCollaboratorInput` via: +// +// GetCollaboratorsCollaboratorArgs{...} +type GetCollaboratorsCollaboratorInput interface { + pulumi.Input + + ToGetCollaboratorsCollaboratorOutput() GetCollaboratorsCollaboratorOutput + ToGetCollaboratorsCollaboratorOutputWithContext(context.Context) GetCollaboratorsCollaboratorOutput +} + +type GetCollaboratorsCollaboratorArgs struct { + // The GitHub API URL for the collaborator's events. + EventsUrl pulumi.StringInput `pulumi:"eventsUrl"` + // The GitHub API URL for the collaborator's followers. + FollowersUrl pulumi.StringInput `pulumi:"followersUrl"` + // The GitHub API URL for those following the collaborator. + FollowingUrl pulumi.StringInput `pulumi:"followingUrl"` + // The GitHub API URL for the collaborator's gists. + GistsUrl pulumi.StringInput `pulumi:"gistsUrl"` + // The GitHub HTML URL for the collaborator. + HtmlUrl pulumi.StringInput `pulumi:"htmlUrl"` + // The ID of the collaborator. + Id pulumi.IntInput `pulumi:"id"` + // The collaborator's login. + Login pulumi.StringInput `pulumi:"login"` + // The GitHub API URL for the collaborator's organizations. + OrganizationsUrl pulumi.StringInput `pulumi:"organizationsUrl"` + // Filter collaborators returned by their permission. Can be one of: `pull`, `triage`, `push`, `maintain`, `admin`. Defaults to not doing any filtering on permission. + Permission pulumi.StringInput `pulumi:"permission"` + // The GitHub API URL for the collaborator's received events. + ReceivedEventsUrl pulumi.StringInput `pulumi:"receivedEventsUrl"` + // The GitHub API URL for the collaborator's repositories. + ReposUrl pulumi.StringInput `pulumi:"reposUrl"` + // Whether the user is a GitHub admin. + SiteAdmin pulumi.BoolInput `pulumi:"siteAdmin"` + // The GitHub API URL for the collaborator's starred repositories. + StarredUrl pulumi.StringInput `pulumi:"starredUrl"` + // The GitHub API URL for the collaborator's subscribed repositories. + SubscriptionsUrl pulumi.StringInput `pulumi:"subscriptionsUrl"` + // The type of the collaborator (ex. `user`). + Type pulumi.StringInput `pulumi:"type"` + // The GitHub API URL for the collaborator. + Url pulumi.StringInput `pulumi:"url"` +} + +func (GetCollaboratorsCollaboratorArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetCollaboratorsCollaborator)(nil)).Elem() +} + +func (i GetCollaboratorsCollaboratorArgs) ToGetCollaboratorsCollaboratorOutput() GetCollaboratorsCollaboratorOutput { + return i.ToGetCollaboratorsCollaboratorOutputWithContext(context.Background()) +} + +func (i GetCollaboratorsCollaboratorArgs) ToGetCollaboratorsCollaboratorOutputWithContext(ctx context.Context) GetCollaboratorsCollaboratorOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetCollaboratorsCollaboratorOutput) +} + +// GetCollaboratorsCollaboratorArrayInput is an input type that accepts GetCollaboratorsCollaboratorArray and GetCollaboratorsCollaboratorArrayOutput values. +// You can construct a concrete instance of `GetCollaboratorsCollaboratorArrayInput` via: +// +// GetCollaboratorsCollaboratorArray{ GetCollaboratorsCollaboratorArgs{...} } +type GetCollaboratorsCollaboratorArrayInput interface { + pulumi.Input + + ToGetCollaboratorsCollaboratorArrayOutput() GetCollaboratorsCollaboratorArrayOutput + ToGetCollaboratorsCollaboratorArrayOutputWithContext(context.Context) GetCollaboratorsCollaboratorArrayOutput +} + +type GetCollaboratorsCollaboratorArray []GetCollaboratorsCollaboratorInput + +func (GetCollaboratorsCollaboratorArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetCollaboratorsCollaborator)(nil)).Elem() +} + +func (i GetCollaboratorsCollaboratorArray) ToGetCollaboratorsCollaboratorArrayOutput() GetCollaboratorsCollaboratorArrayOutput { + return i.ToGetCollaboratorsCollaboratorArrayOutputWithContext(context.Background()) +} + +func (i GetCollaboratorsCollaboratorArray) ToGetCollaboratorsCollaboratorArrayOutputWithContext(ctx context.Context) GetCollaboratorsCollaboratorArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetCollaboratorsCollaboratorArrayOutput) +} + +type GetCollaboratorsCollaboratorOutput struct{ *pulumi.OutputState } + +func (GetCollaboratorsCollaboratorOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetCollaboratorsCollaborator)(nil)).Elem() +} + +func (o GetCollaboratorsCollaboratorOutput) ToGetCollaboratorsCollaboratorOutput() GetCollaboratorsCollaboratorOutput { + return o +} + +func (o GetCollaboratorsCollaboratorOutput) ToGetCollaboratorsCollaboratorOutputWithContext(ctx context.Context) GetCollaboratorsCollaboratorOutput { + return o +} + +// The GitHub API URL for the collaborator's events. +func (o GetCollaboratorsCollaboratorOutput) EventsUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsCollaborator) string { return v.EventsUrl }).(pulumi.StringOutput) +} + +// The GitHub API URL for the collaborator's followers. +func (o GetCollaboratorsCollaboratorOutput) FollowersUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsCollaborator) string { return v.FollowersUrl }).(pulumi.StringOutput) +} + +// The GitHub API URL for those following the collaborator. +func (o GetCollaboratorsCollaboratorOutput) FollowingUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsCollaborator) string { return v.FollowingUrl }).(pulumi.StringOutput) +} + +// The GitHub API URL for the collaborator's gists. +func (o GetCollaboratorsCollaboratorOutput) GistsUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsCollaborator) string { return v.GistsUrl }).(pulumi.StringOutput) +} + +// The GitHub HTML URL for the collaborator. +func (o GetCollaboratorsCollaboratorOutput) HtmlUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsCollaborator) string { return v.HtmlUrl }).(pulumi.StringOutput) +} + +// The ID of the collaborator. +func (o GetCollaboratorsCollaboratorOutput) Id() pulumi.IntOutput { + return o.ApplyT(func(v GetCollaboratorsCollaborator) int { return v.Id }).(pulumi.IntOutput) +} + +// The collaborator's login. +func (o GetCollaboratorsCollaboratorOutput) Login() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsCollaborator) string { return v.Login }).(pulumi.StringOutput) +} + +// The GitHub API URL for the collaborator's organizations. +func (o GetCollaboratorsCollaboratorOutput) OrganizationsUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsCollaborator) string { return v.OrganizationsUrl }).(pulumi.StringOutput) +} + +// Filter collaborators returned by their permission. Can be one of: `pull`, `triage`, `push`, `maintain`, `admin`. Defaults to not doing any filtering on permission. +func (o GetCollaboratorsCollaboratorOutput) Permission() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsCollaborator) string { return v.Permission }).(pulumi.StringOutput) +} + +// The GitHub API URL for the collaborator's received events. +func (o GetCollaboratorsCollaboratorOutput) ReceivedEventsUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsCollaborator) string { return v.ReceivedEventsUrl }).(pulumi.StringOutput) +} + +// The GitHub API URL for the collaborator's repositories. +func (o GetCollaboratorsCollaboratorOutput) ReposUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsCollaborator) string { return v.ReposUrl }).(pulumi.StringOutput) +} + +// Whether the user is a GitHub admin. +func (o GetCollaboratorsCollaboratorOutput) SiteAdmin() pulumi.BoolOutput { + return o.ApplyT(func(v GetCollaboratorsCollaborator) bool { return v.SiteAdmin }).(pulumi.BoolOutput) +} + +// The GitHub API URL for the collaborator's starred repositories. +func (o GetCollaboratorsCollaboratorOutput) StarredUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsCollaborator) string { return v.StarredUrl }).(pulumi.StringOutput) +} + +// The GitHub API URL for the collaborator's subscribed repositories. +func (o GetCollaboratorsCollaboratorOutput) SubscriptionsUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsCollaborator) string { return v.SubscriptionsUrl }).(pulumi.StringOutput) +} + +// The type of the collaborator (ex. `user`). +func (o GetCollaboratorsCollaboratorOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsCollaborator) string { return v.Type }).(pulumi.StringOutput) +} + +// The GitHub API URL for the collaborator. +func (o GetCollaboratorsCollaboratorOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v GetCollaboratorsCollaborator) string { return v.Url }).(pulumi.StringOutput) +} + +type GetCollaboratorsCollaboratorArrayOutput struct{ *pulumi.OutputState } + +func (GetCollaboratorsCollaboratorArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetCollaboratorsCollaborator)(nil)).Elem() +} + +func (o GetCollaboratorsCollaboratorArrayOutput) ToGetCollaboratorsCollaboratorArrayOutput() GetCollaboratorsCollaboratorArrayOutput { + return o +} + +func (o GetCollaboratorsCollaboratorArrayOutput) ToGetCollaboratorsCollaboratorArrayOutputWithContext(ctx context.Context) GetCollaboratorsCollaboratorArrayOutput { + return o +} + +func (o GetCollaboratorsCollaboratorArrayOutput) Index(i pulumi.IntInput) GetCollaboratorsCollaboratorOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetCollaboratorsCollaborator { + return vs[0].([]GetCollaboratorsCollaborator)[vs[1].(int)] + }).(GetCollaboratorsCollaboratorOutput) +} + +type GetDependabotOrganizationSecretsSecret struct { + // Timestamp of the secret creation + CreatedAt string `pulumi:"createdAt"` + // Secret name + Name string `pulumi:"name"` + // Timestamp of the secret last update + UpdatedAt string `pulumi:"updatedAt"` + // Secret visibility + Visibility string `pulumi:"visibility"` +} + +// GetDependabotOrganizationSecretsSecretInput is an input type that accepts GetDependabotOrganizationSecretsSecretArgs and GetDependabotOrganizationSecretsSecretOutput values. +// You can construct a concrete instance of `GetDependabotOrganizationSecretsSecretInput` via: +// +// GetDependabotOrganizationSecretsSecretArgs{...} +type GetDependabotOrganizationSecretsSecretInput interface { + pulumi.Input + + ToGetDependabotOrganizationSecretsSecretOutput() GetDependabotOrganizationSecretsSecretOutput + ToGetDependabotOrganizationSecretsSecretOutputWithContext(context.Context) GetDependabotOrganizationSecretsSecretOutput +} + +type GetDependabotOrganizationSecretsSecretArgs struct { + // Timestamp of the secret creation + CreatedAt pulumi.StringInput `pulumi:"createdAt"` + // Secret name + Name pulumi.StringInput `pulumi:"name"` + // Timestamp of the secret last update + UpdatedAt pulumi.StringInput `pulumi:"updatedAt"` + // Secret visibility + Visibility pulumi.StringInput `pulumi:"visibility"` +} + +func (GetDependabotOrganizationSecretsSecretArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetDependabotOrganizationSecretsSecret)(nil)).Elem() +} + +func (i GetDependabotOrganizationSecretsSecretArgs) ToGetDependabotOrganizationSecretsSecretOutput() GetDependabotOrganizationSecretsSecretOutput { + return i.ToGetDependabotOrganizationSecretsSecretOutputWithContext(context.Background()) +} + +func (i GetDependabotOrganizationSecretsSecretArgs) ToGetDependabotOrganizationSecretsSecretOutputWithContext(ctx context.Context) GetDependabotOrganizationSecretsSecretOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetDependabotOrganizationSecretsSecretOutput) +} + +// GetDependabotOrganizationSecretsSecretArrayInput is an input type that accepts GetDependabotOrganizationSecretsSecretArray and GetDependabotOrganizationSecretsSecretArrayOutput values. +// You can construct a concrete instance of `GetDependabotOrganizationSecretsSecretArrayInput` via: +// +// GetDependabotOrganizationSecretsSecretArray{ GetDependabotOrganizationSecretsSecretArgs{...} } +type GetDependabotOrganizationSecretsSecretArrayInput interface { + pulumi.Input + + ToGetDependabotOrganizationSecretsSecretArrayOutput() GetDependabotOrganizationSecretsSecretArrayOutput + ToGetDependabotOrganizationSecretsSecretArrayOutputWithContext(context.Context) GetDependabotOrganizationSecretsSecretArrayOutput +} + +type GetDependabotOrganizationSecretsSecretArray []GetDependabotOrganizationSecretsSecretInput + +func (GetDependabotOrganizationSecretsSecretArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetDependabotOrganizationSecretsSecret)(nil)).Elem() +} + +func (i GetDependabotOrganizationSecretsSecretArray) ToGetDependabotOrganizationSecretsSecretArrayOutput() GetDependabotOrganizationSecretsSecretArrayOutput { + return i.ToGetDependabotOrganizationSecretsSecretArrayOutputWithContext(context.Background()) +} + +func (i GetDependabotOrganizationSecretsSecretArray) ToGetDependabotOrganizationSecretsSecretArrayOutputWithContext(ctx context.Context) GetDependabotOrganizationSecretsSecretArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetDependabotOrganizationSecretsSecretArrayOutput) +} + +type GetDependabotOrganizationSecretsSecretOutput struct{ *pulumi.OutputState } + +func (GetDependabotOrganizationSecretsSecretOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetDependabotOrganizationSecretsSecret)(nil)).Elem() +} + +func (o GetDependabotOrganizationSecretsSecretOutput) ToGetDependabotOrganizationSecretsSecretOutput() GetDependabotOrganizationSecretsSecretOutput { + return o +} + +func (o GetDependabotOrganizationSecretsSecretOutput) ToGetDependabotOrganizationSecretsSecretOutputWithContext(ctx context.Context) GetDependabotOrganizationSecretsSecretOutput { + return o +} + +// Timestamp of the secret creation +func (o GetDependabotOrganizationSecretsSecretOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotOrganizationSecretsSecret) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// Secret name +func (o GetDependabotOrganizationSecretsSecretOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotOrganizationSecretsSecret) string { return v.Name }).(pulumi.StringOutput) +} + +// Timestamp of the secret last update +func (o GetDependabotOrganizationSecretsSecretOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotOrganizationSecretsSecret) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// Secret visibility +func (o GetDependabotOrganizationSecretsSecretOutput) Visibility() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotOrganizationSecretsSecret) string { return v.Visibility }).(pulumi.StringOutput) +} + +type GetDependabotOrganizationSecretsSecretArrayOutput struct{ *pulumi.OutputState } + +func (GetDependabotOrganizationSecretsSecretArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetDependabotOrganizationSecretsSecret)(nil)).Elem() +} + +func (o GetDependabotOrganizationSecretsSecretArrayOutput) ToGetDependabotOrganizationSecretsSecretArrayOutput() GetDependabotOrganizationSecretsSecretArrayOutput { + return o +} + +func (o GetDependabotOrganizationSecretsSecretArrayOutput) ToGetDependabotOrganizationSecretsSecretArrayOutputWithContext(ctx context.Context) GetDependabotOrganizationSecretsSecretArrayOutput { + return o +} + +func (o GetDependabotOrganizationSecretsSecretArrayOutput) Index(i pulumi.IntInput) GetDependabotOrganizationSecretsSecretOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetDependabotOrganizationSecretsSecret { + return vs[0].([]GetDependabotOrganizationSecretsSecret)[vs[1].(int)] + }).(GetDependabotOrganizationSecretsSecretOutput) +} + +type GetDependabotSecretsSecret struct { + // Timestamp of the secret creation + CreatedAt string `pulumi:"createdAt"` + // The name of the repository. + Name string `pulumi:"name"` + // Timestamp of the secret last update + UpdatedAt string `pulumi:"updatedAt"` +} + +// GetDependabotSecretsSecretInput is an input type that accepts GetDependabotSecretsSecretArgs and GetDependabotSecretsSecretOutput values. +// You can construct a concrete instance of `GetDependabotSecretsSecretInput` via: +// +// GetDependabotSecretsSecretArgs{...} +type GetDependabotSecretsSecretInput interface { + pulumi.Input + + ToGetDependabotSecretsSecretOutput() GetDependabotSecretsSecretOutput + ToGetDependabotSecretsSecretOutputWithContext(context.Context) GetDependabotSecretsSecretOutput +} + +type GetDependabotSecretsSecretArgs struct { + // Timestamp of the secret creation + CreatedAt pulumi.StringInput `pulumi:"createdAt"` + // The name of the repository. + Name pulumi.StringInput `pulumi:"name"` + // Timestamp of the secret last update + UpdatedAt pulumi.StringInput `pulumi:"updatedAt"` +} + +func (GetDependabotSecretsSecretArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetDependabotSecretsSecret)(nil)).Elem() +} + +func (i GetDependabotSecretsSecretArgs) ToGetDependabotSecretsSecretOutput() GetDependabotSecretsSecretOutput { + return i.ToGetDependabotSecretsSecretOutputWithContext(context.Background()) +} + +func (i GetDependabotSecretsSecretArgs) ToGetDependabotSecretsSecretOutputWithContext(ctx context.Context) GetDependabotSecretsSecretOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetDependabotSecretsSecretOutput) +} + +// GetDependabotSecretsSecretArrayInput is an input type that accepts GetDependabotSecretsSecretArray and GetDependabotSecretsSecretArrayOutput values. +// You can construct a concrete instance of `GetDependabotSecretsSecretArrayInput` via: +// +// GetDependabotSecretsSecretArray{ GetDependabotSecretsSecretArgs{...} } +type GetDependabotSecretsSecretArrayInput interface { + pulumi.Input + + ToGetDependabotSecretsSecretArrayOutput() GetDependabotSecretsSecretArrayOutput + ToGetDependabotSecretsSecretArrayOutputWithContext(context.Context) GetDependabotSecretsSecretArrayOutput +} + +type GetDependabotSecretsSecretArray []GetDependabotSecretsSecretInput + +func (GetDependabotSecretsSecretArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetDependabotSecretsSecret)(nil)).Elem() +} + +func (i GetDependabotSecretsSecretArray) ToGetDependabotSecretsSecretArrayOutput() GetDependabotSecretsSecretArrayOutput { + return i.ToGetDependabotSecretsSecretArrayOutputWithContext(context.Background()) +} + +func (i GetDependabotSecretsSecretArray) ToGetDependabotSecretsSecretArrayOutputWithContext(ctx context.Context) GetDependabotSecretsSecretArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetDependabotSecretsSecretArrayOutput) +} + +type GetDependabotSecretsSecretOutput struct{ *pulumi.OutputState } + +func (GetDependabotSecretsSecretOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetDependabotSecretsSecret)(nil)).Elem() +} + +func (o GetDependabotSecretsSecretOutput) ToGetDependabotSecretsSecretOutput() GetDependabotSecretsSecretOutput { + return o +} + +func (o GetDependabotSecretsSecretOutput) ToGetDependabotSecretsSecretOutputWithContext(ctx context.Context) GetDependabotSecretsSecretOutput { + return o +} + +// Timestamp of the secret creation +func (o GetDependabotSecretsSecretOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotSecretsSecret) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// The name of the repository. +func (o GetDependabotSecretsSecretOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotSecretsSecret) string { return v.Name }).(pulumi.StringOutput) +} + +// Timestamp of the secret last update +func (o GetDependabotSecretsSecretOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetDependabotSecretsSecret) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +type GetDependabotSecretsSecretArrayOutput struct{ *pulumi.OutputState } + +func (GetDependabotSecretsSecretArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetDependabotSecretsSecret)(nil)).Elem() +} + +func (o GetDependabotSecretsSecretArrayOutput) ToGetDependabotSecretsSecretArrayOutput() GetDependabotSecretsSecretArrayOutput { + return o +} + +func (o GetDependabotSecretsSecretArrayOutput) ToGetDependabotSecretsSecretArrayOutputWithContext(ctx context.Context) GetDependabotSecretsSecretArrayOutput { + return o +} + +func (o GetDependabotSecretsSecretArrayOutput) Index(i pulumi.IntInput) GetDependabotSecretsSecretOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetDependabotSecretsSecret { + return vs[0].([]GetDependabotSecretsSecret)[vs[1].(int)] + }).(GetDependabotSecretsSecretOutput) +} + +type GetExternalGroupsExternalGroup struct { + // the ID of the group. + GroupId int `pulumi:"groupId"` + // the name of the group. + GroupName string `pulumi:"groupName"` + // the date the group was last updated. + UpdatedAt string `pulumi:"updatedAt"` +} + +// GetExternalGroupsExternalGroupInput is an input type that accepts GetExternalGroupsExternalGroupArgs and GetExternalGroupsExternalGroupOutput values. +// You can construct a concrete instance of `GetExternalGroupsExternalGroupInput` via: +// +// GetExternalGroupsExternalGroupArgs{...} +type GetExternalGroupsExternalGroupInput interface { + pulumi.Input + + ToGetExternalGroupsExternalGroupOutput() GetExternalGroupsExternalGroupOutput + ToGetExternalGroupsExternalGroupOutputWithContext(context.Context) GetExternalGroupsExternalGroupOutput +} + +type GetExternalGroupsExternalGroupArgs struct { + // the ID of the group. + GroupId pulumi.IntInput `pulumi:"groupId"` + // the name of the group. + GroupName pulumi.StringInput `pulumi:"groupName"` + // the date the group was last updated. + UpdatedAt pulumi.StringInput `pulumi:"updatedAt"` +} + +func (GetExternalGroupsExternalGroupArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetExternalGroupsExternalGroup)(nil)).Elem() +} + +func (i GetExternalGroupsExternalGroupArgs) ToGetExternalGroupsExternalGroupOutput() GetExternalGroupsExternalGroupOutput { + return i.ToGetExternalGroupsExternalGroupOutputWithContext(context.Background()) +} + +func (i GetExternalGroupsExternalGroupArgs) ToGetExternalGroupsExternalGroupOutputWithContext(ctx context.Context) GetExternalGroupsExternalGroupOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetExternalGroupsExternalGroupOutput) +} + +// GetExternalGroupsExternalGroupArrayInput is an input type that accepts GetExternalGroupsExternalGroupArray and GetExternalGroupsExternalGroupArrayOutput values. +// You can construct a concrete instance of `GetExternalGroupsExternalGroupArrayInput` via: +// +// GetExternalGroupsExternalGroupArray{ GetExternalGroupsExternalGroupArgs{...} } +type GetExternalGroupsExternalGroupArrayInput interface { + pulumi.Input + + ToGetExternalGroupsExternalGroupArrayOutput() GetExternalGroupsExternalGroupArrayOutput + ToGetExternalGroupsExternalGroupArrayOutputWithContext(context.Context) GetExternalGroupsExternalGroupArrayOutput +} + +type GetExternalGroupsExternalGroupArray []GetExternalGroupsExternalGroupInput + +func (GetExternalGroupsExternalGroupArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetExternalGroupsExternalGroup)(nil)).Elem() +} + +func (i GetExternalGroupsExternalGroupArray) ToGetExternalGroupsExternalGroupArrayOutput() GetExternalGroupsExternalGroupArrayOutput { + return i.ToGetExternalGroupsExternalGroupArrayOutputWithContext(context.Background()) +} + +func (i GetExternalGroupsExternalGroupArray) ToGetExternalGroupsExternalGroupArrayOutputWithContext(ctx context.Context) GetExternalGroupsExternalGroupArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetExternalGroupsExternalGroupArrayOutput) +} + +type GetExternalGroupsExternalGroupOutput struct{ *pulumi.OutputState } + +func (GetExternalGroupsExternalGroupOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetExternalGroupsExternalGroup)(nil)).Elem() +} + +func (o GetExternalGroupsExternalGroupOutput) ToGetExternalGroupsExternalGroupOutput() GetExternalGroupsExternalGroupOutput { + return o +} + +func (o GetExternalGroupsExternalGroupOutput) ToGetExternalGroupsExternalGroupOutputWithContext(ctx context.Context) GetExternalGroupsExternalGroupOutput { + return o +} + +// the ID of the group. +func (o GetExternalGroupsExternalGroupOutput) GroupId() pulumi.IntOutput { + return o.ApplyT(func(v GetExternalGroupsExternalGroup) int { return v.GroupId }).(pulumi.IntOutput) +} + +// the name of the group. +func (o GetExternalGroupsExternalGroupOutput) GroupName() pulumi.StringOutput { + return o.ApplyT(func(v GetExternalGroupsExternalGroup) string { return v.GroupName }).(pulumi.StringOutput) +} + +// the date the group was last updated. +func (o GetExternalGroupsExternalGroupOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetExternalGroupsExternalGroup) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +type GetExternalGroupsExternalGroupArrayOutput struct{ *pulumi.OutputState } + +func (GetExternalGroupsExternalGroupArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetExternalGroupsExternalGroup)(nil)).Elem() +} + +func (o GetExternalGroupsExternalGroupArrayOutput) ToGetExternalGroupsExternalGroupArrayOutput() GetExternalGroupsExternalGroupArrayOutput { + return o +} + +func (o GetExternalGroupsExternalGroupArrayOutput) ToGetExternalGroupsExternalGroupArrayOutputWithContext(ctx context.Context) GetExternalGroupsExternalGroupArrayOutput { + return o +} + +func (o GetExternalGroupsExternalGroupArrayOutput) Index(i pulumi.IntInput) GetExternalGroupsExternalGroupOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetExternalGroupsExternalGroup { + return vs[0].([]GetExternalGroupsExternalGroup)[vs[1].(int)] + }).(GetExternalGroupsExternalGroupOutput) +} + +type GetIssueLabelsLabel struct { + // The hexadecimal color code for the label, without the leading #. + Color string `pulumi:"color"` + // A short description of the label. + Description string `pulumi:"description"` + // The name of the label. + Name string `pulumi:"name"` + // The URL of the label. + Url string `pulumi:"url"` +} + +// GetIssueLabelsLabelInput is an input type that accepts GetIssueLabelsLabelArgs and GetIssueLabelsLabelOutput values. +// You can construct a concrete instance of `GetIssueLabelsLabelInput` via: +// +// GetIssueLabelsLabelArgs{...} +type GetIssueLabelsLabelInput interface { + pulumi.Input + + ToGetIssueLabelsLabelOutput() GetIssueLabelsLabelOutput + ToGetIssueLabelsLabelOutputWithContext(context.Context) GetIssueLabelsLabelOutput +} + +type GetIssueLabelsLabelArgs struct { + // The hexadecimal color code for the label, without the leading #. + Color pulumi.StringInput `pulumi:"color"` + // A short description of the label. + Description pulumi.StringInput `pulumi:"description"` + // The name of the label. + Name pulumi.StringInput `pulumi:"name"` + // The URL of the label. + Url pulumi.StringInput `pulumi:"url"` +} + +func (GetIssueLabelsLabelArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetIssueLabelsLabel)(nil)).Elem() +} + +func (i GetIssueLabelsLabelArgs) ToGetIssueLabelsLabelOutput() GetIssueLabelsLabelOutput { + return i.ToGetIssueLabelsLabelOutputWithContext(context.Background()) +} + +func (i GetIssueLabelsLabelArgs) ToGetIssueLabelsLabelOutputWithContext(ctx context.Context) GetIssueLabelsLabelOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetIssueLabelsLabelOutput) +} + +// GetIssueLabelsLabelArrayInput is an input type that accepts GetIssueLabelsLabelArray and GetIssueLabelsLabelArrayOutput values. +// You can construct a concrete instance of `GetIssueLabelsLabelArrayInput` via: +// +// GetIssueLabelsLabelArray{ GetIssueLabelsLabelArgs{...} } +type GetIssueLabelsLabelArrayInput interface { + pulumi.Input + + ToGetIssueLabelsLabelArrayOutput() GetIssueLabelsLabelArrayOutput + ToGetIssueLabelsLabelArrayOutputWithContext(context.Context) GetIssueLabelsLabelArrayOutput +} + +type GetIssueLabelsLabelArray []GetIssueLabelsLabelInput + +func (GetIssueLabelsLabelArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetIssueLabelsLabel)(nil)).Elem() +} + +func (i GetIssueLabelsLabelArray) ToGetIssueLabelsLabelArrayOutput() GetIssueLabelsLabelArrayOutput { + return i.ToGetIssueLabelsLabelArrayOutputWithContext(context.Background()) +} + +func (i GetIssueLabelsLabelArray) ToGetIssueLabelsLabelArrayOutputWithContext(ctx context.Context) GetIssueLabelsLabelArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetIssueLabelsLabelArrayOutput) +} + +type GetIssueLabelsLabelOutput struct{ *pulumi.OutputState } + +func (GetIssueLabelsLabelOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetIssueLabelsLabel)(nil)).Elem() +} + +func (o GetIssueLabelsLabelOutput) ToGetIssueLabelsLabelOutput() GetIssueLabelsLabelOutput { + return o +} + +func (o GetIssueLabelsLabelOutput) ToGetIssueLabelsLabelOutputWithContext(ctx context.Context) GetIssueLabelsLabelOutput { + return o +} + +// The hexadecimal color code for the label, without the leading #. +func (o GetIssueLabelsLabelOutput) Color() pulumi.StringOutput { + return o.ApplyT(func(v GetIssueLabelsLabel) string { return v.Color }).(pulumi.StringOutput) +} + +// A short description of the label. +func (o GetIssueLabelsLabelOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v GetIssueLabelsLabel) string { return v.Description }).(pulumi.StringOutput) +} + +// The name of the label. +func (o GetIssueLabelsLabelOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetIssueLabelsLabel) string { return v.Name }).(pulumi.StringOutput) +} + +// The URL of the label. +func (o GetIssueLabelsLabelOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v GetIssueLabelsLabel) string { return v.Url }).(pulumi.StringOutput) +} + +type GetIssueLabelsLabelArrayOutput struct{ *pulumi.OutputState } + +func (GetIssueLabelsLabelArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetIssueLabelsLabel)(nil)).Elem() +} + +func (o GetIssueLabelsLabelArrayOutput) ToGetIssueLabelsLabelArrayOutput() GetIssueLabelsLabelArrayOutput { + return o +} + +func (o GetIssueLabelsLabelArrayOutput) ToGetIssueLabelsLabelArrayOutputWithContext(ctx context.Context) GetIssueLabelsLabelArrayOutput { + return o +} + +func (o GetIssueLabelsLabelArrayOutput) Index(i pulumi.IntInput) GetIssueLabelsLabelOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetIssueLabelsLabel { + return vs[0].([]GetIssueLabelsLabel)[vs[1].(int)] + }).(GetIssueLabelsLabelOutput) +} + +type GetOrganizationAppInstallationsInstallation struct { + // The ID of the GitHub App. + AppId int `pulumi:"appId"` + // The URL-friendly name of the GitHub App. + AppSlug string `pulumi:"appSlug"` + // The OAuth client ID of the GitHub App. + ClientId string `pulumi:"clientId"` + // The date the GitHub App installation was created. + CreatedAt string `pulumi:"createdAt"` + // The list of events the GitHub App installation subscribes to. + Events []string `pulumi:"events"` + // The ID of the GitHub App installation. + Id int `pulumi:"id"` + // A map of the permissions granted to the GitHub App installation. + Permissions map[string]string `pulumi:"permissions"` + // Whether the installation has access to all repositories or only selected ones. Possible values are `all` or `selected`. + RepositorySelection string `pulumi:"repositorySelection"` + // The list of single file paths the GitHub App installation has access to. + SingleFilePaths []string `pulumi:"singleFilePaths"` + // Whether the GitHub App installation is currently suspended. + Suspended bool `pulumi:"suspended"` + // The ID of the account the GitHub App is installed on. + TargetId int `pulumi:"targetId"` + // The type of account the GitHub App is installed on. Possible values are `Organization` or `User`. + TargetType string `pulumi:"targetType"` + // The date the GitHub App installation was last updated. + UpdatedAt string `pulumi:"updatedAt"` +} + +// GetOrganizationAppInstallationsInstallationInput is an input type that accepts GetOrganizationAppInstallationsInstallationArgs and GetOrganizationAppInstallationsInstallationOutput values. +// You can construct a concrete instance of `GetOrganizationAppInstallationsInstallationInput` via: +// +// GetOrganizationAppInstallationsInstallationArgs{...} +type GetOrganizationAppInstallationsInstallationInput interface { + pulumi.Input + + ToGetOrganizationAppInstallationsInstallationOutput() GetOrganizationAppInstallationsInstallationOutput + ToGetOrganizationAppInstallationsInstallationOutputWithContext(context.Context) GetOrganizationAppInstallationsInstallationOutput +} + +type GetOrganizationAppInstallationsInstallationArgs struct { + // The ID of the GitHub App. + AppId pulumi.IntInput `pulumi:"appId"` + // The URL-friendly name of the GitHub App. + AppSlug pulumi.StringInput `pulumi:"appSlug"` + // The OAuth client ID of the GitHub App. + ClientId pulumi.StringInput `pulumi:"clientId"` + // The date the GitHub App installation was created. + CreatedAt pulumi.StringInput `pulumi:"createdAt"` + // The list of events the GitHub App installation subscribes to. + Events pulumi.StringArrayInput `pulumi:"events"` + // The ID of the GitHub App installation. + Id pulumi.IntInput `pulumi:"id"` + // A map of the permissions granted to the GitHub App installation. + Permissions pulumi.StringMapInput `pulumi:"permissions"` + // Whether the installation has access to all repositories or only selected ones. Possible values are `all` or `selected`. + RepositorySelection pulumi.StringInput `pulumi:"repositorySelection"` + // The list of single file paths the GitHub App installation has access to. + SingleFilePaths pulumi.StringArrayInput `pulumi:"singleFilePaths"` + // Whether the GitHub App installation is currently suspended. + Suspended pulumi.BoolInput `pulumi:"suspended"` + // The ID of the account the GitHub App is installed on. + TargetId pulumi.IntInput `pulumi:"targetId"` + // The type of account the GitHub App is installed on. Possible values are `Organization` or `User`. + TargetType pulumi.StringInput `pulumi:"targetType"` + // The date the GitHub App installation was last updated. + UpdatedAt pulumi.StringInput `pulumi:"updatedAt"` +} + +func (GetOrganizationAppInstallationsInstallationArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationAppInstallationsInstallation)(nil)).Elem() +} + +func (i GetOrganizationAppInstallationsInstallationArgs) ToGetOrganizationAppInstallationsInstallationOutput() GetOrganizationAppInstallationsInstallationOutput { + return i.ToGetOrganizationAppInstallationsInstallationOutputWithContext(context.Background()) +} + +func (i GetOrganizationAppInstallationsInstallationArgs) ToGetOrganizationAppInstallationsInstallationOutputWithContext(ctx context.Context) GetOrganizationAppInstallationsInstallationOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationAppInstallationsInstallationOutput) +} + +// GetOrganizationAppInstallationsInstallationArrayInput is an input type that accepts GetOrganizationAppInstallationsInstallationArray and GetOrganizationAppInstallationsInstallationArrayOutput values. +// You can construct a concrete instance of `GetOrganizationAppInstallationsInstallationArrayInput` via: +// +// GetOrganizationAppInstallationsInstallationArray{ GetOrganizationAppInstallationsInstallationArgs{...} } +type GetOrganizationAppInstallationsInstallationArrayInput interface { + pulumi.Input + + ToGetOrganizationAppInstallationsInstallationArrayOutput() GetOrganizationAppInstallationsInstallationArrayOutput + ToGetOrganizationAppInstallationsInstallationArrayOutputWithContext(context.Context) GetOrganizationAppInstallationsInstallationArrayOutput +} + +type GetOrganizationAppInstallationsInstallationArray []GetOrganizationAppInstallationsInstallationInput + +func (GetOrganizationAppInstallationsInstallationArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationAppInstallationsInstallation)(nil)).Elem() +} + +func (i GetOrganizationAppInstallationsInstallationArray) ToGetOrganizationAppInstallationsInstallationArrayOutput() GetOrganizationAppInstallationsInstallationArrayOutput { + return i.ToGetOrganizationAppInstallationsInstallationArrayOutputWithContext(context.Background()) +} + +func (i GetOrganizationAppInstallationsInstallationArray) ToGetOrganizationAppInstallationsInstallationArrayOutputWithContext(ctx context.Context) GetOrganizationAppInstallationsInstallationArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationAppInstallationsInstallationArrayOutput) +} + +type GetOrganizationAppInstallationsInstallationOutput struct{ *pulumi.OutputState } + +func (GetOrganizationAppInstallationsInstallationOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationAppInstallationsInstallation)(nil)).Elem() +} + +func (o GetOrganizationAppInstallationsInstallationOutput) ToGetOrganizationAppInstallationsInstallationOutput() GetOrganizationAppInstallationsInstallationOutput { + return o +} + +func (o GetOrganizationAppInstallationsInstallationOutput) ToGetOrganizationAppInstallationsInstallationOutputWithContext(ctx context.Context) GetOrganizationAppInstallationsInstallationOutput { + return o +} + +// The ID of the GitHub App. +func (o GetOrganizationAppInstallationsInstallationOutput) AppId() pulumi.IntOutput { + return o.ApplyT(func(v GetOrganizationAppInstallationsInstallation) int { return v.AppId }).(pulumi.IntOutput) +} + +// The URL-friendly name of the GitHub App. +func (o GetOrganizationAppInstallationsInstallationOutput) AppSlug() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationAppInstallationsInstallation) string { return v.AppSlug }).(pulumi.StringOutput) +} + +// The OAuth client ID of the GitHub App. +func (o GetOrganizationAppInstallationsInstallationOutput) ClientId() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationAppInstallationsInstallation) string { return v.ClientId }).(pulumi.StringOutput) +} + +// The date the GitHub App installation was created. +func (o GetOrganizationAppInstallationsInstallationOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationAppInstallationsInstallation) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// The list of events the GitHub App installation subscribes to. +func (o GetOrganizationAppInstallationsInstallationOutput) Events() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetOrganizationAppInstallationsInstallation) []string { return v.Events }).(pulumi.StringArrayOutput) +} + +// The ID of the GitHub App installation. +func (o GetOrganizationAppInstallationsInstallationOutput) Id() pulumi.IntOutput { + return o.ApplyT(func(v GetOrganizationAppInstallationsInstallation) int { return v.Id }).(pulumi.IntOutput) +} + +// A map of the permissions granted to the GitHub App installation. +func (o GetOrganizationAppInstallationsInstallationOutput) Permissions() pulumi.StringMapOutput { + return o.ApplyT(func(v GetOrganizationAppInstallationsInstallation) map[string]string { return v.Permissions }).(pulumi.StringMapOutput) +} + +// Whether the installation has access to all repositories or only selected ones. Possible values are `all` or `selected`. +func (o GetOrganizationAppInstallationsInstallationOutput) RepositorySelection() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationAppInstallationsInstallation) string { return v.RepositorySelection }).(pulumi.StringOutput) +} + +// The list of single file paths the GitHub App installation has access to. +func (o GetOrganizationAppInstallationsInstallationOutput) SingleFilePaths() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetOrganizationAppInstallationsInstallation) []string { return v.SingleFilePaths }).(pulumi.StringArrayOutput) +} + +// Whether the GitHub App installation is currently suspended. +func (o GetOrganizationAppInstallationsInstallationOutput) Suspended() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationAppInstallationsInstallation) bool { return v.Suspended }).(pulumi.BoolOutput) +} + +// The ID of the account the GitHub App is installed on. +func (o GetOrganizationAppInstallationsInstallationOutput) TargetId() pulumi.IntOutput { + return o.ApplyT(func(v GetOrganizationAppInstallationsInstallation) int { return v.TargetId }).(pulumi.IntOutput) +} + +// The type of account the GitHub App is installed on. Possible values are `Organization` or `User`. +func (o GetOrganizationAppInstallationsInstallationOutput) TargetType() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationAppInstallationsInstallation) string { return v.TargetType }).(pulumi.StringOutput) +} + +// The date the GitHub App installation was last updated. +func (o GetOrganizationAppInstallationsInstallationOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationAppInstallationsInstallation) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +type GetOrganizationAppInstallationsInstallationArrayOutput struct{ *pulumi.OutputState } + +func (GetOrganizationAppInstallationsInstallationArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationAppInstallationsInstallation)(nil)).Elem() +} + +func (o GetOrganizationAppInstallationsInstallationArrayOutput) ToGetOrganizationAppInstallationsInstallationArrayOutput() GetOrganizationAppInstallationsInstallationArrayOutput { + return o +} + +func (o GetOrganizationAppInstallationsInstallationArrayOutput) ToGetOrganizationAppInstallationsInstallationArrayOutputWithContext(ctx context.Context) GetOrganizationAppInstallationsInstallationArrayOutput { + return o +} + +func (o GetOrganizationAppInstallationsInstallationArrayOutput) Index(i pulumi.IntInput) GetOrganizationAppInstallationsInstallationOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetOrganizationAppInstallationsInstallation { + return vs[0].([]GetOrganizationAppInstallationsInstallation)[vs[1].(int)] + }).(GetOrganizationAppInstallationsInstallationOutput) +} + +type GetOrganizationExternalIdentitiesIdentity struct { + // The username of the GitHub user + Login string `pulumi:"login"` + // An Object containing the user's SAML data. This object will + // be empty if the user is not managed by SAML. + SamlIdentity map[string]string `pulumi:"samlIdentity"` + // An Object contining the user's SCIM data. This object will + // be empty if the user is not managed by SCIM. + ScimIdentity map[string]string `pulumi:"scimIdentity"` +} + +// GetOrganizationExternalIdentitiesIdentityInput is an input type that accepts GetOrganizationExternalIdentitiesIdentityArgs and GetOrganizationExternalIdentitiesIdentityOutput values. +// You can construct a concrete instance of `GetOrganizationExternalIdentitiesIdentityInput` via: +// +// GetOrganizationExternalIdentitiesIdentityArgs{...} +type GetOrganizationExternalIdentitiesIdentityInput interface { + pulumi.Input + + ToGetOrganizationExternalIdentitiesIdentityOutput() GetOrganizationExternalIdentitiesIdentityOutput + ToGetOrganizationExternalIdentitiesIdentityOutputWithContext(context.Context) GetOrganizationExternalIdentitiesIdentityOutput +} + +type GetOrganizationExternalIdentitiesIdentityArgs struct { + // The username of the GitHub user + Login pulumi.StringInput `pulumi:"login"` + // An Object containing the user's SAML data. This object will + // be empty if the user is not managed by SAML. + SamlIdentity pulumi.StringMapInput `pulumi:"samlIdentity"` + // An Object contining the user's SCIM data. This object will + // be empty if the user is not managed by SCIM. + ScimIdentity pulumi.StringMapInput `pulumi:"scimIdentity"` +} + +func (GetOrganizationExternalIdentitiesIdentityArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationExternalIdentitiesIdentity)(nil)).Elem() +} + +func (i GetOrganizationExternalIdentitiesIdentityArgs) ToGetOrganizationExternalIdentitiesIdentityOutput() GetOrganizationExternalIdentitiesIdentityOutput { + return i.ToGetOrganizationExternalIdentitiesIdentityOutputWithContext(context.Background()) +} + +func (i GetOrganizationExternalIdentitiesIdentityArgs) ToGetOrganizationExternalIdentitiesIdentityOutputWithContext(ctx context.Context) GetOrganizationExternalIdentitiesIdentityOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationExternalIdentitiesIdentityOutput) +} + +// GetOrganizationExternalIdentitiesIdentityArrayInput is an input type that accepts GetOrganizationExternalIdentitiesIdentityArray and GetOrganizationExternalIdentitiesIdentityArrayOutput values. +// You can construct a concrete instance of `GetOrganizationExternalIdentitiesIdentityArrayInput` via: +// +// GetOrganizationExternalIdentitiesIdentityArray{ GetOrganizationExternalIdentitiesIdentityArgs{...} } +type GetOrganizationExternalIdentitiesIdentityArrayInput interface { + pulumi.Input + + ToGetOrganizationExternalIdentitiesIdentityArrayOutput() GetOrganizationExternalIdentitiesIdentityArrayOutput + ToGetOrganizationExternalIdentitiesIdentityArrayOutputWithContext(context.Context) GetOrganizationExternalIdentitiesIdentityArrayOutput +} + +type GetOrganizationExternalIdentitiesIdentityArray []GetOrganizationExternalIdentitiesIdentityInput + +func (GetOrganizationExternalIdentitiesIdentityArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationExternalIdentitiesIdentity)(nil)).Elem() +} + +func (i GetOrganizationExternalIdentitiesIdentityArray) ToGetOrganizationExternalIdentitiesIdentityArrayOutput() GetOrganizationExternalIdentitiesIdentityArrayOutput { + return i.ToGetOrganizationExternalIdentitiesIdentityArrayOutputWithContext(context.Background()) +} + +func (i GetOrganizationExternalIdentitiesIdentityArray) ToGetOrganizationExternalIdentitiesIdentityArrayOutputWithContext(ctx context.Context) GetOrganizationExternalIdentitiesIdentityArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationExternalIdentitiesIdentityArrayOutput) +} + +type GetOrganizationExternalIdentitiesIdentityOutput struct{ *pulumi.OutputState } + +func (GetOrganizationExternalIdentitiesIdentityOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationExternalIdentitiesIdentity)(nil)).Elem() +} + +func (o GetOrganizationExternalIdentitiesIdentityOutput) ToGetOrganizationExternalIdentitiesIdentityOutput() GetOrganizationExternalIdentitiesIdentityOutput { + return o +} + +func (o GetOrganizationExternalIdentitiesIdentityOutput) ToGetOrganizationExternalIdentitiesIdentityOutputWithContext(ctx context.Context) GetOrganizationExternalIdentitiesIdentityOutput { + return o +} + +// The username of the GitHub user +func (o GetOrganizationExternalIdentitiesIdentityOutput) Login() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationExternalIdentitiesIdentity) string { return v.Login }).(pulumi.StringOutput) +} + +// An Object containing the user's SAML data. This object will +// be empty if the user is not managed by SAML. +func (o GetOrganizationExternalIdentitiesIdentityOutput) SamlIdentity() pulumi.StringMapOutput { + return o.ApplyT(func(v GetOrganizationExternalIdentitiesIdentity) map[string]string { return v.SamlIdentity }).(pulumi.StringMapOutput) +} + +// An Object contining the user's SCIM data. This object will +// be empty if the user is not managed by SCIM. +func (o GetOrganizationExternalIdentitiesIdentityOutput) ScimIdentity() pulumi.StringMapOutput { + return o.ApplyT(func(v GetOrganizationExternalIdentitiesIdentity) map[string]string { return v.ScimIdentity }).(pulumi.StringMapOutput) +} + +type GetOrganizationExternalIdentitiesIdentityArrayOutput struct{ *pulumi.OutputState } + +func (GetOrganizationExternalIdentitiesIdentityArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationExternalIdentitiesIdentity)(nil)).Elem() +} + +func (o GetOrganizationExternalIdentitiesIdentityArrayOutput) ToGetOrganizationExternalIdentitiesIdentityArrayOutput() GetOrganizationExternalIdentitiesIdentityArrayOutput { + return o +} + +func (o GetOrganizationExternalIdentitiesIdentityArrayOutput) ToGetOrganizationExternalIdentitiesIdentityArrayOutputWithContext(ctx context.Context) GetOrganizationExternalIdentitiesIdentityArrayOutput { + return o +} + +func (o GetOrganizationExternalIdentitiesIdentityArrayOutput) Index(i pulumi.IntInput) GetOrganizationExternalIdentitiesIdentityOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetOrganizationExternalIdentitiesIdentity { + return vs[0].([]GetOrganizationExternalIdentitiesIdentity)[vs[1].(int)] + }).(GetOrganizationExternalIdentitiesIdentityOutput) +} + +type GetOrganizationIpAllowListIpAllowList struct { + // A single IP address or range of IP addresses in CIDR notation. + AllowListValue string `pulumi:"allowListValue"` + // Identifies the date and time when the object was created. + CreatedAt string `pulumi:"createdAt"` + // The ID of the IP allow list entry. + Id string `pulumi:"id"` + // Whether the entry is currently active. + IsActive bool `pulumi:"isActive"` + // The name of the IP allow list entry. + Name string `pulumi:"name"` + // Identifies the date and time when the object was last updated. + UpdatedAt string `pulumi:"updatedAt"` +} + +// GetOrganizationIpAllowListIpAllowListInput is an input type that accepts GetOrganizationIpAllowListIpAllowListArgs and GetOrganizationIpAllowListIpAllowListOutput values. +// You can construct a concrete instance of `GetOrganizationIpAllowListIpAllowListInput` via: +// +// GetOrganizationIpAllowListIpAllowListArgs{...} +type GetOrganizationIpAllowListIpAllowListInput interface { + pulumi.Input + + ToGetOrganizationIpAllowListIpAllowListOutput() GetOrganizationIpAllowListIpAllowListOutput + ToGetOrganizationIpAllowListIpAllowListOutputWithContext(context.Context) GetOrganizationIpAllowListIpAllowListOutput +} + +type GetOrganizationIpAllowListIpAllowListArgs struct { + // A single IP address or range of IP addresses in CIDR notation. + AllowListValue pulumi.StringInput `pulumi:"allowListValue"` + // Identifies the date and time when the object was created. + CreatedAt pulumi.StringInput `pulumi:"createdAt"` + // The ID of the IP allow list entry. + Id pulumi.StringInput `pulumi:"id"` + // Whether the entry is currently active. + IsActive pulumi.BoolInput `pulumi:"isActive"` + // The name of the IP allow list entry. + Name pulumi.StringInput `pulumi:"name"` + // Identifies the date and time when the object was last updated. + UpdatedAt pulumi.StringInput `pulumi:"updatedAt"` +} + +func (GetOrganizationIpAllowListIpAllowListArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationIpAllowListIpAllowList)(nil)).Elem() +} + +func (i GetOrganizationIpAllowListIpAllowListArgs) ToGetOrganizationIpAllowListIpAllowListOutput() GetOrganizationIpAllowListIpAllowListOutput { + return i.ToGetOrganizationIpAllowListIpAllowListOutputWithContext(context.Background()) +} + +func (i GetOrganizationIpAllowListIpAllowListArgs) ToGetOrganizationIpAllowListIpAllowListOutputWithContext(ctx context.Context) GetOrganizationIpAllowListIpAllowListOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationIpAllowListIpAllowListOutput) +} + +// GetOrganizationIpAllowListIpAllowListArrayInput is an input type that accepts GetOrganizationIpAllowListIpAllowListArray and GetOrganizationIpAllowListIpAllowListArrayOutput values. +// You can construct a concrete instance of `GetOrganizationIpAllowListIpAllowListArrayInput` via: +// +// GetOrganizationIpAllowListIpAllowListArray{ GetOrganizationIpAllowListIpAllowListArgs{...} } +type GetOrganizationIpAllowListIpAllowListArrayInput interface { + pulumi.Input + + ToGetOrganizationIpAllowListIpAllowListArrayOutput() GetOrganizationIpAllowListIpAllowListArrayOutput + ToGetOrganizationIpAllowListIpAllowListArrayOutputWithContext(context.Context) GetOrganizationIpAllowListIpAllowListArrayOutput +} + +type GetOrganizationIpAllowListIpAllowListArray []GetOrganizationIpAllowListIpAllowListInput + +func (GetOrganizationIpAllowListIpAllowListArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationIpAllowListIpAllowList)(nil)).Elem() +} + +func (i GetOrganizationIpAllowListIpAllowListArray) ToGetOrganizationIpAllowListIpAllowListArrayOutput() GetOrganizationIpAllowListIpAllowListArrayOutput { + return i.ToGetOrganizationIpAllowListIpAllowListArrayOutputWithContext(context.Background()) +} + +func (i GetOrganizationIpAllowListIpAllowListArray) ToGetOrganizationIpAllowListIpAllowListArrayOutputWithContext(ctx context.Context) GetOrganizationIpAllowListIpAllowListArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationIpAllowListIpAllowListArrayOutput) +} + +type GetOrganizationIpAllowListIpAllowListOutput struct{ *pulumi.OutputState } + +func (GetOrganizationIpAllowListIpAllowListOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationIpAllowListIpAllowList)(nil)).Elem() +} + +func (o GetOrganizationIpAllowListIpAllowListOutput) ToGetOrganizationIpAllowListIpAllowListOutput() GetOrganizationIpAllowListIpAllowListOutput { + return o +} + +func (o GetOrganizationIpAllowListIpAllowListOutput) ToGetOrganizationIpAllowListIpAllowListOutputWithContext(ctx context.Context) GetOrganizationIpAllowListIpAllowListOutput { + return o +} + +// A single IP address or range of IP addresses in CIDR notation. +func (o GetOrganizationIpAllowListIpAllowListOutput) AllowListValue() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationIpAllowListIpAllowList) string { return v.AllowListValue }).(pulumi.StringOutput) +} + +// Identifies the date and time when the object was created. +func (o GetOrganizationIpAllowListIpAllowListOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationIpAllowListIpAllowList) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// The ID of the IP allow list entry. +func (o GetOrganizationIpAllowListIpAllowListOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationIpAllowListIpAllowList) string { return v.Id }).(pulumi.StringOutput) +} + +// Whether the entry is currently active. +func (o GetOrganizationIpAllowListIpAllowListOutput) IsActive() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationIpAllowListIpAllowList) bool { return v.IsActive }).(pulumi.BoolOutput) +} + +// The name of the IP allow list entry. +func (o GetOrganizationIpAllowListIpAllowListOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationIpAllowListIpAllowList) string { return v.Name }).(pulumi.StringOutput) +} + +// Identifies the date and time when the object was last updated. +func (o GetOrganizationIpAllowListIpAllowListOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationIpAllowListIpAllowList) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +type GetOrganizationIpAllowListIpAllowListArrayOutput struct{ *pulumi.OutputState } + +func (GetOrganizationIpAllowListIpAllowListArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationIpAllowListIpAllowList)(nil)).Elem() +} + +func (o GetOrganizationIpAllowListIpAllowListArrayOutput) ToGetOrganizationIpAllowListIpAllowListArrayOutput() GetOrganizationIpAllowListIpAllowListArrayOutput { + return o +} + +func (o GetOrganizationIpAllowListIpAllowListArrayOutput) ToGetOrganizationIpAllowListIpAllowListArrayOutputWithContext(ctx context.Context) GetOrganizationIpAllowListIpAllowListArrayOutput { + return o +} + +func (o GetOrganizationIpAllowListIpAllowListArrayOutput) Index(i pulumi.IntInput) GetOrganizationIpAllowListIpAllowListOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetOrganizationIpAllowListIpAllowList { + return vs[0].([]GetOrganizationIpAllowListIpAllowList)[vs[1].(int)] + }).(GetOrganizationIpAllowListIpAllowListOutput) +} + +type GetOrganizationRepositoryRolesRole struct { + // The system role from which this role inherits permissions. + BaseRole string `pulumi:"baseRole"` + // The description of the organization repository role. + Description string `pulumi:"description"` + // The name of the organization repository role. + Name string `pulumi:"name"` + // The permissions included in this role. + Permissions []string `pulumi:"permissions"` + // The ID of the organization repository role. + RoleId int `pulumi:"roleId"` +} + +// GetOrganizationRepositoryRolesRoleInput is an input type that accepts GetOrganizationRepositoryRolesRoleArgs and GetOrganizationRepositoryRolesRoleOutput values. +// You can construct a concrete instance of `GetOrganizationRepositoryRolesRoleInput` via: +// +// GetOrganizationRepositoryRolesRoleArgs{...} +type GetOrganizationRepositoryRolesRoleInput interface { + pulumi.Input + + ToGetOrganizationRepositoryRolesRoleOutput() GetOrganizationRepositoryRolesRoleOutput + ToGetOrganizationRepositoryRolesRoleOutputWithContext(context.Context) GetOrganizationRepositoryRolesRoleOutput +} + +type GetOrganizationRepositoryRolesRoleArgs struct { + // The system role from which this role inherits permissions. + BaseRole pulumi.StringInput `pulumi:"baseRole"` + // The description of the organization repository role. + Description pulumi.StringInput `pulumi:"description"` + // The name of the organization repository role. + Name pulumi.StringInput `pulumi:"name"` + // The permissions included in this role. + Permissions pulumi.StringArrayInput `pulumi:"permissions"` + // The ID of the organization repository role. + RoleId pulumi.IntInput `pulumi:"roleId"` +} + +func (GetOrganizationRepositoryRolesRoleArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationRepositoryRolesRole)(nil)).Elem() +} + +func (i GetOrganizationRepositoryRolesRoleArgs) ToGetOrganizationRepositoryRolesRoleOutput() GetOrganizationRepositoryRolesRoleOutput { + return i.ToGetOrganizationRepositoryRolesRoleOutputWithContext(context.Background()) +} + +func (i GetOrganizationRepositoryRolesRoleArgs) ToGetOrganizationRepositoryRolesRoleOutputWithContext(ctx context.Context) GetOrganizationRepositoryRolesRoleOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationRepositoryRolesRoleOutput) +} + +// GetOrganizationRepositoryRolesRoleArrayInput is an input type that accepts GetOrganizationRepositoryRolesRoleArray and GetOrganizationRepositoryRolesRoleArrayOutput values. +// You can construct a concrete instance of `GetOrganizationRepositoryRolesRoleArrayInput` via: +// +// GetOrganizationRepositoryRolesRoleArray{ GetOrganizationRepositoryRolesRoleArgs{...} } +type GetOrganizationRepositoryRolesRoleArrayInput interface { + pulumi.Input + + ToGetOrganizationRepositoryRolesRoleArrayOutput() GetOrganizationRepositoryRolesRoleArrayOutput + ToGetOrganizationRepositoryRolesRoleArrayOutputWithContext(context.Context) GetOrganizationRepositoryRolesRoleArrayOutput +} + +type GetOrganizationRepositoryRolesRoleArray []GetOrganizationRepositoryRolesRoleInput + +func (GetOrganizationRepositoryRolesRoleArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationRepositoryRolesRole)(nil)).Elem() +} + +func (i GetOrganizationRepositoryRolesRoleArray) ToGetOrganizationRepositoryRolesRoleArrayOutput() GetOrganizationRepositoryRolesRoleArrayOutput { + return i.ToGetOrganizationRepositoryRolesRoleArrayOutputWithContext(context.Background()) +} + +func (i GetOrganizationRepositoryRolesRoleArray) ToGetOrganizationRepositoryRolesRoleArrayOutputWithContext(ctx context.Context) GetOrganizationRepositoryRolesRoleArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationRepositoryRolesRoleArrayOutput) +} + +type GetOrganizationRepositoryRolesRoleOutput struct{ *pulumi.OutputState } + +func (GetOrganizationRepositoryRolesRoleOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationRepositoryRolesRole)(nil)).Elem() +} + +func (o GetOrganizationRepositoryRolesRoleOutput) ToGetOrganizationRepositoryRolesRoleOutput() GetOrganizationRepositoryRolesRoleOutput { + return o +} + +func (o GetOrganizationRepositoryRolesRoleOutput) ToGetOrganizationRepositoryRolesRoleOutputWithContext(ctx context.Context) GetOrganizationRepositoryRolesRoleOutput { + return o +} + +// The system role from which this role inherits permissions. +func (o GetOrganizationRepositoryRolesRoleOutput) BaseRole() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationRepositoryRolesRole) string { return v.BaseRole }).(pulumi.StringOutput) +} + +// The description of the organization repository role. +func (o GetOrganizationRepositoryRolesRoleOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationRepositoryRolesRole) string { return v.Description }).(pulumi.StringOutput) +} + +// The name of the organization repository role. +func (o GetOrganizationRepositoryRolesRoleOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationRepositoryRolesRole) string { return v.Name }).(pulumi.StringOutput) +} + +// The permissions included in this role. +func (o GetOrganizationRepositoryRolesRoleOutput) Permissions() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetOrganizationRepositoryRolesRole) []string { return v.Permissions }).(pulumi.StringArrayOutput) +} + +// The ID of the organization repository role. +func (o GetOrganizationRepositoryRolesRoleOutput) RoleId() pulumi.IntOutput { + return o.ApplyT(func(v GetOrganizationRepositoryRolesRole) int { return v.RoleId }).(pulumi.IntOutput) +} + +type GetOrganizationRepositoryRolesRoleArrayOutput struct{ *pulumi.OutputState } + +func (GetOrganizationRepositoryRolesRoleArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationRepositoryRolesRole)(nil)).Elem() +} + +func (o GetOrganizationRepositoryRolesRoleArrayOutput) ToGetOrganizationRepositoryRolesRoleArrayOutput() GetOrganizationRepositoryRolesRoleArrayOutput { + return o +} + +func (o GetOrganizationRepositoryRolesRoleArrayOutput) ToGetOrganizationRepositoryRolesRoleArrayOutputWithContext(ctx context.Context) GetOrganizationRepositoryRolesRoleArrayOutput { + return o +} + +func (o GetOrganizationRepositoryRolesRoleArrayOutput) Index(i pulumi.IntInput) GetOrganizationRepositoryRolesRoleOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetOrganizationRepositoryRolesRole { + return vs[0].([]GetOrganizationRepositoryRolesRole)[vs[1].(int)] + }).(GetOrganizationRepositoryRolesRoleOutput) +} + +type GetOrganizationRoleTeamsTeam struct { + // The name of the team. + Name string `pulumi:"name"` + // The permission that the team will have for its repositories. + Permission string `pulumi:"permission"` + // The Slug of the team name. + Slug string `pulumi:"slug"` + // The ID of the team. + TeamId int `pulumi:"teamId"` +} + +// GetOrganizationRoleTeamsTeamInput is an input type that accepts GetOrganizationRoleTeamsTeamArgs and GetOrganizationRoleTeamsTeamOutput values. +// You can construct a concrete instance of `GetOrganizationRoleTeamsTeamInput` via: +// +// GetOrganizationRoleTeamsTeamArgs{...} +type GetOrganizationRoleTeamsTeamInput interface { + pulumi.Input + + ToGetOrganizationRoleTeamsTeamOutput() GetOrganizationRoleTeamsTeamOutput + ToGetOrganizationRoleTeamsTeamOutputWithContext(context.Context) GetOrganizationRoleTeamsTeamOutput +} + +type GetOrganizationRoleTeamsTeamArgs struct { + // The name of the team. + Name pulumi.StringInput `pulumi:"name"` + // The permission that the team will have for its repositories. + Permission pulumi.StringInput `pulumi:"permission"` + // The Slug of the team name. + Slug pulumi.StringInput `pulumi:"slug"` + // The ID of the team. + TeamId pulumi.IntInput `pulumi:"teamId"` +} + +func (GetOrganizationRoleTeamsTeamArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationRoleTeamsTeam)(nil)).Elem() +} + +func (i GetOrganizationRoleTeamsTeamArgs) ToGetOrganizationRoleTeamsTeamOutput() GetOrganizationRoleTeamsTeamOutput { + return i.ToGetOrganizationRoleTeamsTeamOutputWithContext(context.Background()) +} + +func (i GetOrganizationRoleTeamsTeamArgs) ToGetOrganizationRoleTeamsTeamOutputWithContext(ctx context.Context) GetOrganizationRoleTeamsTeamOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationRoleTeamsTeamOutput) +} + +// GetOrganizationRoleTeamsTeamArrayInput is an input type that accepts GetOrganizationRoleTeamsTeamArray and GetOrganizationRoleTeamsTeamArrayOutput values. +// You can construct a concrete instance of `GetOrganizationRoleTeamsTeamArrayInput` via: +// +// GetOrganizationRoleTeamsTeamArray{ GetOrganizationRoleTeamsTeamArgs{...} } +type GetOrganizationRoleTeamsTeamArrayInput interface { + pulumi.Input + + ToGetOrganizationRoleTeamsTeamArrayOutput() GetOrganizationRoleTeamsTeamArrayOutput + ToGetOrganizationRoleTeamsTeamArrayOutputWithContext(context.Context) GetOrganizationRoleTeamsTeamArrayOutput +} + +type GetOrganizationRoleTeamsTeamArray []GetOrganizationRoleTeamsTeamInput + +func (GetOrganizationRoleTeamsTeamArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationRoleTeamsTeam)(nil)).Elem() +} + +func (i GetOrganizationRoleTeamsTeamArray) ToGetOrganizationRoleTeamsTeamArrayOutput() GetOrganizationRoleTeamsTeamArrayOutput { + return i.ToGetOrganizationRoleTeamsTeamArrayOutputWithContext(context.Background()) +} + +func (i GetOrganizationRoleTeamsTeamArray) ToGetOrganizationRoleTeamsTeamArrayOutputWithContext(ctx context.Context) GetOrganizationRoleTeamsTeamArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationRoleTeamsTeamArrayOutput) +} + +type GetOrganizationRoleTeamsTeamOutput struct{ *pulumi.OutputState } + +func (GetOrganizationRoleTeamsTeamOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationRoleTeamsTeam)(nil)).Elem() +} + +func (o GetOrganizationRoleTeamsTeamOutput) ToGetOrganizationRoleTeamsTeamOutput() GetOrganizationRoleTeamsTeamOutput { + return o +} + +func (o GetOrganizationRoleTeamsTeamOutput) ToGetOrganizationRoleTeamsTeamOutputWithContext(ctx context.Context) GetOrganizationRoleTeamsTeamOutput { + return o +} + +// The name of the team. +func (o GetOrganizationRoleTeamsTeamOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationRoleTeamsTeam) string { return v.Name }).(pulumi.StringOutput) +} + +// The permission that the team will have for its repositories. +func (o GetOrganizationRoleTeamsTeamOutput) Permission() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationRoleTeamsTeam) string { return v.Permission }).(pulumi.StringOutput) +} + +// The Slug of the team name. +func (o GetOrganizationRoleTeamsTeamOutput) Slug() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationRoleTeamsTeam) string { return v.Slug }).(pulumi.StringOutput) +} + +// The ID of the team. +func (o GetOrganizationRoleTeamsTeamOutput) TeamId() pulumi.IntOutput { + return o.ApplyT(func(v GetOrganizationRoleTeamsTeam) int { return v.TeamId }).(pulumi.IntOutput) +} + +type GetOrganizationRoleTeamsTeamArrayOutput struct{ *pulumi.OutputState } + +func (GetOrganizationRoleTeamsTeamArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationRoleTeamsTeam)(nil)).Elem() +} + +func (o GetOrganizationRoleTeamsTeamArrayOutput) ToGetOrganizationRoleTeamsTeamArrayOutput() GetOrganizationRoleTeamsTeamArrayOutput { + return o +} + +func (o GetOrganizationRoleTeamsTeamArrayOutput) ToGetOrganizationRoleTeamsTeamArrayOutputWithContext(ctx context.Context) GetOrganizationRoleTeamsTeamArrayOutput { + return o +} + +func (o GetOrganizationRoleTeamsTeamArrayOutput) Index(i pulumi.IntInput) GetOrganizationRoleTeamsTeamOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetOrganizationRoleTeamsTeam { + return vs[0].([]GetOrganizationRoleTeamsTeam)[vs[1].(int)] + }).(GetOrganizationRoleTeamsTeamOutput) +} + +type GetOrganizationRoleUsersUser struct { + // The login for the GitHub user account. + Login string `pulumi:"login"` + // The ID of the user. + UserId int `pulumi:"userId"` +} + +// GetOrganizationRoleUsersUserInput is an input type that accepts GetOrganizationRoleUsersUserArgs and GetOrganizationRoleUsersUserOutput values. +// You can construct a concrete instance of `GetOrganizationRoleUsersUserInput` via: +// +// GetOrganizationRoleUsersUserArgs{...} +type GetOrganizationRoleUsersUserInput interface { + pulumi.Input + + ToGetOrganizationRoleUsersUserOutput() GetOrganizationRoleUsersUserOutput + ToGetOrganizationRoleUsersUserOutputWithContext(context.Context) GetOrganizationRoleUsersUserOutput +} + +type GetOrganizationRoleUsersUserArgs struct { + // The login for the GitHub user account. + Login pulumi.StringInput `pulumi:"login"` + // The ID of the user. + UserId pulumi.IntInput `pulumi:"userId"` +} + +func (GetOrganizationRoleUsersUserArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationRoleUsersUser)(nil)).Elem() +} + +func (i GetOrganizationRoleUsersUserArgs) ToGetOrganizationRoleUsersUserOutput() GetOrganizationRoleUsersUserOutput { + return i.ToGetOrganizationRoleUsersUserOutputWithContext(context.Background()) +} + +func (i GetOrganizationRoleUsersUserArgs) ToGetOrganizationRoleUsersUserOutputWithContext(ctx context.Context) GetOrganizationRoleUsersUserOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationRoleUsersUserOutput) +} + +// GetOrganizationRoleUsersUserArrayInput is an input type that accepts GetOrganizationRoleUsersUserArray and GetOrganizationRoleUsersUserArrayOutput values. +// You can construct a concrete instance of `GetOrganizationRoleUsersUserArrayInput` via: +// +// GetOrganizationRoleUsersUserArray{ GetOrganizationRoleUsersUserArgs{...} } +type GetOrganizationRoleUsersUserArrayInput interface { + pulumi.Input + + ToGetOrganizationRoleUsersUserArrayOutput() GetOrganizationRoleUsersUserArrayOutput + ToGetOrganizationRoleUsersUserArrayOutputWithContext(context.Context) GetOrganizationRoleUsersUserArrayOutput +} + +type GetOrganizationRoleUsersUserArray []GetOrganizationRoleUsersUserInput + +func (GetOrganizationRoleUsersUserArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationRoleUsersUser)(nil)).Elem() +} + +func (i GetOrganizationRoleUsersUserArray) ToGetOrganizationRoleUsersUserArrayOutput() GetOrganizationRoleUsersUserArrayOutput { + return i.ToGetOrganizationRoleUsersUserArrayOutputWithContext(context.Background()) +} + +func (i GetOrganizationRoleUsersUserArray) ToGetOrganizationRoleUsersUserArrayOutputWithContext(ctx context.Context) GetOrganizationRoleUsersUserArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationRoleUsersUserArrayOutput) +} + +type GetOrganizationRoleUsersUserOutput struct{ *pulumi.OutputState } + +func (GetOrganizationRoleUsersUserOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationRoleUsersUser)(nil)).Elem() +} + +func (o GetOrganizationRoleUsersUserOutput) ToGetOrganizationRoleUsersUserOutput() GetOrganizationRoleUsersUserOutput { + return o +} + +func (o GetOrganizationRoleUsersUserOutput) ToGetOrganizationRoleUsersUserOutputWithContext(ctx context.Context) GetOrganizationRoleUsersUserOutput { + return o +} + +// The login for the GitHub user account. +func (o GetOrganizationRoleUsersUserOutput) Login() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationRoleUsersUser) string { return v.Login }).(pulumi.StringOutput) +} + +// The ID of the user. +func (o GetOrganizationRoleUsersUserOutput) UserId() pulumi.IntOutput { + return o.ApplyT(func(v GetOrganizationRoleUsersUser) int { return v.UserId }).(pulumi.IntOutput) +} + +type GetOrganizationRoleUsersUserArrayOutput struct{ *pulumi.OutputState } + +func (GetOrganizationRoleUsersUserArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationRoleUsersUser)(nil)).Elem() +} + +func (o GetOrganizationRoleUsersUserArrayOutput) ToGetOrganizationRoleUsersUserArrayOutput() GetOrganizationRoleUsersUserArrayOutput { + return o +} + +func (o GetOrganizationRoleUsersUserArrayOutput) ToGetOrganizationRoleUsersUserArrayOutputWithContext(ctx context.Context) GetOrganizationRoleUsersUserArrayOutput { + return o +} + +func (o GetOrganizationRoleUsersUserArrayOutput) Index(i pulumi.IntInput) GetOrganizationRoleUsersUserOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetOrganizationRoleUsersUser { + return vs[0].([]GetOrganizationRoleUsersUser)[vs[1].(int)] + }).(GetOrganizationRoleUsersUserOutput) +} + +type GetOrganizationRolesRole struct { + // The system role from which this role inherits permissions. + BaseRole string `pulumi:"baseRole"` + // The description of the organization role. + Description string `pulumi:"description"` + // The name of the organization role. + Name string `pulumi:"name"` + // A list of permissions included in this role. + Permissions []string `pulumi:"permissions"` + // The ID of the organization role. + RoleId int `pulumi:"roleId"` + // The source of this role; one of `Predefined`, `Organization`, or `Enterprise`. + Source string `pulumi:"source"` +} + +// GetOrganizationRolesRoleInput is an input type that accepts GetOrganizationRolesRoleArgs and GetOrganizationRolesRoleOutput values. +// You can construct a concrete instance of `GetOrganizationRolesRoleInput` via: +// +// GetOrganizationRolesRoleArgs{...} +type GetOrganizationRolesRoleInput interface { + pulumi.Input + + ToGetOrganizationRolesRoleOutput() GetOrganizationRolesRoleOutput + ToGetOrganizationRolesRoleOutputWithContext(context.Context) GetOrganizationRolesRoleOutput +} + +type GetOrganizationRolesRoleArgs struct { + // The system role from which this role inherits permissions. + BaseRole pulumi.StringInput `pulumi:"baseRole"` + // The description of the organization role. + Description pulumi.StringInput `pulumi:"description"` + // The name of the organization role. + Name pulumi.StringInput `pulumi:"name"` + // A list of permissions included in this role. + Permissions pulumi.StringArrayInput `pulumi:"permissions"` + // The ID of the organization role. + RoleId pulumi.IntInput `pulumi:"roleId"` + // The source of this role; one of `Predefined`, `Organization`, or `Enterprise`. + Source pulumi.StringInput `pulumi:"source"` +} + +func (GetOrganizationRolesRoleArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationRolesRole)(nil)).Elem() +} + +func (i GetOrganizationRolesRoleArgs) ToGetOrganizationRolesRoleOutput() GetOrganizationRolesRoleOutput { + return i.ToGetOrganizationRolesRoleOutputWithContext(context.Background()) +} + +func (i GetOrganizationRolesRoleArgs) ToGetOrganizationRolesRoleOutputWithContext(ctx context.Context) GetOrganizationRolesRoleOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationRolesRoleOutput) +} + +// GetOrganizationRolesRoleArrayInput is an input type that accepts GetOrganizationRolesRoleArray and GetOrganizationRolesRoleArrayOutput values. +// You can construct a concrete instance of `GetOrganizationRolesRoleArrayInput` via: +// +// GetOrganizationRolesRoleArray{ GetOrganizationRolesRoleArgs{...} } +type GetOrganizationRolesRoleArrayInput interface { + pulumi.Input + + ToGetOrganizationRolesRoleArrayOutput() GetOrganizationRolesRoleArrayOutput + ToGetOrganizationRolesRoleArrayOutputWithContext(context.Context) GetOrganizationRolesRoleArrayOutput +} + +type GetOrganizationRolesRoleArray []GetOrganizationRolesRoleInput + +func (GetOrganizationRolesRoleArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationRolesRole)(nil)).Elem() +} + +func (i GetOrganizationRolesRoleArray) ToGetOrganizationRolesRoleArrayOutput() GetOrganizationRolesRoleArrayOutput { + return i.ToGetOrganizationRolesRoleArrayOutputWithContext(context.Background()) +} + +func (i GetOrganizationRolesRoleArray) ToGetOrganizationRolesRoleArrayOutputWithContext(ctx context.Context) GetOrganizationRolesRoleArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationRolesRoleArrayOutput) +} + +type GetOrganizationRolesRoleOutput struct{ *pulumi.OutputState } + +func (GetOrganizationRolesRoleOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationRolesRole)(nil)).Elem() +} + +func (o GetOrganizationRolesRoleOutput) ToGetOrganizationRolesRoleOutput() GetOrganizationRolesRoleOutput { + return o +} + +func (o GetOrganizationRolesRoleOutput) ToGetOrganizationRolesRoleOutputWithContext(ctx context.Context) GetOrganizationRolesRoleOutput { + return o +} + +// The system role from which this role inherits permissions. +func (o GetOrganizationRolesRoleOutput) BaseRole() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationRolesRole) string { return v.BaseRole }).(pulumi.StringOutput) +} + +// The description of the organization role. +func (o GetOrganizationRolesRoleOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationRolesRole) string { return v.Description }).(pulumi.StringOutput) +} + +// The name of the organization role. +func (o GetOrganizationRolesRoleOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationRolesRole) string { return v.Name }).(pulumi.StringOutput) +} + +// A list of permissions included in this role. +func (o GetOrganizationRolesRoleOutput) Permissions() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetOrganizationRolesRole) []string { return v.Permissions }).(pulumi.StringArrayOutput) +} + +// The ID of the organization role. +func (o GetOrganizationRolesRoleOutput) RoleId() pulumi.IntOutput { + return o.ApplyT(func(v GetOrganizationRolesRole) int { return v.RoleId }).(pulumi.IntOutput) +} + +// The source of this role; one of `Predefined`, `Organization`, or `Enterprise`. +func (o GetOrganizationRolesRoleOutput) Source() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationRolesRole) string { return v.Source }).(pulumi.StringOutput) +} + +type GetOrganizationRolesRoleArrayOutput struct{ *pulumi.OutputState } + +func (GetOrganizationRolesRoleArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationRolesRole)(nil)).Elem() +} + +func (o GetOrganizationRolesRoleArrayOutput) ToGetOrganizationRolesRoleArrayOutput() GetOrganizationRolesRoleArrayOutput { + return o +} + +func (o GetOrganizationRolesRoleArrayOutput) ToGetOrganizationRolesRoleArrayOutputWithContext(ctx context.Context) GetOrganizationRolesRoleArrayOutput { + return o +} + +func (o GetOrganizationRolesRoleArrayOutput) Index(i pulumi.IntInput) GetOrganizationRolesRoleOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetOrganizationRolesRole { + return vs[0].([]GetOrganizationRolesRole)[vs[1].(int)] + }).(GetOrganizationRolesRoleOutput) +} + +type GetOrganizationSecurityManagersTeam struct { + // Unique identifier of the team. + Id int `pulumi:"id"` + // Name of the team. + Name string `pulumi:"name"` + // Permission that the team will have for its repositories. + Permission string `pulumi:"permission"` + // Name based identifier of the team. + Slug string `pulumi:"slug"` +} + +// GetOrganizationSecurityManagersTeamInput is an input type that accepts GetOrganizationSecurityManagersTeamArgs and GetOrganizationSecurityManagersTeamOutput values. +// You can construct a concrete instance of `GetOrganizationSecurityManagersTeamInput` via: +// +// GetOrganizationSecurityManagersTeamArgs{...} +type GetOrganizationSecurityManagersTeamInput interface { + pulumi.Input + + ToGetOrganizationSecurityManagersTeamOutput() GetOrganizationSecurityManagersTeamOutput + ToGetOrganizationSecurityManagersTeamOutputWithContext(context.Context) GetOrganizationSecurityManagersTeamOutput +} + +type GetOrganizationSecurityManagersTeamArgs struct { + // Unique identifier of the team. + Id pulumi.IntInput `pulumi:"id"` + // Name of the team. + Name pulumi.StringInput `pulumi:"name"` + // Permission that the team will have for its repositories. + Permission pulumi.StringInput `pulumi:"permission"` + // Name based identifier of the team. + Slug pulumi.StringInput `pulumi:"slug"` +} + +func (GetOrganizationSecurityManagersTeamArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationSecurityManagersTeam)(nil)).Elem() +} + +func (i GetOrganizationSecurityManagersTeamArgs) ToGetOrganizationSecurityManagersTeamOutput() GetOrganizationSecurityManagersTeamOutput { + return i.ToGetOrganizationSecurityManagersTeamOutputWithContext(context.Background()) +} + +func (i GetOrganizationSecurityManagersTeamArgs) ToGetOrganizationSecurityManagersTeamOutputWithContext(ctx context.Context) GetOrganizationSecurityManagersTeamOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationSecurityManagersTeamOutput) +} + +// GetOrganizationSecurityManagersTeamArrayInput is an input type that accepts GetOrganizationSecurityManagersTeamArray and GetOrganizationSecurityManagersTeamArrayOutput values. +// You can construct a concrete instance of `GetOrganizationSecurityManagersTeamArrayInput` via: +// +// GetOrganizationSecurityManagersTeamArray{ GetOrganizationSecurityManagersTeamArgs{...} } +type GetOrganizationSecurityManagersTeamArrayInput interface { + pulumi.Input + + ToGetOrganizationSecurityManagersTeamArrayOutput() GetOrganizationSecurityManagersTeamArrayOutput + ToGetOrganizationSecurityManagersTeamArrayOutputWithContext(context.Context) GetOrganizationSecurityManagersTeamArrayOutput +} + +type GetOrganizationSecurityManagersTeamArray []GetOrganizationSecurityManagersTeamInput + +func (GetOrganizationSecurityManagersTeamArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationSecurityManagersTeam)(nil)).Elem() +} + +func (i GetOrganizationSecurityManagersTeamArray) ToGetOrganizationSecurityManagersTeamArrayOutput() GetOrganizationSecurityManagersTeamArrayOutput { + return i.ToGetOrganizationSecurityManagersTeamArrayOutputWithContext(context.Background()) +} + +func (i GetOrganizationSecurityManagersTeamArray) ToGetOrganizationSecurityManagersTeamArrayOutputWithContext(ctx context.Context) GetOrganizationSecurityManagersTeamArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationSecurityManagersTeamArrayOutput) +} + +type GetOrganizationSecurityManagersTeamOutput struct{ *pulumi.OutputState } + +func (GetOrganizationSecurityManagersTeamOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationSecurityManagersTeam)(nil)).Elem() +} + +func (o GetOrganizationSecurityManagersTeamOutput) ToGetOrganizationSecurityManagersTeamOutput() GetOrganizationSecurityManagersTeamOutput { + return o +} + +func (o GetOrganizationSecurityManagersTeamOutput) ToGetOrganizationSecurityManagersTeamOutputWithContext(ctx context.Context) GetOrganizationSecurityManagersTeamOutput { + return o +} + +// Unique identifier of the team. +func (o GetOrganizationSecurityManagersTeamOutput) Id() pulumi.IntOutput { + return o.ApplyT(func(v GetOrganizationSecurityManagersTeam) int { return v.Id }).(pulumi.IntOutput) +} + +// Name of the team. +func (o GetOrganizationSecurityManagersTeamOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationSecurityManagersTeam) string { return v.Name }).(pulumi.StringOutput) +} + +// Permission that the team will have for its repositories. +func (o GetOrganizationSecurityManagersTeamOutput) Permission() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationSecurityManagersTeam) string { return v.Permission }).(pulumi.StringOutput) +} + +// Name based identifier of the team. +func (o GetOrganizationSecurityManagersTeamOutput) Slug() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationSecurityManagersTeam) string { return v.Slug }).(pulumi.StringOutput) +} + +type GetOrganizationSecurityManagersTeamArrayOutput struct{ *pulumi.OutputState } + +func (GetOrganizationSecurityManagersTeamArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationSecurityManagersTeam)(nil)).Elem() +} + +func (o GetOrganizationSecurityManagersTeamArrayOutput) ToGetOrganizationSecurityManagersTeamArrayOutput() GetOrganizationSecurityManagersTeamArrayOutput { + return o +} + +func (o GetOrganizationSecurityManagersTeamArrayOutput) ToGetOrganizationSecurityManagersTeamArrayOutputWithContext(ctx context.Context) GetOrganizationSecurityManagersTeamArrayOutput { + return o +} + +func (o GetOrganizationSecurityManagersTeamArrayOutput) Index(i pulumi.IntInput) GetOrganizationSecurityManagersTeamOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetOrganizationSecurityManagersTeam { + return vs[0].([]GetOrganizationSecurityManagersTeam)[vs[1].(int)] + }).(GetOrganizationSecurityManagersTeamOutput) +} + +type GetOrganizationTeamSyncGroupsGroup struct { + // The description of the IdP group. + GroupDescription string `pulumi:"groupDescription"` + // The ID of the IdP group. + GroupId string `pulumi:"groupId"` + // The name of the IdP group. + GroupName string `pulumi:"groupName"` +} + +// GetOrganizationTeamSyncGroupsGroupInput is an input type that accepts GetOrganizationTeamSyncGroupsGroupArgs and GetOrganizationTeamSyncGroupsGroupOutput values. +// You can construct a concrete instance of `GetOrganizationTeamSyncGroupsGroupInput` via: +// +// GetOrganizationTeamSyncGroupsGroupArgs{...} +type GetOrganizationTeamSyncGroupsGroupInput interface { + pulumi.Input + + ToGetOrganizationTeamSyncGroupsGroupOutput() GetOrganizationTeamSyncGroupsGroupOutput + ToGetOrganizationTeamSyncGroupsGroupOutputWithContext(context.Context) GetOrganizationTeamSyncGroupsGroupOutput +} + +type GetOrganizationTeamSyncGroupsGroupArgs struct { + // The description of the IdP group. + GroupDescription pulumi.StringInput `pulumi:"groupDescription"` + // The ID of the IdP group. + GroupId pulumi.StringInput `pulumi:"groupId"` + // The name of the IdP group. + GroupName pulumi.StringInput `pulumi:"groupName"` +} + +func (GetOrganizationTeamSyncGroupsGroupArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationTeamSyncGroupsGroup)(nil)).Elem() +} + +func (i GetOrganizationTeamSyncGroupsGroupArgs) ToGetOrganizationTeamSyncGroupsGroupOutput() GetOrganizationTeamSyncGroupsGroupOutput { + return i.ToGetOrganizationTeamSyncGroupsGroupOutputWithContext(context.Background()) +} + +func (i GetOrganizationTeamSyncGroupsGroupArgs) ToGetOrganizationTeamSyncGroupsGroupOutputWithContext(ctx context.Context) GetOrganizationTeamSyncGroupsGroupOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationTeamSyncGroupsGroupOutput) +} + +// GetOrganizationTeamSyncGroupsGroupArrayInput is an input type that accepts GetOrganizationTeamSyncGroupsGroupArray and GetOrganizationTeamSyncGroupsGroupArrayOutput values. +// You can construct a concrete instance of `GetOrganizationTeamSyncGroupsGroupArrayInput` via: +// +// GetOrganizationTeamSyncGroupsGroupArray{ GetOrganizationTeamSyncGroupsGroupArgs{...} } +type GetOrganizationTeamSyncGroupsGroupArrayInput interface { + pulumi.Input + + ToGetOrganizationTeamSyncGroupsGroupArrayOutput() GetOrganizationTeamSyncGroupsGroupArrayOutput + ToGetOrganizationTeamSyncGroupsGroupArrayOutputWithContext(context.Context) GetOrganizationTeamSyncGroupsGroupArrayOutput +} + +type GetOrganizationTeamSyncGroupsGroupArray []GetOrganizationTeamSyncGroupsGroupInput + +func (GetOrganizationTeamSyncGroupsGroupArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationTeamSyncGroupsGroup)(nil)).Elem() +} + +func (i GetOrganizationTeamSyncGroupsGroupArray) ToGetOrganizationTeamSyncGroupsGroupArrayOutput() GetOrganizationTeamSyncGroupsGroupArrayOutput { + return i.ToGetOrganizationTeamSyncGroupsGroupArrayOutputWithContext(context.Background()) +} + +func (i GetOrganizationTeamSyncGroupsGroupArray) ToGetOrganizationTeamSyncGroupsGroupArrayOutputWithContext(ctx context.Context) GetOrganizationTeamSyncGroupsGroupArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationTeamSyncGroupsGroupArrayOutput) +} + +type GetOrganizationTeamSyncGroupsGroupOutput struct{ *pulumi.OutputState } + +func (GetOrganizationTeamSyncGroupsGroupOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationTeamSyncGroupsGroup)(nil)).Elem() +} + +func (o GetOrganizationTeamSyncGroupsGroupOutput) ToGetOrganizationTeamSyncGroupsGroupOutput() GetOrganizationTeamSyncGroupsGroupOutput { + return o +} + +func (o GetOrganizationTeamSyncGroupsGroupOutput) ToGetOrganizationTeamSyncGroupsGroupOutputWithContext(ctx context.Context) GetOrganizationTeamSyncGroupsGroupOutput { + return o +} + +// The description of the IdP group. +func (o GetOrganizationTeamSyncGroupsGroupOutput) GroupDescription() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationTeamSyncGroupsGroup) string { return v.GroupDescription }).(pulumi.StringOutput) +} + +// The ID of the IdP group. +func (o GetOrganizationTeamSyncGroupsGroupOutput) GroupId() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationTeamSyncGroupsGroup) string { return v.GroupId }).(pulumi.StringOutput) +} + +// The name of the IdP group. +func (o GetOrganizationTeamSyncGroupsGroupOutput) GroupName() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationTeamSyncGroupsGroup) string { return v.GroupName }).(pulumi.StringOutput) +} + +type GetOrganizationTeamSyncGroupsGroupArrayOutput struct{ *pulumi.OutputState } + +func (GetOrganizationTeamSyncGroupsGroupArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationTeamSyncGroupsGroup)(nil)).Elem() +} + +func (o GetOrganizationTeamSyncGroupsGroupArrayOutput) ToGetOrganizationTeamSyncGroupsGroupArrayOutput() GetOrganizationTeamSyncGroupsGroupArrayOutput { + return o +} + +func (o GetOrganizationTeamSyncGroupsGroupArrayOutput) ToGetOrganizationTeamSyncGroupsGroupArrayOutputWithContext(ctx context.Context) GetOrganizationTeamSyncGroupsGroupArrayOutput { + return o +} + +func (o GetOrganizationTeamSyncGroupsGroupArrayOutput) Index(i pulumi.IntInput) GetOrganizationTeamSyncGroupsGroupOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetOrganizationTeamSyncGroupsGroup { + return vs[0].([]GetOrganizationTeamSyncGroupsGroup)[vs[1].(int)] + }).(GetOrganizationTeamSyncGroupsGroupOutput) +} + +type GetOrganizationTeamsTeam struct { + // The team's description. + Description string `pulumi:"description"` + // The ID of the team. + Id int `pulumi:"id"` + // List of team members. Not returned if `summaryOnly = true` + Members []string `pulumi:"members"` + // The team's full name. + Name string `pulumi:"name"` + // The Node ID of the team. + NodeId string `pulumi:"nodeId"` + // (**DEPRECATED**) The parent team, use `parentTeamId` or `parentTeamSlug` instead. + // + // Deprecated: Use parentTeamId and parentTeamSlug instead. + Parent map[string]string `pulumi:"parent"` + // The ID of the parent team, if there is one. + ParentTeamId string `pulumi:"parentTeamId"` + // The slug of the parent team, if there is one. + ParentTeamSlug string `pulumi:"parentTeamSlug"` + // The team's privacy type. + Privacy string `pulumi:"privacy"` + // List of team repositories. Not returned if `summaryOnly = true` + Repositories []string `pulumi:"repositories"` + // The slug of the team. + Slug string `pulumi:"slug"` +} + +// GetOrganizationTeamsTeamInput is an input type that accepts GetOrganizationTeamsTeamArgs and GetOrganizationTeamsTeamOutput values. +// You can construct a concrete instance of `GetOrganizationTeamsTeamInput` via: +// +// GetOrganizationTeamsTeamArgs{...} +type GetOrganizationTeamsTeamInput interface { + pulumi.Input + + ToGetOrganizationTeamsTeamOutput() GetOrganizationTeamsTeamOutput + ToGetOrganizationTeamsTeamOutputWithContext(context.Context) GetOrganizationTeamsTeamOutput +} + +type GetOrganizationTeamsTeamArgs struct { + // The team's description. + Description pulumi.StringInput `pulumi:"description"` + // The ID of the team. + Id pulumi.IntInput `pulumi:"id"` + // List of team members. Not returned if `summaryOnly = true` + Members pulumi.StringArrayInput `pulumi:"members"` + // The team's full name. + Name pulumi.StringInput `pulumi:"name"` + // The Node ID of the team. + NodeId pulumi.StringInput `pulumi:"nodeId"` + // (**DEPRECATED**) The parent team, use `parentTeamId` or `parentTeamSlug` instead. + // + // Deprecated: Use parentTeamId and parentTeamSlug instead. + Parent pulumi.StringMapInput `pulumi:"parent"` + // The ID of the parent team, if there is one. + ParentTeamId pulumi.StringInput `pulumi:"parentTeamId"` + // The slug of the parent team, if there is one. + ParentTeamSlug pulumi.StringInput `pulumi:"parentTeamSlug"` + // The team's privacy type. + Privacy pulumi.StringInput `pulumi:"privacy"` + // List of team repositories. Not returned if `summaryOnly = true` + Repositories pulumi.StringArrayInput `pulumi:"repositories"` + // The slug of the team. + Slug pulumi.StringInput `pulumi:"slug"` +} + +func (GetOrganizationTeamsTeamArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationTeamsTeam)(nil)).Elem() +} + +func (i GetOrganizationTeamsTeamArgs) ToGetOrganizationTeamsTeamOutput() GetOrganizationTeamsTeamOutput { + return i.ToGetOrganizationTeamsTeamOutputWithContext(context.Background()) +} + +func (i GetOrganizationTeamsTeamArgs) ToGetOrganizationTeamsTeamOutputWithContext(ctx context.Context) GetOrganizationTeamsTeamOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationTeamsTeamOutput) +} + +// GetOrganizationTeamsTeamArrayInput is an input type that accepts GetOrganizationTeamsTeamArray and GetOrganizationTeamsTeamArrayOutput values. +// You can construct a concrete instance of `GetOrganizationTeamsTeamArrayInput` via: +// +// GetOrganizationTeamsTeamArray{ GetOrganizationTeamsTeamArgs{...} } +type GetOrganizationTeamsTeamArrayInput interface { + pulumi.Input + + ToGetOrganizationTeamsTeamArrayOutput() GetOrganizationTeamsTeamArrayOutput + ToGetOrganizationTeamsTeamArrayOutputWithContext(context.Context) GetOrganizationTeamsTeamArrayOutput +} + +type GetOrganizationTeamsTeamArray []GetOrganizationTeamsTeamInput + +func (GetOrganizationTeamsTeamArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationTeamsTeam)(nil)).Elem() +} + +func (i GetOrganizationTeamsTeamArray) ToGetOrganizationTeamsTeamArrayOutput() GetOrganizationTeamsTeamArrayOutput { + return i.ToGetOrganizationTeamsTeamArrayOutputWithContext(context.Background()) +} + +func (i GetOrganizationTeamsTeamArray) ToGetOrganizationTeamsTeamArrayOutputWithContext(ctx context.Context) GetOrganizationTeamsTeamArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationTeamsTeamArrayOutput) +} + +type GetOrganizationTeamsTeamOutput struct{ *pulumi.OutputState } + +func (GetOrganizationTeamsTeamOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationTeamsTeam)(nil)).Elem() +} + +func (o GetOrganizationTeamsTeamOutput) ToGetOrganizationTeamsTeamOutput() GetOrganizationTeamsTeamOutput { + return o +} + +func (o GetOrganizationTeamsTeamOutput) ToGetOrganizationTeamsTeamOutputWithContext(ctx context.Context) GetOrganizationTeamsTeamOutput { + return o +} + +// The team's description. +func (o GetOrganizationTeamsTeamOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationTeamsTeam) string { return v.Description }).(pulumi.StringOutput) +} + +// The ID of the team. +func (o GetOrganizationTeamsTeamOutput) Id() pulumi.IntOutput { + return o.ApplyT(func(v GetOrganizationTeamsTeam) int { return v.Id }).(pulumi.IntOutput) +} + +// List of team members. Not returned if `summaryOnly = true` +func (o GetOrganizationTeamsTeamOutput) Members() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetOrganizationTeamsTeam) []string { return v.Members }).(pulumi.StringArrayOutput) +} + +// The team's full name. +func (o GetOrganizationTeamsTeamOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationTeamsTeam) string { return v.Name }).(pulumi.StringOutput) +} + +// The Node ID of the team. +func (o GetOrganizationTeamsTeamOutput) NodeId() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationTeamsTeam) string { return v.NodeId }).(pulumi.StringOutput) +} + +// (**DEPRECATED**) The parent team, use `parentTeamId` or `parentTeamSlug` instead. +// +// Deprecated: Use parentTeamId and parentTeamSlug instead. +func (o GetOrganizationTeamsTeamOutput) Parent() pulumi.StringMapOutput { + return o.ApplyT(func(v GetOrganizationTeamsTeam) map[string]string { return v.Parent }).(pulumi.StringMapOutput) +} + +// The ID of the parent team, if there is one. +func (o GetOrganizationTeamsTeamOutput) ParentTeamId() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationTeamsTeam) string { return v.ParentTeamId }).(pulumi.StringOutput) +} + +// The slug of the parent team, if there is one. +func (o GetOrganizationTeamsTeamOutput) ParentTeamSlug() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationTeamsTeam) string { return v.ParentTeamSlug }).(pulumi.StringOutput) +} + +// The team's privacy type. +func (o GetOrganizationTeamsTeamOutput) Privacy() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationTeamsTeam) string { return v.Privacy }).(pulumi.StringOutput) +} + +// List of team repositories. Not returned if `summaryOnly = true` +func (o GetOrganizationTeamsTeamOutput) Repositories() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetOrganizationTeamsTeam) []string { return v.Repositories }).(pulumi.StringArrayOutput) +} + +// The slug of the team. +func (o GetOrganizationTeamsTeamOutput) Slug() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationTeamsTeam) string { return v.Slug }).(pulumi.StringOutput) +} + +type GetOrganizationTeamsTeamArrayOutput struct{ *pulumi.OutputState } + +func (GetOrganizationTeamsTeamArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationTeamsTeam)(nil)).Elem() +} + +func (o GetOrganizationTeamsTeamArrayOutput) ToGetOrganizationTeamsTeamArrayOutput() GetOrganizationTeamsTeamArrayOutput { + return o +} + +func (o GetOrganizationTeamsTeamArrayOutput) ToGetOrganizationTeamsTeamArrayOutputWithContext(ctx context.Context) GetOrganizationTeamsTeamArrayOutput { + return o +} + +func (o GetOrganizationTeamsTeamArrayOutput) Index(i pulumi.IntInput) GetOrganizationTeamsTeamOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetOrganizationTeamsTeam { + return vs[0].([]GetOrganizationTeamsTeam)[vs[1].(int)] + }).(GetOrganizationTeamsTeamOutput) +} + +type GetOrganizationWebhooksWebhook struct { + // `true` if the webhook is active. + Active bool `pulumi:"active"` + // the ID of the webhook. + Id int `pulumi:"id"` + // the name of the webhook. + Name string `pulumi:"name"` + // the type of the webhook. + Type string `pulumi:"type"` + // the url of the webhook. + Url string `pulumi:"url"` +} + +// GetOrganizationWebhooksWebhookInput is an input type that accepts GetOrganizationWebhooksWebhookArgs and GetOrganizationWebhooksWebhookOutput values. +// You can construct a concrete instance of `GetOrganizationWebhooksWebhookInput` via: +// +// GetOrganizationWebhooksWebhookArgs{...} +type GetOrganizationWebhooksWebhookInput interface { + pulumi.Input + + ToGetOrganizationWebhooksWebhookOutput() GetOrganizationWebhooksWebhookOutput + ToGetOrganizationWebhooksWebhookOutputWithContext(context.Context) GetOrganizationWebhooksWebhookOutput +} + +type GetOrganizationWebhooksWebhookArgs struct { + // `true` if the webhook is active. + Active pulumi.BoolInput `pulumi:"active"` + // the ID of the webhook. + Id pulumi.IntInput `pulumi:"id"` + // the name of the webhook. + Name pulumi.StringInput `pulumi:"name"` + // the type of the webhook. + Type pulumi.StringInput `pulumi:"type"` + // the url of the webhook. + Url pulumi.StringInput `pulumi:"url"` +} + +func (GetOrganizationWebhooksWebhookArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationWebhooksWebhook)(nil)).Elem() +} + +func (i GetOrganizationWebhooksWebhookArgs) ToGetOrganizationWebhooksWebhookOutput() GetOrganizationWebhooksWebhookOutput { + return i.ToGetOrganizationWebhooksWebhookOutputWithContext(context.Background()) +} + +func (i GetOrganizationWebhooksWebhookArgs) ToGetOrganizationWebhooksWebhookOutputWithContext(ctx context.Context) GetOrganizationWebhooksWebhookOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationWebhooksWebhookOutput) +} + +// GetOrganizationWebhooksWebhookArrayInput is an input type that accepts GetOrganizationWebhooksWebhookArray and GetOrganizationWebhooksWebhookArrayOutput values. +// You can construct a concrete instance of `GetOrganizationWebhooksWebhookArrayInput` via: +// +// GetOrganizationWebhooksWebhookArray{ GetOrganizationWebhooksWebhookArgs{...} } +type GetOrganizationWebhooksWebhookArrayInput interface { + pulumi.Input + + ToGetOrganizationWebhooksWebhookArrayOutput() GetOrganizationWebhooksWebhookArrayOutput + ToGetOrganizationWebhooksWebhookArrayOutputWithContext(context.Context) GetOrganizationWebhooksWebhookArrayOutput +} + +type GetOrganizationWebhooksWebhookArray []GetOrganizationWebhooksWebhookInput + +func (GetOrganizationWebhooksWebhookArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationWebhooksWebhook)(nil)).Elem() +} + +func (i GetOrganizationWebhooksWebhookArray) ToGetOrganizationWebhooksWebhookArrayOutput() GetOrganizationWebhooksWebhookArrayOutput { + return i.ToGetOrganizationWebhooksWebhookArrayOutputWithContext(context.Background()) +} + +func (i GetOrganizationWebhooksWebhookArray) ToGetOrganizationWebhooksWebhookArrayOutputWithContext(ctx context.Context) GetOrganizationWebhooksWebhookArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetOrganizationWebhooksWebhookArrayOutput) +} + +type GetOrganizationWebhooksWebhookOutput struct{ *pulumi.OutputState } + +func (GetOrganizationWebhooksWebhookOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetOrganizationWebhooksWebhook)(nil)).Elem() +} + +func (o GetOrganizationWebhooksWebhookOutput) ToGetOrganizationWebhooksWebhookOutput() GetOrganizationWebhooksWebhookOutput { + return o +} + +func (o GetOrganizationWebhooksWebhookOutput) ToGetOrganizationWebhooksWebhookOutputWithContext(ctx context.Context) GetOrganizationWebhooksWebhookOutput { + return o +} + +// `true` if the webhook is active. +func (o GetOrganizationWebhooksWebhookOutput) Active() pulumi.BoolOutput { + return o.ApplyT(func(v GetOrganizationWebhooksWebhook) bool { return v.Active }).(pulumi.BoolOutput) +} + +// the ID of the webhook. +func (o GetOrganizationWebhooksWebhookOutput) Id() pulumi.IntOutput { + return o.ApplyT(func(v GetOrganizationWebhooksWebhook) int { return v.Id }).(pulumi.IntOutput) +} + +// the name of the webhook. +func (o GetOrganizationWebhooksWebhookOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationWebhooksWebhook) string { return v.Name }).(pulumi.StringOutput) +} + +// the type of the webhook. +func (o GetOrganizationWebhooksWebhookOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationWebhooksWebhook) string { return v.Type }).(pulumi.StringOutput) +} + +// the url of the webhook. +func (o GetOrganizationWebhooksWebhookOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v GetOrganizationWebhooksWebhook) string { return v.Url }).(pulumi.StringOutput) +} + +type GetOrganizationWebhooksWebhookArrayOutput struct{ *pulumi.OutputState } + +func (GetOrganizationWebhooksWebhookArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetOrganizationWebhooksWebhook)(nil)).Elem() +} + +func (o GetOrganizationWebhooksWebhookArrayOutput) ToGetOrganizationWebhooksWebhookArrayOutput() GetOrganizationWebhooksWebhookArrayOutput { + return o +} + +func (o GetOrganizationWebhooksWebhookArrayOutput) ToGetOrganizationWebhooksWebhookArrayOutputWithContext(ctx context.Context) GetOrganizationWebhooksWebhookArrayOutput { + return o +} + +func (o GetOrganizationWebhooksWebhookArrayOutput) Index(i pulumi.IntInput) GetOrganizationWebhooksWebhookOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetOrganizationWebhooksWebhook { + return vs[0].([]GetOrganizationWebhooksWebhook)[vs[1].(int)] + }).(GetOrganizationWebhooksWebhookOutput) +} + +type GetReleaseAsset struct { + // Browser download URL + BrowserDownloadUrl string `pulumi:"browserDownloadUrl"` + // MIME type of the asset + ContentType string `pulumi:"contentType"` + // Date the asset was created + CreatedAt string `pulumi:"createdAt"` + // ID of the asset + Id int `pulumi:"id"` + // Label for the asset + Label string `pulumi:"label"` + // The file name of the asset + Name string `pulumi:"name"` + // Node ID of the asset + NodeId string `pulumi:"nodeId"` + // Size in byte + Size int `pulumi:"size"` + // Date the asset was last updated + UpdatedAt string `pulumi:"updatedAt"` + // URL of the asset + Url string `pulumi:"url"` +} + +// GetReleaseAssetInput is an input type that accepts GetReleaseAssetArgs and GetReleaseAssetOutput values. +// You can construct a concrete instance of `GetReleaseAssetInput` via: +// +// GetReleaseAssetArgs{...} +type GetReleaseAssetInput interface { + pulumi.Input + + ToGetReleaseAssetOutput() GetReleaseAssetOutput + ToGetReleaseAssetOutputWithContext(context.Context) GetReleaseAssetOutput +} + +type GetReleaseAssetArgs struct { + // Browser download URL + BrowserDownloadUrl pulumi.StringInput `pulumi:"browserDownloadUrl"` + // MIME type of the asset + ContentType pulumi.StringInput `pulumi:"contentType"` + // Date the asset was created + CreatedAt pulumi.StringInput `pulumi:"createdAt"` + // ID of the asset + Id pulumi.IntInput `pulumi:"id"` + // Label for the asset + Label pulumi.StringInput `pulumi:"label"` + // The file name of the asset + Name pulumi.StringInput `pulumi:"name"` + // Node ID of the asset + NodeId pulumi.StringInput `pulumi:"nodeId"` + // Size in byte + Size pulumi.IntInput `pulumi:"size"` + // Date the asset was last updated + UpdatedAt pulumi.StringInput `pulumi:"updatedAt"` + // URL of the asset + Url pulumi.StringInput `pulumi:"url"` +} + +func (GetReleaseAssetArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetReleaseAsset)(nil)).Elem() +} + +func (i GetReleaseAssetArgs) ToGetReleaseAssetOutput() GetReleaseAssetOutput { + return i.ToGetReleaseAssetOutputWithContext(context.Background()) +} + +func (i GetReleaseAssetArgs) ToGetReleaseAssetOutputWithContext(ctx context.Context) GetReleaseAssetOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetReleaseAssetOutput) +} + +// GetReleaseAssetArrayInput is an input type that accepts GetReleaseAssetArray and GetReleaseAssetArrayOutput values. +// You can construct a concrete instance of `GetReleaseAssetArrayInput` via: +// +// GetReleaseAssetArray{ GetReleaseAssetArgs{...} } +type GetReleaseAssetArrayInput interface { + pulumi.Input + + ToGetReleaseAssetArrayOutput() GetReleaseAssetArrayOutput + ToGetReleaseAssetArrayOutputWithContext(context.Context) GetReleaseAssetArrayOutput +} + +type GetReleaseAssetArray []GetReleaseAssetInput + +func (GetReleaseAssetArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetReleaseAsset)(nil)).Elem() +} + +func (i GetReleaseAssetArray) ToGetReleaseAssetArrayOutput() GetReleaseAssetArrayOutput { + return i.ToGetReleaseAssetArrayOutputWithContext(context.Background()) +} + +func (i GetReleaseAssetArray) ToGetReleaseAssetArrayOutputWithContext(ctx context.Context) GetReleaseAssetArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetReleaseAssetArrayOutput) +} + +type GetReleaseAssetOutput struct{ *pulumi.OutputState } + +func (GetReleaseAssetOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetReleaseAsset)(nil)).Elem() +} + +func (o GetReleaseAssetOutput) ToGetReleaseAssetOutput() GetReleaseAssetOutput { + return o +} + +func (o GetReleaseAssetOutput) ToGetReleaseAssetOutputWithContext(ctx context.Context) GetReleaseAssetOutput { + return o +} + +// Browser download URL +func (o GetReleaseAssetOutput) BrowserDownloadUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetReleaseAsset) string { return v.BrowserDownloadUrl }).(pulumi.StringOutput) +} + +// MIME type of the asset +func (o GetReleaseAssetOutput) ContentType() pulumi.StringOutput { + return o.ApplyT(func(v GetReleaseAsset) string { return v.ContentType }).(pulumi.StringOutput) +} + +// Date the asset was created +func (o GetReleaseAssetOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetReleaseAsset) string { return v.CreatedAt }).(pulumi.StringOutput) +} + +// ID of the asset +func (o GetReleaseAssetOutput) Id() pulumi.IntOutput { + return o.ApplyT(func(v GetReleaseAsset) int { return v.Id }).(pulumi.IntOutput) +} + +// Label for the asset +func (o GetReleaseAssetOutput) Label() pulumi.StringOutput { + return o.ApplyT(func(v GetReleaseAsset) string { return v.Label }).(pulumi.StringOutput) +} + +// The file name of the asset +func (o GetReleaseAssetOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetReleaseAsset) string { return v.Name }).(pulumi.StringOutput) +} + +// Node ID of the asset +func (o GetReleaseAssetOutput) NodeId() pulumi.StringOutput { + return o.ApplyT(func(v GetReleaseAsset) string { return v.NodeId }).(pulumi.StringOutput) +} + +// Size in byte +func (o GetReleaseAssetOutput) Size() pulumi.IntOutput { + return o.ApplyT(func(v GetReleaseAsset) int { return v.Size }).(pulumi.IntOutput) +} + +// Date the asset was last updated +func (o GetReleaseAssetOutput) UpdatedAt() pulumi.StringOutput { + return o.ApplyT(func(v GetReleaseAsset) string { return v.UpdatedAt }).(pulumi.StringOutput) +} + +// URL of the asset +func (o GetReleaseAssetOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v GetReleaseAsset) string { return v.Url }).(pulumi.StringOutput) +} + +type GetReleaseAssetArrayOutput struct{ *pulumi.OutputState } + +func (GetReleaseAssetArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetReleaseAsset)(nil)).Elem() +} + +func (o GetReleaseAssetArrayOutput) ToGetReleaseAssetArrayOutput() GetReleaseAssetArrayOutput { + return o +} + +func (o GetReleaseAssetArrayOutput) ToGetReleaseAssetArrayOutputWithContext(ctx context.Context) GetReleaseAssetArrayOutput { + return o +} + +func (o GetReleaseAssetArrayOutput) Index(i pulumi.IntInput) GetReleaseAssetOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetReleaseAsset { + return vs[0].([]GetReleaseAsset)[vs[1].(int)] + }).(GetReleaseAssetOutput) +} + +type GetRepositoryAutolinkReferencesAutolinkReference struct { + // True if alphanumeric. + IsAlphanumeric bool `pulumi:"isAlphanumeric"` + // Key prefix. + KeyPrefix string `pulumi:"keyPrefix"` + // Target url template. + TargetUrlTemplate string `pulumi:"targetUrlTemplate"` +} + +// GetRepositoryAutolinkReferencesAutolinkReferenceInput is an input type that accepts GetRepositoryAutolinkReferencesAutolinkReferenceArgs and GetRepositoryAutolinkReferencesAutolinkReferenceOutput values. +// You can construct a concrete instance of `GetRepositoryAutolinkReferencesAutolinkReferenceInput` via: +// +// GetRepositoryAutolinkReferencesAutolinkReferenceArgs{...} +type GetRepositoryAutolinkReferencesAutolinkReferenceInput interface { + pulumi.Input + + ToGetRepositoryAutolinkReferencesAutolinkReferenceOutput() GetRepositoryAutolinkReferencesAutolinkReferenceOutput + ToGetRepositoryAutolinkReferencesAutolinkReferenceOutputWithContext(context.Context) GetRepositoryAutolinkReferencesAutolinkReferenceOutput +} + +type GetRepositoryAutolinkReferencesAutolinkReferenceArgs struct { + // True if alphanumeric. + IsAlphanumeric pulumi.BoolInput `pulumi:"isAlphanumeric"` + // Key prefix. + KeyPrefix pulumi.StringInput `pulumi:"keyPrefix"` + // Target url template. + TargetUrlTemplate pulumi.StringInput `pulumi:"targetUrlTemplate"` +} + +func (GetRepositoryAutolinkReferencesAutolinkReferenceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryAutolinkReferencesAutolinkReference)(nil)).Elem() +} + +func (i GetRepositoryAutolinkReferencesAutolinkReferenceArgs) ToGetRepositoryAutolinkReferencesAutolinkReferenceOutput() GetRepositoryAutolinkReferencesAutolinkReferenceOutput { + return i.ToGetRepositoryAutolinkReferencesAutolinkReferenceOutputWithContext(context.Background()) +} + +func (i GetRepositoryAutolinkReferencesAutolinkReferenceArgs) ToGetRepositoryAutolinkReferencesAutolinkReferenceOutputWithContext(ctx context.Context) GetRepositoryAutolinkReferencesAutolinkReferenceOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryAutolinkReferencesAutolinkReferenceOutput) +} + +// GetRepositoryAutolinkReferencesAutolinkReferenceArrayInput is an input type that accepts GetRepositoryAutolinkReferencesAutolinkReferenceArray and GetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput values. +// You can construct a concrete instance of `GetRepositoryAutolinkReferencesAutolinkReferenceArrayInput` via: +// +// GetRepositoryAutolinkReferencesAutolinkReferenceArray{ GetRepositoryAutolinkReferencesAutolinkReferenceArgs{...} } +type GetRepositoryAutolinkReferencesAutolinkReferenceArrayInput interface { + pulumi.Input + + ToGetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput() GetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput + ToGetRepositoryAutolinkReferencesAutolinkReferenceArrayOutputWithContext(context.Context) GetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput +} + +type GetRepositoryAutolinkReferencesAutolinkReferenceArray []GetRepositoryAutolinkReferencesAutolinkReferenceInput + +func (GetRepositoryAutolinkReferencesAutolinkReferenceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryAutolinkReferencesAutolinkReference)(nil)).Elem() +} + +func (i GetRepositoryAutolinkReferencesAutolinkReferenceArray) ToGetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput() GetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput { + return i.ToGetRepositoryAutolinkReferencesAutolinkReferenceArrayOutputWithContext(context.Background()) +} + +func (i GetRepositoryAutolinkReferencesAutolinkReferenceArray) ToGetRepositoryAutolinkReferencesAutolinkReferenceArrayOutputWithContext(ctx context.Context) GetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput) +} + +type GetRepositoryAutolinkReferencesAutolinkReferenceOutput struct{ *pulumi.OutputState } + +func (GetRepositoryAutolinkReferencesAutolinkReferenceOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryAutolinkReferencesAutolinkReference)(nil)).Elem() +} + +func (o GetRepositoryAutolinkReferencesAutolinkReferenceOutput) ToGetRepositoryAutolinkReferencesAutolinkReferenceOutput() GetRepositoryAutolinkReferencesAutolinkReferenceOutput { + return o +} + +func (o GetRepositoryAutolinkReferencesAutolinkReferenceOutput) ToGetRepositoryAutolinkReferencesAutolinkReferenceOutputWithContext(ctx context.Context) GetRepositoryAutolinkReferencesAutolinkReferenceOutput { + return o +} + +// True if alphanumeric. +func (o GetRepositoryAutolinkReferencesAutolinkReferenceOutput) IsAlphanumeric() pulumi.BoolOutput { + return o.ApplyT(func(v GetRepositoryAutolinkReferencesAutolinkReference) bool { return v.IsAlphanumeric }).(pulumi.BoolOutput) +} + +// Key prefix. +func (o GetRepositoryAutolinkReferencesAutolinkReferenceOutput) KeyPrefix() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryAutolinkReferencesAutolinkReference) string { return v.KeyPrefix }).(pulumi.StringOutput) +} + +// Target url template. +func (o GetRepositoryAutolinkReferencesAutolinkReferenceOutput) TargetUrlTemplate() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryAutolinkReferencesAutolinkReference) string { return v.TargetUrlTemplate }).(pulumi.StringOutput) +} + +type GetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput struct{ *pulumi.OutputState } + +func (GetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryAutolinkReferencesAutolinkReference)(nil)).Elem() +} + +func (o GetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput) ToGetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput() GetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput { + return o +} + +func (o GetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput) ToGetRepositoryAutolinkReferencesAutolinkReferenceArrayOutputWithContext(ctx context.Context) GetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput { + return o +} + +func (o GetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput) Index(i pulumi.IntInput) GetRepositoryAutolinkReferencesAutolinkReferenceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryAutolinkReferencesAutolinkReference { + return vs[0].([]GetRepositoryAutolinkReferencesAutolinkReference)[vs[1].(int)] + }).(GetRepositoryAutolinkReferencesAutolinkReferenceOutput) +} + +type GetRepositoryBranchesBranch struct { + // Name of the branch. + Name string `pulumi:"name"` + // Whether the branch is protected. + Protected bool `pulumi:"protected"` +} + +// GetRepositoryBranchesBranchInput is an input type that accepts GetRepositoryBranchesBranchArgs and GetRepositoryBranchesBranchOutput values. +// You can construct a concrete instance of `GetRepositoryBranchesBranchInput` via: +// +// GetRepositoryBranchesBranchArgs{...} +type GetRepositoryBranchesBranchInput interface { + pulumi.Input + + ToGetRepositoryBranchesBranchOutput() GetRepositoryBranchesBranchOutput + ToGetRepositoryBranchesBranchOutputWithContext(context.Context) GetRepositoryBranchesBranchOutput +} + +type GetRepositoryBranchesBranchArgs struct { + // Name of the branch. + Name pulumi.StringInput `pulumi:"name"` + // Whether the branch is protected. + Protected pulumi.BoolInput `pulumi:"protected"` +} + +func (GetRepositoryBranchesBranchArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryBranchesBranch)(nil)).Elem() +} + +func (i GetRepositoryBranchesBranchArgs) ToGetRepositoryBranchesBranchOutput() GetRepositoryBranchesBranchOutput { + return i.ToGetRepositoryBranchesBranchOutputWithContext(context.Background()) +} + +func (i GetRepositoryBranchesBranchArgs) ToGetRepositoryBranchesBranchOutputWithContext(ctx context.Context) GetRepositoryBranchesBranchOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryBranchesBranchOutput) +} + +// GetRepositoryBranchesBranchArrayInput is an input type that accepts GetRepositoryBranchesBranchArray and GetRepositoryBranchesBranchArrayOutput values. +// You can construct a concrete instance of `GetRepositoryBranchesBranchArrayInput` via: +// +// GetRepositoryBranchesBranchArray{ GetRepositoryBranchesBranchArgs{...} } +type GetRepositoryBranchesBranchArrayInput interface { + pulumi.Input + + ToGetRepositoryBranchesBranchArrayOutput() GetRepositoryBranchesBranchArrayOutput + ToGetRepositoryBranchesBranchArrayOutputWithContext(context.Context) GetRepositoryBranchesBranchArrayOutput +} + +type GetRepositoryBranchesBranchArray []GetRepositoryBranchesBranchInput + +func (GetRepositoryBranchesBranchArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryBranchesBranch)(nil)).Elem() +} + +func (i GetRepositoryBranchesBranchArray) ToGetRepositoryBranchesBranchArrayOutput() GetRepositoryBranchesBranchArrayOutput { + return i.ToGetRepositoryBranchesBranchArrayOutputWithContext(context.Background()) +} + +func (i GetRepositoryBranchesBranchArray) ToGetRepositoryBranchesBranchArrayOutputWithContext(ctx context.Context) GetRepositoryBranchesBranchArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryBranchesBranchArrayOutput) +} + +type GetRepositoryBranchesBranchOutput struct{ *pulumi.OutputState } + +func (GetRepositoryBranchesBranchOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryBranchesBranch)(nil)).Elem() +} + +func (o GetRepositoryBranchesBranchOutput) ToGetRepositoryBranchesBranchOutput() GetRepositoryBranchesBranchOutput { + return o +} + +func (o GetRepositoryBranchesBranchOutput) ToGetRepositoryBranchesBranchOutputWithContext(ctx context.Context) GetRepositoryBranchesBranchOutput { + return o +} + +// Name of the branch. +func (o GetRepositoryBranchesBranchOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryBranchesBranch) string { return v.Name }).(pulumi.StringOutput) +} + +// Whether the branch is protected. +func (o GetRepositoryBranchesBranchOutput) Protected() pulumi.BoolOutput { + return o.ApplyT(func(v GetRepositoryBranchesBranch) bool { return v.Protected }).(pulumi.BoolOutput) +} + +type GetRepositoryBranchesBranchArrayOutput struct{ *pulumi.OutputState } + +func (GetRepositoryBranchesBranchArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryBranchesBranch)(nil)).Elem() +} + +func (o GetRepositoryBranchesBranchArrayOutput) ToGetRepositoryBranchesBranchArrayOutput() GetRepositoryBranchesBranchArrayOutput { + return o +} + +func (o GetRepositoryBranchesBranchArrayOutput) ToGetRepositoryBranchesBranchArrayOutputWithContext(ctx context.Context) GetRepositoryBranchesBranchArrayOutput { + return o +} + +func (o GetRepositoryBranchesBranchArrayOutput) Index(i pulumi.IntInput) GetRepositoryBranchesBranchOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryBranchesBranch { + return vs[0].([]GetRepositoryBranchesBranch)[vs[1].(int)] + }).(GetRepositoryBranchesBranchOutput) +} + +type GetRepositoryCustomPropertiesProperty struct { + // Name of the property + PropertyName string `pulumi:"propertyName"` + // Value of the property + PropertyValues []string `pulumi:"propertyValues"` +} + +// GetRepositoryCustomPropertiesPropertyInput is an input type that accepts GetRepositoryCustomPropertiesPropertyArgs and GetRepositoryCustomPropertiesPropertyOutput values. +// You can construct a concrete instance of `GetRepositoryCustomPropertiesPropertyInput` via: +// +// GetRepositoryCustomPropertiesPropertyArgs{...} +type GetRepositoryCustomPropertiesPropertyInput interface { + pulumi.Input + + ToGetRepositoryCustomPropertiesPropertyOutput() GetRepositoryCustomPropertiesPropertyOutput + ToGetRepositoryCustomPropertiesPropertyOutputWithContext(context.Context) GetRepositoryCustomPropertiesPropertyOutput +} + +type GetRepositoryCustomPropertiesPropertyArgs struct { + // Name of the property + PropertyName pulumi.StringInput `pulumi:"propertyName"` + // Value of the property + PropertyValues pulumi.StringArrayInput `pulumi:"propertyValues"` +} + +func (GetRepositoryCustomPropertiesPropertyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryCustomPropertiesProperty)(nil)).Elem() +} + +func (i GetRepositoryCustomPropertiesPropertyArgs) ToGetRepositoryCustomPropertiesPropertyOutput() GetRepositoryCustomPropertiesPropertyOutput { + return i.ToGetRepositoryCustomPropertiesPropertyOutputWithContext(context.Background()) +} + +func (i GetRepositoryCustomPropertiesPropertyArgs) ToGetRepositoryCustomPropertiesPropertyOutputWithContext(ctx context.Context) GetRepositoryCustomPropertiesPropertyOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryCustomPropertiesPropertyOutput) +} + +// GetRepositoryCustomPropertiesPropertyArrayInput is an input type that accepts GetRepositoryCustomPropertiesPropertyArray and GetRepositoryCustomPropertiesPropertyArrayOutput values. +// You can construct a concrete instance of `GetRepositoryCustomPropertiesPropertyArrayInput` via: +// +// GetRepositoryCustomPropertiesPropertyArray{ GetRepositoryCustomPropertiesPropertyArgs{...} } +type GetRepositoryCustomPropertiesPropertyArrayInput interface { + pulumi.Input + + ToGetRepositoryCustomPropertiesPropertyArrayOutput() GetRepositoryCustomPropertiesPropertyArrayOutput + ToGetRepositoryCustomPropertiesPropertyArrayOutputWithContext(context.Context) GetRepositoryCustomPropertiesPropertyArrayOutput +} + +type GetRepositoryCustomPropertiesPropertyArray []GetRepositoryCustomPropertiesPropertyInput + +func (GetRepositoryCustomPropertiesPropertyArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryCustomPropertiesProperty)(nil)).Elem() +} + +func (i GetRepositoryCustomPropertiesPropertyArray) ToGetRepositoryCustomPropertiesPropertyArrayOutput() GetRepositoryCustomPropertiesPropertyArrayOutput { + return i.ToGetRepositoryCustomPropertiesPropertyArrayOutputWithContext(context.Background()) +} + +func (i GetRepositoryCustomPropertiesPropertyArray) ToGetRepositoryCustomPropertiesPropertyArrayOutputWithContext(ctx context.Context) GetRepositoryCustomPropertiesPropertyArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryCustomPropertiesPropertyArrayOutput) +} + +type GetRepositoryCustomPropertiesPropertyOutput struct{ *pulumi.OutputState } + +func (GetRepositoryCustomPropertiesPropertyOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryCustomPropertiesProperty)(nil)).Elem() +} + +func (o GetRepositoryCustomPropertiesPropertyOutput) ToGetRepositoryCustomPropertiesPropertyOutput() GetRepositoryCustomPropertiesPropertyOutput { + return o +} + +func (o GetRepositoryCustomPropertiesPropertyOutput) ToGetRepositoryCustomPropertiesPropertyOutputWithContext(ctx context.Context) GetRepositoryCustomPropertiesPropertyOutput { + return o +} + +// Name of the property +func (o GetRepositoryCustomPropertiesPropertyOutput) PropertyName() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryCustomPropertiesProperty) string { return v.PropertyName }).(pulumi.StringOutput) +} + +// Value of the property +func (o GetRepositoryCustomPropertiesPropertyOutput) PropertyValues() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetRepositoryCustomPropertiesProperty) []string { return v.PropertyValues }).(pulumi.StringArrayOutput) +} + +type GetRepositoryCustomPropertiesPropertyArrayOutput struct{ *pulumi.OutputState } + +func (GetRepositoryCustomPropertiesPropertyArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryCustomPropertiesProperty)(nil)).Elem() +} + +func (o GetRepositoryCustomPropertiesPropertyArrayOutput) ToGetRepositoryCustomPropertiesPropertyArrayOutput() GetRepositoryCustomPropertiesPropertyArrayOutput { + return o +} + +func (o GetRepositoryCustomPropertiesPropertyArrayOutput) ToGetRepositoryCustomPropertiesPropertyArrayOutputWithContext(ctx context.Context) GetRepositoryCustomPropertiesPropertyArrayOutput { + return o +} + +func (o GetRepositoryCustomPropertiesPropertyArrayOutput) Index(i pulumi.IntInput) GetRepositoryCustomPropertiesPropertyOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryCustomPropertiesProperty { + return vs[0].([]GetRepositoryCustomPropertiesProperty)[vs[1].(int)] + }).(GetRepositoryCustomPropertiesPropertyOutput) +} + +type GetRepositoryDeployKeysKey struct { + // Key id + Id int `pulumi:"id"` + // Key itself + Key string `pulumi:"key"` + // Key title + Title string `pulumi:"title"` + // `true` if the key was verified. + Verified bool `pulumi:"verified"` +} + +// GetRepositoryDeployKeysKeyInput is an input type that accepts GetRepositoryDeployKeysKeyArgs and GetRepositoryDeployKeysKeyOutput values. +// You can construct a concrete instance of `GetRepositoryDeployKeysKeyInput` via: +// +// GetRepositoryDeployKeysKeyArgs{...} +type GetRepositoryDeployKeysKeyInput interface { + pulumi.Input + + ToGetRepositoryDeployKeysKeyOutput() GetRepositoryDeployKeysKeyOutput + ToGetRepositoryDeployKeysKeyOutputWithContext(context.Context) GetRepositoryDeployKeysKeyOutput +} + +type GetRepositoryDeployKeysKeyArgs struct { + // Key id + Id pulumi.IntInput `pulumi:"id"` + // Key itself + Key pulumi.StringInput `pulumi:"key"` + // Key title + Title pulumi.StringInput `pulumi:"title"` + // `true` if the key was verified. + Verified pulumi.BoolInput `pulumi:"verified"` +} + +func (GetRepositoryDeployKeysKeyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryDeployKeysKey)(nil)).Elem() +} + +func (i GetRepositoryDeployKeysKeyArgs) ToGetRepositoryDeployKeysKeyOutput() GetRepositoryDeployKeysKeyOutput { + return i.ToGetRepositoryDeployKeysKeyOutputWithContext(context.Background()) +} + +func (i GetRepositoryDeployKeysKeyArgs) ToGetRepositoryDeployKeysKeyOutputWithContext(ctx context.Context) GetRepositoryDeployKeysKeyOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryDeployKeysKeyOutput) +} + +// GetRepositoryDeployKeysKeyArrayInput is an input type that accepts GetRepositoryDeployKeysKeyArray and GetRepositoryDeployKeysKeyArrayOutput values. +// You can construct a concrete instance of `GetRepositoryDeployKeysKeyArrayInput` via: +// +// GetRepositoryDeployKeysKeyArray{ GetRepositoryDeployKeysKeyArgs{...} } +type GetRepositoryDeployKeysKeyArrayInput interface { + pulumi.Input + + ToGetRepositoryDeployKeysKeyArrayOutput() GetRepositoryDeployKeysKeyArrayOutput + ToGetRepositoryDeployKeysKeyArrayOutputWithContext(context.Context) GetRepositoryDeployKeysKeyArrayOutput +} + +type GetRepositoryDeployKeysKeyArray []GetRepositoryDeployKeysKeyInput + +func (GetRepositoryDeployKeysKeyArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryDeployKeysKey)(nil)).Elem() +} + +func (i GetRepositoryDeployKeysKeyArray) ToGetRepositoryDeployKeysKeyArrayOutput() GetRepositoryDeployKeysKeyArrayOutput { + return i.ToGetRepositoryDeployKeysKeyArrayOutputWithContext(context.Background()) +} + +func (i GetRepositoryDeployKeysKeyArray) ToGetRepositoryDeployKeysKeyArrayOutputWithContext(ctx context.Context) GetRepositoryDeployKeysKeyArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryDeployKeysKeyArrayOutput) +} + +type GetRepositoryDeployKeysKeyOutput struct{ *pulumi.OutputState } + +func (GetRepositoryDeployKeysKeyOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryDeployKeysKey)(nil)).Elem() +} + +func (o GetRepositoryDeployKeysKeyOutput) ToGetRepositoryDeployKeysKeyOutput() GetRepositoryDeployKeysKeyOutput { + return o +} + +func (o GetRepositoryDeployKeysKeyOutput) ToGetRepositoryDeployKeysKeyOutputWithContext(ctx context.Context) GetRepositoryDeployKeysKeyOutput { + return o +} + +// Key id +func (o GetRepositoryDeployKeysKeyOutput) Id() pulumi.IntOutput { + return o.ApplyT(func(v GetRepositoryDeployKeysKey) int { return v.Id }).(pulumi.IntOutput) +} + +// Key itself +func (o GetRepositoryDeployKeysKeyOutput) Key() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryDeployKeysKey) string { return v.Key }).(pulumi.StringOutput) +} + +// Key title +func (o GetRepositoryDeployKeysKeyOutput) Title() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryDeployKeysKey) string { return v.Title }).(pulumi.StringOutput) +} + +// `true` if the key was verified. +func (o GetRepositoryDeployKeysKeyOutput) Verified() pulumi.BoolOutput { + return o.ApplyT(func(v GetRepositoryDeployKeysKey) bool { return v.Verified }).(pulumi.BoolOutput) +} + +type GetRepositoryDeployKeysKeyArrayOutput struct{ *pulumi.OutputState } + +func (GetRepositoryDeployKeysKeyArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryDeployKeysKey)(nil)).Elem() +} + +func (o GetRepositoryDeployKeysKeyArrayOutput) ToGetRepositoryDeployKeysKeyArrayOutput() GetRepositoryDeployKeysKeyArrayOutput { + return o +} + +func (o GetRepositoryDeployKeysKeyArrayOutput) ToGetRepositoryDeployKeysKeyArrayOutputWithContext(ctx context.Context) GetRepositoryDeployKeysKeyArrayOutput { + return o +} + +func (o GetRepositoryDeployKeysKeyArrayOutput) Index(i pulumi.IntInput) GetRepositoryDeployKeysKeyOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryDeployKeysKey { + return vs[0].([]GetRepositoryDeployKeysKey)[vs[1].(int)] + }).(GetRepositoryDeployKeysKeyOutput) +} + +type GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicy struct { + // Id of the policy. + Id string `pulumi:"id"` + // The name pattern that branches must match in order to deploy to the environment. + Name string `pulumi:"name"` +} + +// GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyInput is an input type that accepts GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArgs and GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput values. +// You can construct a concrete instance of `GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyInput` via: +// +// GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArgs{...} +type GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyInput interface { + pulumi.Input + + ToGetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput() GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput + ToGetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutputWithContext(context.Context) GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput +} + +type GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArgs struct { + // Id of the policy. + Id pulumi.StringInput `pulumi:"id"` + // The name pattern that branches must match in order to deploy to the environment. + Name pulumi.StringInput `pulumi:"name"` +} + +func (GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicy)(nil)).Elem() +} + +func (i GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArgs) ToGetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput() GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput { + return i.ToGetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutputWithContext(context.Background()) +} + +func (i GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArgs) ToGetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutputWithContext(ctx context.Context) GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput) +} + +// GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayInput is an input type that accepts GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArray and GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput values. +// You can construct a concrete instance of `GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayInput` via: +// +// GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArray{ GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArgs{...} } +type GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayInput interface { + pulumi.Input + + ToGetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput() GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput + ToGetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutputWithContext(context.Context) GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput +} + +type GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArray []GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyInput + +func (GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicy)(nil)).Elem() +} + +func (i GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArray) ToGetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput() GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput { + return i.ToGetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutputWithContext(context.Background()) +} + +func (i GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArray) ToGetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutputWithContext(ctx context.Context) GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput) +} + +type GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput struct{ *pulumi.OutputState } + +func (GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicy)(nil)).Elem() +} + +func (o GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput) ToGetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput() GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput { + return o +} + +func (o GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput) ToGetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutputWithContext(ctx context.Context) GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput { + return o +} + +// Id of the policy. +func (o GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicy) string { return v.Id }).(pulumi.StringOutput) +} + +// The name pattern that branches must match in order to deploy to the environment. +func (o GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicy) string { return v.Name }).(pulumi.StringOutput) +} + +type GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput struct{ *pulumi.OutputState } + +func (GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicy)(nil)).Elem() +} + +func (o GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput) ToGetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput() GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput { + return o +} + +func (o GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput) ToGetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutputWithContext(ctx context.Context) GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput { + return o +} + +func (o GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput) Index(i pulumi.IntInput) GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicy { + return vs[0].([]GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicy)[vs[1].(int)] + }).(GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput) +} + +type GetRepositoryEnvironmentDeploymentPoliciesPolicy struct { + // The pattern that branch or tag names must match in order to deploy to the environment. + Pattern string `pulumi:"pattern"` + // Type of the policy; this could be `branch` or `tag`. + Type string `pulumi:"type"` +} + +// GetRepositoryEnvironmentDeploymentPoliciesPolicyInput is an input type that accepts GetRepositoryEnvironmentDeploymentPoliciesPolicyArgs and GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput values. +// You can construct a concrete instance of `GetRepositoryEnvironmentDeploymentPoliciesPolicyInput` via: +// +// GetRepositoryEnvironmentDeploymentPoliciesPolicyArgs{...} +type GetRepositoryEnvironmentDeploymentPoliciesPolicyInput interface { + pulumi.Input + + ToGetRepositoryEnvironmentDeploymentPoliciesPolicyOutput() GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput + ToGetRepositoryEnvironmentDeploymentPoliciesPolicyOutputWithContext(context.Context) GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput +} + +type GetRepositoryEnvironmentDeploymentPoliciesPolicyArgs struct { + // The pattern that branch or tag names must match in order to deploy to the environment. + Pattern pulumi.StringInput `pulumi:"pattern"` + // Type of the policy; this could be `branch` or `tag`. + Type pulumi.StringInput `pulumi:"type"` +} + +func (GetRepositoryEnvironmentDeploymentPoliciesPolicyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryEnvironmentDeploymentPoliciesPolicy)(nil)).Elem() +} + +func (i GetRepositoryEnvironmentDeploymentPoliciesPolicyArgs) ToGetRepositoryEnvironmentDeploymentPoliciesPolicyOutput() GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput { + return i.ToGetRepositoryEnvironmentDeploymentPoliciesPolicyOutputWithContext(context.Background()) +} + +func (i GetRepositoryEnvironmentDeploymentPoliciesPolicyArgs) ToGetRepositoryEnvironmentDeploymentPoliciesPolicyOutputWithContext(ctx context.Context) GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput) +} + +// GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayInput is an input type that accepts GetRepositoryEnvironmentDeploymentPoliciesPolicyArray and GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput values. +// You can construct a concrete instance of `GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayInput` via: +// +// GetRepositoryEnvironmentDeploymentPoliciesPolicyArray{ GetRepositoryEnvironmentDeploymentPoliciesPolicyArgs{...} } +type GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayInput interface { + pulumi.Input + + ToGetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput() GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput + ToGetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutputWithContext(context.Context) GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput +} + +type GetRepositoryEnvironmentDeploymentPoliciesPolicyArray []GetRepositoryEnvironmentDeploymentPoliciesPolicyInput + +func (GetRepositoryEnvironmentDeploymentPoliciesPolicyArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryEnvironmentDeploymentPoliciesPolicy)(nil)).Elem() +} + +func (i GetRepositoryEnvironmentDeploymentPoliciesPolicyArray) ToGetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput() GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput { + return i.ToGetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutputWithContext(context.Background()) +} + +func (i GetRepositoryEnvironmentDeploymentPoliciesPolicyArray) ToGetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutputWithContext(ctx context.Context) GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput) +} + +type GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput struct{ *pulumi.OutputState } + +func (GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryEnvironmentDeploymentPoliciesPolicy)(nil)).Elem() +} + +func (o GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput) ToGetRepositoryEnvironmentDeploymentPoliciesPolicyOutput() GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput { + return o +} + +func (o GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput) ToGetRepositoryEnvironmentDeploymentPoliciesPolicyOutputWithContext(ctx context.Context) GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput { + return o +} + +// The pattern that branch or tag names must match in order to deploy to the environment. +func (o GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput) Pattern() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryEnvironmentDeploymentPoliciesPolicy) string { return v.Pattern }).(pulumi.StringOutput) +} + +// Type of the policy; this could be `branch` or `tag`. +func (o GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryEnvironmentDeploymentPoliciesPolicy) string { return v.Type }).(pulumi.StringOutput) +} + +type GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput struct{ *pulumi.OutputState } + +func (GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryEnvironmentDeploymentPoliciesPolicy)(nil)).Elem() +} + +func (o GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput) ToGetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput() GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput { + return o +} + +func (o GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput) ToGetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutputWithContext(ctx context.Context) GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput { + return o +} + +func (o GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput) Index(i pulumi.IntInput) GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryEnvironmentDeploymentPoliciesPolicy { + return vs[0].([]GetRepositoryEnvironmentDeploymentPoliciesPolicy)[vs[1].(int)] + }).(GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput) +} + +type GetRepositoryEnvironmentsEnvironment struct { + // Environment name. + Name string `pulumi:"name"` + // Environment node id. + NodeId string `pulumi:"nodeId"` +} + +// GetRepositoryEnvironmentsEnvironmentInput is an input type that accepts GetRepositoryEnvironmentsEnvironmentArgs and GetRepositoryEnvironmentsEnvironmentOutput values. +// You can construct a concrete instance of `GetRepositoryEnvironmentsEnvironmentInput` via: +// +// GetRepositoryEnvironmentsEnvironmentArgs{...} +type GetRepositoryEnvironmentsEnvironmentInput interface { + pulumi.Input + + ToGetRepositoryEnvironmentsEnvironmentOutput() GetRepositoryEnvironmentsEnvironmentOutput + ToGetRepositoryEnvironmentsEnvironmentOutputWithContext(context.Context) GetRepositoryEnvironmentsEnvironmentOutput +} + +type GetRepositoryEnvironmentsEnvironmentArgs struct { + // Environment name. + Name pulumi.StringInput `pulumi:"name"` + // Environment node id. + NodeId pulumi.StringInput `pulumi:"nodeId"` +} + +func (GetRepositoryEnvironmentsEnvironmentArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryEnvironmentsEnvironment)(nil)).Elem() +} + +func (i GetRepositoryEnvironmentsEnvironmentArgs) ToGetRepositoryEnvironmentsEnvironmentOutput() GetRepositoryEnvironmentsEnvironmentOutput { + return i.ToGetRepositoryEnvironmentsEnvironmentOutputWithContext(context.Background()) +} + +func (i GetRepositoryEnvironmentsEnvironmentArgs) ToGetRepositoryEnvironmentsEnvironmentOutputWithContext(ctx context.Context) GetRepositoryEnvironmentsEnvironmentOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryEnvironmentsEnvironmentOutput) +} + +// GetRepositoryEnvironmentsEnvironmentArrayInput is an input type that accepts GetRepositoryEnvironmentsEnvironmentArray and GetRepositoryEnvironmentsEnvironmentArrayOutput values. +// You can construct a concrete instance of `GetRepositoryEnvironmentsEnvironmentArrayInput` via: +// +// GetRepositoryEnvironmentsEnvironmentArray{ GetRepositoryEnvironmentsEnvironmentArgs{...} } +type GetRepositoryEnvironmentsEnvironmentArrayInput interface { + pulumi.Input + + ToGetRepositoryEnvironmentsEnvironmentArrayOutput() GetRepositoryEnvironmentsEnvironmentArrayOutput + ToGetRepositoryEnvironmentsEnvironmentArrayOutputWithContext(context.Context) GetRepositoryEnvironmentsEnvironmentArrayOutput +} + +type GetRepositoryEnvironmentsEnvironmentArray []GetRepositoryEnvironmentsEnvironmentInput + +func (GetRepositoryEnvironmentsEnvironmentArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryEnvironmentsEnvironment)(nil)).Elem() +} + +func (i GetRepositoryEnvironmentsEnvironmentArray) ToGetRepositoryEnvironmentsEnvironmentArrayOutput() GetRepositoryEnvironmentsEnvironmentArrayOutput { + return i.ToGetRepositoryEnvironmentsEnvironmentArrayOutputWithContext(context.Background()) +} + +func (i GetRepositoryEnvironmentsEnvironmentArray) ToGetRepositoryEnvironmentsEnvironmentArrayOutputWithContext(ctx context.Context) GetRepositoryEnvironmentsEnvironmentArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryEnvironmentsEnvironmentArrayOutput) +} + +type GetRepositoryEnvironmentsEnvironmentOutput struct{ *pulumi.OutputState } + +func (GetRepositoryEnvironmentsEnvironmentOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryEnvironmentsEnvironment)(nil)).Elem() +} + +func (o GetRepositoryEnvironmentsEnvironmentOutput) ToGetRepositoryEnvironmentsEnvironmentOutput() GetRepositoryEnvironmentsEnvironmentOutput { + return o +} + +func (o GetRepositoryEnvironmentsEnvironmentOutput) ToGetRepositoryEnvironmentsEnvironmentOutputWithContext(ctx context.Context) GetRepositoryEnvironmentsEnvironmentOutput { + return o +} + +// Environment name. +func (o GetRepositoryEnvironmentsEnvironmentOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryEnvironmentsEnvironment) string { return v.Name }).(pulumi.StringOutput) +} + +// Environment node id. +func (o GetRepositoryEnvironmentsEnvironmentOutput) NodeId() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryEnvironmentsEnvironment) string { return v.NodeId }).(pulumi.StringOutput) +} + +type GetRepositoryEnvironmentsEnvironmentArrayOutput struct{ *pulumi.OutputState } + +func (GetRepositoryEnvironmentsEnvironmentArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryEnvironmentsEnvironment)(nil)).Elem() +} + +func (o GetRepositoryEnvironmentsEnvironmentArrayOutput) ToGetRepositoryEnvironmentsEnvironmentArrayOutput() GetRepositoryEnvironmentsEnvironmentArrayOutput { + return o +} + +func (o GetRepositoryEnvironmentsEnvironmentArrayOutput) ToGetRepositoryEnvironmentsEnvironmentArrayOutputWithContext(ctx context.Context) GetRepositoryEnvironmentsEnvironmentArrayOutput { + return o +} + +func (o GetRepositoryEnvironmentsEnvironmentArrayOutput) Index(i pulumi.IntInput) GetRepositoryEnvironmentsEnvironmentOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryEnvironmentsEnvironment { + return vs[0].([]GetRepositoryEnvironmentsEnvironment)[vs[1].(int)] + }).(GetRepositoryEnvironmentsEnvironmentOutput) +} + +type GetRepositoryPage struct { + BuildType string `pulumi:"buildType"` + Cname string `pulumi:"cname"` + Custom404 bool `pulumi:"custom404"` + // The URL to view the license details on GitHub. + HtmlUrl string `pulumi:"htmlUrl"` + Sources []GetRepositoryPageSource `pulumi:"sources"` + Status string `pulumi:"status"` + // The URL to access information about the license on GitHub. + Url string `pulumi:"url"` +} + +// GetRepositoryPageInput is an input type that accepts GetRepositoryPageArgs and GetRepositoryPageOutput values. +// You can construct a concrete instance of `GetRepositoryPageInput` via: +// +// GetRepositoryPageArgs{...} +type GetRepositoryPageInput interface { + pulumi.Input + + ToGetRepositoryPageOutput() GetRepositoryPageOutput + ToGetRepositoryPageOutputWithContext(context.Context) GetRepositoryPageOutput +} + +type GetRepositoryPageArgs struct { + BuildType pulumi.StringInput `pulumi:"buildType"` + Cname pulumi.StringInput `pulumi:"cname"` + Custom404 pulumi.BoolInput `pulumi:"custom404"` + // The URL to view the license details on GitHub. + HtmlUrl pulumi.StringInput `pulumi:"htmlUrl"` + Sources GetRepositoryPageSourceArrayInput `pulumi:"sources"` + Status pulumi.StringInput `pulumi:"status"` + // The URL to access information about the license on GitHub. + Url pulumi.StringInput `pulumi:"url"` +} + +func (GetRepositoryPageArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryPage)(nil)).Elem() +} + +func (i GetRepositoryPageArgs) ToGetRepositoryPageOutput() GetRepositoryPageOutput { + return i.ToGetRepositoryPageOutputWithContext(context.Background()) +} + +func (i GetRepositoryPageArgs) ToGetRepositoryPageOutputWithContext(ctx context.Context) GetRepositoryPageOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryPageOutput) +} + +// GetRepositoryPageArrayInput is an input type that accepts GetRepositoryPageArray and GetRepositoryPageArrayOutput values. +// You can construct a concrete instance of `GetRepositoryPageArrayInput` via: +// +// GetRepositoryPageArray{ GetRepositoryPageArgs{...} } +type GetRepositoryPageArrayInput interface { + pulumi.Input + + ToGetRepositoryPageArrayOutput() GetRepositoryPageArrayOutput + ToGetRepositoryPageArrayOutputWithContext(context.Context) GetRepositoryPageArrayOutput +} + +type GetRepositoryPageArray []GetRepositoryPageInput + +func (GetRepositoryPageArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryPage)(nil)).Elem() +} + +func (i GetRepositoryPageArray) ToGetRepositoryPageArrayOutput() GetRepositoryPageArrayOutput { + return i.ToGetRepositoryPageArrayOutputWithContext(context.Background()) +} + +func (i GetRepositoryPageArray) ToGetRepositoryPageArrayOutputWithContext(ctx context.Context) GetRepositoryPageArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryPageArrayOutput) +} + +type GetRepositoryPageOutput struct{ *pulumi.OutputState } + +func (GetRepositoryPageOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryPage)(nil)).Elem() +} + +func (o GetRepositoryPageOutput) ToGetRepositoryPageOutput() GetRepositoryPageOutput { + return o +} + +func (o GetRepositoryPageOutput) ToGetRepositoryPageOutputWithContext(ctx context.Context) GetRepositoryPageOutput { + return o +} + +func (o GetRepositoryPageOutput) BuildType() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPage) string { return v.BuildType }).(pulumi.StringOutput) +} + +func (o GetRepositoryPageOutput) Cname() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPage) string { return v.Cname }).(pulumi.StringOutput) +} + +func (o GetRepositoryPageOutput) Custom404() pulumi.BoolOutput { + return o.ApplyT(func(v GetRepositoryPage) bool { return v.Custom404 }).(pulumi.BoolOutput) +} + +// The URL to view the license details on GitHub. +func (o GetRepositoryPageOutput) HtmlUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPage) string { return v.HtmlUrl }).(pulumi.StringOutput) +} + +func (o GetRepositoryPageOutput) Sources() GetRepositoryPageSourceArrayOutput { + return o.ApplyT(func(v GetRepositoryPage) []GetRepositoryPageSource { return v.Sources }).(GetRepositoryPageSourceArrayOutput) +} + +func (o GetRepositoryPageOutput) Status() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPage) string { return v.Status }).(pulumi.StringOutput) +} + +// The URL to access information about the license on GitHub. +func (o GetRepositoryPageOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPage) string { return v.Url }).(pulumi.StringOutput) +} + +type GetRepositoryPageArrayOutput struct{ *pulumi.OutputState } + +func (GetRepositoryPageArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryPage)(nil)).Elem() +} + +func (o GetRepositoryPageArrayOutput) ToGetRepositoryPageArrayOutput() GetRepositoryPageArrayOutput { + return o +} + +func (o GetRepositoryPageArrayOutput) ToGetRepositoryPageArrayOutputWithContext(ctx context.Context) GetRepositoryPageArrayOutput { + return o +} + +func (o GetRepositoryPageArrayOutput) Index(i pulumi.IntInput) GetRepositoryPageOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryPage { + return vs[0].([]GetRepositoryPage)[vs[1].(int)] + }).(GetRepositoryPageOutput) +} + +type GetRepositoryPageSource struct { + Branch string `pulumi:"branch"` + // The path to the license file within the repository. + Path string `pulumi:"path"` +} + +// GetRepositoryPageSourceInput is an input type that accepts GetRepositoryPageSourceArgs and GetRepositoryPageSourceOutput values. +// You can construct a concrete instance of `GetRepositoryPageSourceInput` via: +// +// GetRepositoryPageSourceArgs{...} +type GetRepositoryPageSourceInput interface { + pulumi.Input + + ToGetRepositoryPageSourceOutput() GetRepositoryPageSourceOutput + ToGetRepositoryPageSourceOutputWithContext(context.Context) GetRepositoryPageSourceOutput +} + +type GetRepositoryPageSourceArgs struct { + Branch pulumi.StringInput `pulumi:"branch"` + // The path to the license file within the repository. + Path pulumi.StringInput `pulumi:"path"` +} + +func (GetRepositoryPageSourceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryPageSource)(nil)).Elem() +} + +func (i GetRepositoryPageSourceArgs) ToGetRepositoryPageSourceOutput() GetRepositoryPageSourceOutput { + return i.ToGetRepositoryPageSourceOutputWithContext(context.Background()) +} + +func (i GetRepositoryPageSourceArgs) ToGetRepositoryPageSourceOutputWithContext(ctx context.Context) GetRepositoryPageSourceOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryPageSourceOutput) +} + +// GetRepositoryPageSourceArrayInput is an input type that accepts GetRepositoryPageSourceArray and GetRepositoryPageSourceArrayOutput values. +// You can construct a concrete instance of `GetRepositoryPageSourceArrayInput` via: +// +// GetRepositoryPageSourceArray{ GetRepositoryPageSourceArgs{...} } +type GetRepositoryPageSourceArrayInput interface { + pulumi.Input + + ToGetRepositoryPageSourceArrayOutput() GetRepositoryPageSourceArrayOutput + ToGetRepositoryPageSourceArrayOutputWithContext(context.Context) GetRepositoryPageSourceArrayOutput +} + +type GetRepositoryPageSourceArray []GetRepositoryPageSourceInput + +func (GetRepositoryPageSourceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryPageSource)(nil)).Elem() +} + +func (i GetRepositoryPageSourceArray) ToGetRepositoryPageSourceArrayOutput() GetRepositoryPageSourceArrayOutput { + return i.ToGetRepositoryPageSourceArrayOutputWithContext(context.Background()) +} + +func (i GetRepositoryPageSourceArray) ToGetRepositoryPageSourceArrayOutputWithContext(ctx context.Context) GetRepositoryPageSourceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryPageSourceArrayOutput) +} + +type GetRepositoryPageSourceOutput struct{ *pulumi.OutputState } + +func (GetRepositoryPageSourceOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryPageSource)(nil)).Elem() +} + +func (o GetRepositoryPageSourceOutput) ToGetRepositoryPageSourceOutput() GetRepositoryPageSourceOutput { + return o +} + +func (o GetRepositoryPageSourceOutput) ToGetRepositoryPageSourceOutputWithContext(ctx context.Context) GetRepositoryPageSourceOutput { + return o +} + +func (o GetRepositoryPageSourceOutput) Branch() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPageSource) string { return v.Branch }).(pulumi.StringOutput) +} + +// The path to the license file within the repository. +func (o GetRepositoryPageSourceOutput) Path() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPageSource) string { return v.Path }).(pulumi.StringOutput) +} + +type GetRepositoryPageSourceArrayOutput struct{ *pulumi.OutputState } + +func (GetRepositoryPageSourceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryPageSource)(nil)).Elem() +} + +func (o GetRepositoryPageSourceArrayOutput) ToGetRepositoryPageSourceArrayOutput() GetRepositoryPageSourceArrayOutput { + return o +} + +func (o GetRepositoryPageSourceArrayOutput) ToGetRepositoryPageSourceArrayOutputWithContext(ctx context.Context) GetRepositoryPageSourceArrayOutput { + return o +} + +func (o GetRepositoryPageSourceArrayOutput) Index(i pulumi.IntInput) GetRepositoryPageSourceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryPageSource { + return vs[0].([]GetRepositoryPageSource)[vs[1].(int)] + }).(GetRepositoryPageSourceOutput) +} + +type GetRepositoryPagesSource struct { + // The repository branch used to publish the site's source files. + Branch string `pulumi:"branch"` + // The repository directory from which the site publishes. + Path string `pulumi:"path"` +} + +// GetRepositoryPagesSourceInput is an input type that accepts GetRepositoryPagesSourceArgs and GetRepositoryPagesSourceOutput values. +// You can construct a concrete instance of `GetRepositoryPagesSourceInput` via: +// +// GetRepositoryPagesSourceArgs{...} +type GetRepositoryPagesSourceInput interface { + pulumi.Input + + ToGetRepositoryPagesSourceOutput() GetRepositoryPagesSourceOutput + ToGetRepositoryPagesSourceOutputWithContext(context.Context) GetRepositoryPagesSourceOutput +} + +type GetRepositoryPagesSourceArgs struct { + // The repository branch used to publish the site's source files. + Branch pulumi.StringInput `pulumi:"branch"` + // The repository directory from which the site publishes. + Path pulumi.StringInput `pulumi:"path"` +} + +func (GetRepositoryPagesSourceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryPagesSource)(nil)).Elem() +} + +func (i GetRepositoryPagesSourceArgs) ToGetRepositoryPagesSourceOutput() GetRepositoryPagesSourceOutput { + return i.ToGetRepositoryPagesSourceOutputWithContext(context.Background()) +} + +func (i GetRepositoryPagesSourceArgs) ToGetRepositoryPagesSourceOutputWithContext(ctx context.Context) GetRepositoryPagesSourceOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryPagesSourceOutput) +} + +// GetRepositoryPagesSourceArrayInput is an input type that accepts GetRepositoryPagesSourceArray and GetRepositoryPagesSourceArrayOutput values. +// You can construct a concrete instance of `GetRepositoryPagesSourceArrayInput` via: +// +// GetRepositoryPagesSourceArray{ GetRepositoryPagesSourceArgs{...} } +type GetRepositoryPagesSourceArrayInput interface { + pulumi.Input + + ToGetRepositoryPagesSourceArrayOutput() GetRepositoryPagesSourceArrayOutput + ToGetRepositoryPagesSourceArrayOutputWithContext(context.Context) GetRepositoryPagesSourceArrayOutput +} + +type GetRepositoryPagesSourceArray []GetRepositoryPagesSourceInput + +func (GetRepositoryPagesSourceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryPagesSource)(nil)).Elem() +} + +func (i GetRepositoryPagesSourceArray) ToGetRepositoryPagesSourceArrayOutput() GetRepositoryPagesSourceArrayOutput { + return i.ToGetRepositoryPagesSourceArrayOutputWithContext(context.Background()) +} + +func (i GetRepositoryPagesSourceArray) ToGetRepositoryPagesSourceArrayOutputWithContext(ctx context.Context) GetRepositoryPagesSourceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryPagesSourceArrayOutput) +} + +type GetRepositoryPagesSourceOutput struct{ *pulumi.OutputState } + +func (GetRepositoryPagesSourceOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryPagesSource)(nil)).Elem() +} + +func (o GetRepositoryPagesSourceOutput) ToGetRepositoryPagesSourceOutput() GetRepositoryPagesSourceOutput { + return o +} + +func (o GetRepositoryPagesSourceOutput) ToGetRepositoryPagesSourceOutputWithContext(ctx context.Context) GetRepositoryPagesSourceOutput { + return o +} + +// The repository branch used to publish the site's source files. +func (o GetRepositoryPagesSourceOutput) Branch() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPagesSource) string { return v.Branch }).(pulumi.StringOutput) +} + +// The repository directory from which the site publishes. +func (o GetRepositoryPagesSourceOutput) Path() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPagesSource) string { return v.Path }).(pulumi.StringOutput) +} + +type GetRepositoryPagesSourceArrayOutput struct{ *pulumi.OutputState } + +func (GetRepositoryPagesSourceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryPagesSource)(nil)).Elem() +} + +func (o GetRepositoryPagesSourceArrayOutput) ToGetRepositoryPagesSourceArrayOutput() GetRepositoryPagesSourceArrayOutput { + return o +} + +func (o GetRepositoryPagesSourceArrayOutput) ToGetRepositoryPagesSourceArrayOutputWithContext(ctx context.Context) GetRepositoryPagesSourceArrayOutput { + return o +} + +func (o GetRepositoryPagesSourceArrayOutput) Index(i pulumi.IntInput) GetRepositoryPagesSourceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryPagesSource { + return vs[0].([]GetRepositoryPagesSource)[vs[1].(int)] + }).(GetRepositoryPagesSourceOutput) +} + +type GetRepositoryPullRequestsResult struct { + // If set, filters Pull Requests by base branch name. + BaseRef string `pulumi:"baseRef"` + // Head commit SHA of the Pull Request base. + BaseSha string `pulumi:"baseSha"` + // Body of the Pull Request. + Body string `pulumi:"body"` + // Indicates Whether this Pull Request is a draft. + Draft bool `pulumi:"draft"` + // Owner of the Pull Request head repository. + HeadOwner string `pulumi:"headOwner"` + // If set, filters Pull Requests by head user or head organization and branch name in the format of "user:ref-name" or "organization:ref-name". For example: "github:new-script-format" or "octocat:test-branch". + HeadRef string `pulumi:"headRef"` + // Name of the Pull Request head repository. + HeadRepository string `pulumi:"headRepository"` + // Head commit SHA of the Pull Request head. + HeadSha string `pulumi:"headSha"` + // List of label names set on the Pull Request. + Labels []string `pulumi:"labels"` + // Indicates whether the base repository maintainers can modify the Pull Request. + MaintainerCanModify bool `pulumi:"maintainerCanModify"` + // The number of the Pull Request within the repository. + Number int `pulumi:"number"` + // Unix timestamp indicating the Pull Request creation time. + OpenedAt int `pulumi:"openedAt"` + // GitHub login of the user who opened the Pull Request. + OpenedBy string `pulumi:"openedBy"` + // If set, filters Pull Requests by state. Can be "open", "closed", or "all". Default: "open". + State string `pulumi:"state"` + // The title of the Pull Request. + Title string `pulumi:"title"` + // The timestamp of the last Pull Request update. + UpdatedAt int `pulumi:"updatedAt"` +} + +// GetRepositoryPullRequestsResultInput is an input type that accepts GetRepositoryPullRequestsResultArgs and GetRepositoryPullRequestsResultOutput values. +// You can construct a concrete instance of `GetRepositoryPullRequestsResultInput` via: +// +// GetRepositoryPullRequestsResultArgs{...} +type GetRepositoryPullRequestsResultInput interface { + pulumi.Input + + ToGetRepositoryPullRequestsResultOutput() GetRepositoryPullRequestsResultOutput + ToGetRepositoryPullRequestsResultOutputWithContext(context.Context) GetRepositoryPullRequestsResultOutput +} + +type GetRepositoryPullRequestsResultArgs struct { + // If set, filters Pull Requests by base branch name. + BaseRef pulumi.StringInput `pulumi:"baseRef"` + // Head commit SHA of the Pull Request base. + BaseSha pulumi.StringInput `pulumi:"baseSha"` + // Body of the Pull Request. + Body pulumi.StringInput `pulumi:"body"` + // Indicates Whether this Pull Request is a draft. + Draft pulumi.BoolInput `pulumi:"draft"` + // Owner of the Pull Request head repository. + HeadOwner pulumi.StringInput `pulumi:"headOwner"` + // If set, filters Pull Requests by head user or head organization and branch name in the format of "user:ref-name" or "organization:ref-name". For example: "github:new-script-format" or "octocat:test-branch". + HeadRef pulumi.StringInput `pulumi:"headRef"` + // Name of the Pull Request head repository. + HeadRepository pulumi.StringInput `pulumi:"headRepository"` + // Head commit SHA of the Pull Request head. + HeadSha pulumi.StringInput `pulumi:"headSha"` + // List of label names set on the Pull Request. + Labels pulumi.StringArrayInput `pulumi:"labels"` + // Indicates whether the base repository maintainers can modify the Pull Request. + MaintainerCanModify pulumi.BoolInput `pulumi:"maintainerCanModify"` + // The number of the Pull Request within the repository. + Number pulumi.IntInput `pulumi:"number"` + // Unix timestamp indicating the Pull Request creation time. + OpenedAt pulumi.IntInput `pulumi:"openedAt"` + // GitHub login of the user who opened the Pull Request. + OpenedBy pulumi.StringInput `pulumi:"openedBy"` + // If set, filters Pull Requests by state. Can be "open", "closed", or "all". Default: "open". + State pulumi.StringInput `pulumi:"state"` + // The title of the Pull Request. + Title pulumi.StringInput `pulumi:"title"` + // The timestamp of the last Pull Request update. + UpdatedAt pulumi.IntInput `pulumi:"updatedAt"` +} + +func (GetRepositoryPullRequestsResultArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryPullRequestsResult)(nil)).Elem() +} + +func (i GetRepositoryPullRequestsResultArgs) ToGetRepositoryPullRequestsResultOutput() GetRepositoryPullRequestsResultOutput { + return i.ToGetRepositoryPullRequestsResultOutputWithContext(context.Background()) +} + +func (i GetRepositoryPullRequestsResultArgs) ToGetRepositoryPullRequestsResultOutputWithContext(ctx context.Context) GetRepositoryPullRequestsResultOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryPullRequestsResultOutput) +} + +// GetRepositoryPullRequestsResultArrayInput is an input type that accepts GetRepositoryPullRequestsResultArray and GetRepositoryPullRequestsResultArrayOutput values. +// You can construct a concrete instance of `GetRepositoryPullRequestsResultArrayInput` via: +// +// GetRepositoryPullRequestsResultArray{ GetRepositoryPullRequestsResultArgs{...} } +type GetRepositoryPullRequestsResultArrayInput interface { + pulumi.Input + + ToGetRepositoryPullRequestsResultArrayOutput() GetRepositoryPullRequestsResultArrayOutput + ToGetRepositoryPullRequestsResultArrayOutputWithContext(context.Context) GetRepositoryPullRequestsResultArrayOutput +} + +type GetRepositoryPullRequestsResultArray []GetRepositoryPullRequestsResultInput + +func (GetRepositoryPullRequestsResultArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryPullRequestsResult)(nil)).Elem() +} + +func (i GetRepositoryPullRequestsResultArray) ToGetRepositoryPullRequestsResultArrayOutput() GetRepositoryPullRequestsResultArrayOutput { + return i.ToGetRepositoryPullRequestsResultArrayOutputWithContext(context.Background()) +} + +func (i GetRepositoryPullRequestsResultArray) ToGetRepositoryPullRequestsResultArrayOutputWithContext(ctx context.Context) GetRepositoryPullRequestsResultArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryPullRequestsResultArrayOutput) +} + +type GetRepositoryPullRequestsResultOutput struct{ *pulumi.OutputState } + +func (GetRepositoryPullRequestsResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryPullRequestsResult)(nil)).Elem() +} + +func (o GetRepositoryPullRequestsResultOutput) ToGetRepositoryPullRequestsResultOutput() GetRepositoryPullRequestsResultOutput { + return o +} + +func (o GetRepositoryPullRequestsResultOutput) ToGetRepositoryPullRequestsResultOutputWithContext(ctx context.Context) GetRepositoryPullRequestsResultOutput { + return o +} + +// If set, filters Pull Requests by base branch name. +func (o GetRepositoryPullRequestsResultOutput) BaseRef() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPullRequestsResult) string { return v.BaseRef }).(pulumi.StringOutput) +} + +// Head commit SHA of the Pull Request base. +func (o GetRepositoryPullRequestsResultOutput) BaseSha() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPullRequestsResult) string { return v.BaseSha }).(pulumi.StringOutput) +} + +// Body of the Pull Request. +func (o GetRepositoryPullRequestsResultOutput) Body() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPullRequestsResult) string { return v.Body }).(pulumi.StringOutput) +} + +// Indicates Whether this Pull Request is a draft. +func (o GetRepositoryPullRequestsResultOutput) Draft() pulumi.BoolOutput { + return o.ApplyT(func(v GetRepositoryPullRequestsResult) bool { return v.Draft }).(pulumi.BoolOutput) +} + +// Owner of the Pull Request head repository. +func (o GetRepositoryPullRequestsResultOutput) HeadOwner() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPullRequestsResult) string { return v.HeadOwner }).(pulumi.StringOutput) +} + +// If set, filters Pull Requests by head user or head organization and branch name in the format of "user:ref-name" or "organization:ref-name". For example: "github:new-script-format" or "octocat:test-branch". +func (o GetRepositoryPullRequestsResultOutput) HeadRef() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPullRequestsResult) string { return v.HeadRef }).(pulumi.StringOutput) +} + +// Name of the Pull Request head repository. +func (o GetRepositoryPullRequestsResultOutput) HeadRepository() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPullRequestsResult) string { return v.HeadRepository }).(pulumi.StringOutput) +} + +// Head commit SHA of the Pull Request head. +func (o GetRepositoryPullRequestsResultOutput) HeadSha() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPullRequestsResult) string { return v.HeadSha }).(pulumi.StringOutput) +} + +// List of label names set on the Pull Request. +func (o GetRepositoryPullRequestsResultOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetRepositoryPullRequestsResult) []string { return v.Labels }).(pulumi.StringArrayOutput) +} + +// Indicates whether the base repository maintainers can modify the Pull Request. +func (o GetRepositoryPullRequestsResultOutput) MaintainerCanModify() pulumi.BoolOutput { + return o.ApplyT(func(v GetRepositoryPullRequestsResult) bool { return v.MaintainerCanModify }).(pulumi.BoolOutput) +} + +// The number of the Pull Request within the repository. +func (o GetRepositoryPullRequestsResultOutput) Number() pulumi.IntOutput { + return o.ApplyT(func(v GetRepositoryPullRequestsResult) int { return v.Number }).(pulumi.IntOutput) +} + +// Unix timestamp indicating the Pull Request creation time. +func (o GetRepositoryPullRequestsResultOutput) OpenedAt() pulumi.IntOutput { + return o.ApplyT(func(v GetRepositoryPullRequestsResult) int { return v.OpenedAt }).(pulumi.IntOutput) +} + +// GitHub login of the user who opened the Pull Request. +func (o GetRepositoryPullRequestsResultOutput) OpenedBy() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPullRequestsResult) string { return v.OpenedBy }).(pulumi.StringOutput) +} + +// If set, filters Pull Requests by state. Can be "open", "closed", or "all". Default: "open". +func (o GetRepositoryPullRequestsResultOutput) State() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPullRequestsResult) string { return v.State }).(pulumi.StringOutput) +} + +// The title of the Pull Request. +func (o GetRepositoryPullRequestsResultOutput) Title() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryPullRequestsResult) string { return v.Title }).(pulumi.StringOutput) +} + +// The timestamp of the last Pull Request update. +func (o GetRepositoryPullRequestsResultOutput) UpdatedAt() pulumi.IntOutput { + return o.ApplyT(func(v GetRepositoryPullRequestsResult) int { return v.UpdatedAt }).(pulumi.IntOutput) +} + +type GetRepositoryPullRequestsResultArrayOutput struct{ *pulumi.OutputState } + +func (GetRepositoryPullRequestsResultArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryPullRequestsResult)(nil)).Elem() +} + +func (o GetRepositoryPullRequestsResultArrayOutput) ToGetRepositoryPullRequestsResultArrayOutput() GetRepositoryPullRequestsResultArrayOutput { + return o +} + +func (o GetRepositoryPullRequestsResultArrayOutput) ToGetRepositoryPullRequestsResultArrayOutputWithContext(ctx context.Context) GetRepositoryPullRequestsResultArrayOutput { + return o +} + +func (o GetRepositoryPullRequestsResultArrayOutput) Index(i pulumi.IntInput) GetRepositoryPullRequestsResultOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryPullRequestsResult { + return vs[0].([]GetRepositoryPullRequestsResult)[vs[1].(int)] + }).(GetRepositoryPullRequestsResultOutput) +} + +type GetRepositoryRepositoryLicense struct { + // Content of the license file, encoded by encoding scheme mentioned below. + Content string `pulumi:"content"` + // The URL to download the raw content of the license file. + DownloadUrl string `pulumi:"downloadUrl"` + // The encoding used for the content (e.g., "base64"). + Encoding string `pulumi:"encoding"` + // The URL to access information about the license file as a Git blob. + GitUrl string `pulumi:"gitUrl"` + // The URL to view the license details on GitHub. + HtmlUrl string `pulumi:"htmlUrl"` + // `license` block consists of the fields documented below. + Licenses []GetRepositoryRepositoryLicenseLicense `pulumi:"licenses"` + // The name of the repository. + Name string `pulumi:"name"` + // The path to the license file within the repository. + Path string `pulumi:"path"` + // The SHA hash of the license file. + Sha string `pulumi:"sha"` + // The size of the license file in bytes. + Size int `pulumi:"size"` + // The type of the content, (e.g., "file"). + Type string `pulumi:"type"` + // The URL to access information about the license on GitHub. + Url string `pulumi:"url"` +} + +// GetRepositoryRepositoryLicenseInput is an input type that accepts GetRepositoryRepositoryLicenseArgs and GetRepositoryRepositoryLicenseOutput values. +// You can construct a concrete instance of `GetRepositoryRepositoryLicenseInput` via: +// +// GetRepositoryRepositoryLicenseArgs{...} +type GetRepositoryRepositoryLicenseInput interface { + pulumi.Input + + ToGetRepositoryRepositoryLicenseOutput() GetRepositoryRepositoryLicenseOutput + ToGetRepositoryRepositoryLicenseOutputWithContext(context.Context) GetRepositoryRepositoryLicenseOutput +} + +type GetRepositoryRepositoryLicenseArgs struct { + // Content of the license file, encoded by encoding scheme mentioned below. + Content pulumi.StringInput `pulumi:"content"` + // The URL to download the raw content of the license file. + DownloadUrl pulumi.StringInput `pulumi:"downloadUrl"` + // The encoding used for the content (e.g., "base64"). + Encoding pulumi.StringInput `pulumi:"encoding"` + // The URL to access information about the license file as a Git blob. + GitUrl pulumi.StringInput `pulumi:"gitUrl"` + // The URL to view the license details on GitHub. + HtmlUrl pulumi.StringInput `pulumi:"htmlUrl"` + // `license` block consists of the fields documented below. + Licenses GetRepositoryRepositoryLicenseLicenseArrayInput `pulumi:"licenses"` + // The name of the repository. + Name pulumi.StringInput `pulumi:"name"` + // The path to the license file within the repository. + Path pulumi.StringInput `pulumi:"path"` + // The SHA hash of the license file. + Sha pulumi.StringInput `pulumi:"sha"` + // The size of the license file in bytes. + Size pulumi.IntInput `pulumi:"size"` + // The type of the content, (e.g., "file"). + Type pulumi.StringInput `pulumi:"type"` + // The URL to access information about the license on GitHub. + Url pulumi.StringInput `pulumi:"url"` +} + +func (GetRepositoryRepositoryLicenseArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryRepositoryLicense)(nil)).Elem() +} + +func (i GetRepositoryRepositoryLicenseArgs) ToGetRepositoryRepositoryLicenseOutput() GetRepositoryRepositoryLicenseOutput { + return i.ToGetRepositoryRepositoryLicenseOutputWithContext(context.Background()) +} + +func (i GetRepositoryRepositoryLicenseArgs) ToGetRepositoryRepositoryLicenseOutputWithContext(ctx context.Context) GetRepositoryRepositoryLicenseOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryRepositoryLicenseOutput) +} + +// GetRepositoryRepositoryLicenseArrayInput is an input type that accepts GetRepositoryRepositoryLicenseArray and GetRepositoryRepositoryLicenseArrayOutput values. +// You can construct a concrete instance of `GetRepositoryRepositoryLicenseArrayInput` via: +// +// GetRepositoryRepositoryLicenseArray{ GetRepositoryRepositoryLicenseArgs{...} } +type GetRepositoryRepositoryLicenseArrayInput interface { + pulumi.Input + + ToGetRepositoryRepositoryLicenseArrayOutput() GetRepositoryRepositoryLicenseArrayOutput + ToGetRepositoryRepositoryLicenseArrayOutputWithContext(context.Context) GetRepositoryRepositoryLicenseArrayOutput +} + +type GetRepositoryRepositoryLicenseArray []GetRepositoryRepositoryLicenseInput + +func (GetRepositoryRepositoryLicenseArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryRepositoryLicense)(nil)).Elem() +} + +func (i GetRepositoryRepositoryLicenseArray) ToGetRepositoryRepositoryLicenseArrayOutput() GetRepositoryRepositoryLicenseArrayOutput { + return i.ToGetRepositoryRepositoryLicenseArrayOutputWithContext(context.Background()) +} + +func (i GetRepositoryRepositoryLicenseArray) ToGetRepositoryRepositoryLicenseArrayOutputWithContext(ctx context.Context) GetRepositoryRepositoryLicenseArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryRepositoryLicenseArrayOutput) +} + +type GetRepositoryRepositoryLicenseOutput struct{ *pulumi.OutputState } + +func (GetRepositoryRepositoryLicenseOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryRepositoryLicense)(nil)).Elem() +} + +func (o GetRepositoryRepositoryLicenseOutput) ToGetRepositoryRepositoryLicenseOutput() GetRepositoryRepositoryLicenseOutput { + return o +} + +func (o GetRepositoryRepositoryLicenseOutput) ToGetRepositoryRepositoryLicenseOutputWithContext(ctx context.Context) GetRepositoryRepositoryLicenseOutput { + return o +} + +// Content of the license file, encoded by encoding scheme mentioned below. +func (o GetRepositoryRepositoryLicenseOutput) Content() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicense) string { return v.Content }).(pulumi.StringOutput) +} + +// The URL to download the raw content of the license file. +func (o GetRepositoryRepositoryLicenseOutput) DownloadUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicense) string { return v.DownloadUrl }).(pulumi.StringOutput) +} + +// The encoding used for the content (e.g., "base64"). +func (o GetRepositoryRepositoryLicenseOutput) Encoding() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicense) string { return v.Encoding }).(pulumi.StringOutput) +} + +// The URL to access information about the license file as a Git blob. +func (o GetRepositoryRepositoryLicenseOutput) GitUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicense) string { return v.GitUrl }).(pulumi.StringOutput) +} + +// The URL to view the license details on GitHub. +func (o GetRepositoryRepositoryLicenseOutput) HtmlUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicense) string { return v.HtmlUrl }).(pulumi.StringOutput) +} + +// `license` block consists of the fields documented below. +func (o GetRepositoryRepositoryLicenseOutput) Licenses() GetRepositoryRepositoryLicenseLicenseArrayOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicense) []GetRepositoryRepositoryLicenseLicense { return v.Licenses }).(GetRepositoryRepositoryLicenseLicenseArrayOutput) +} + +// The name of the repository. +func (o GetRepositoryRepositoryLicenseOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicense) string { return v.Name }).(pulumi.StringOutput) +} + +// The path to the license file within the repository. +func (o GetRepositoryRepositoryLicenseOutput) Path() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicense) string { return v.Path }).(pulumi.StringOutput) +} + +// The SHA hash of the license file. +func (o GetRepositoryRepositoryLicenseOutput) Sha() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicense) string { return v.Sha }).(pulumi.StringOutput) +} + +// The size of the license file in bytes. +func (o GetRepositoryRepositoryLicenseOutput) Size() pulumi.IntOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicense) int { return v.Size }).(pulumi.IntOutput) +} + +// The type of the content, (e.g., "file"). +func (o GetRepositoryRepositoryLicenseOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicense) string { return v.Type }).(pulumi.StringOutput) +} + +// The URL to access information about the license on GitHub. +func (o GetRepositoryRepositoryLicenseOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicense) string { return v.Url }).(pulumi.StringOutput) +} + +type GetRepositoryRepositoryLicenseArrayOutput struct{ *pulumi.OutputState } + +func (GetRepositoryRepositoryLicenseArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryRepositoryLicense)(nil)).Elem() +} + +func (o GetRepositoryRepositoryLicenseArrayOutput) ToGetRepositoryRepositoryLicenseArrayOutput() GetRepositoryRepositoryLicenseArrayOutput { + return o +} + +func (o GetRepositoryRepositoryLicenseArrayOutput) ToGetRepositoryRepositoryLicenseArrayOutputWithContext(ctx context.Context) GetRepositoryRepositoryLicenseArrayOutput { + return o +} + +func (o GetRepositoryRepositoryLicenseArrayOutput) Index(i pulumi.IntInput) GetRepositoryRepositoryLicenseOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryRepositoryLicense { + return vs[0].([]GetRepositoryRepositoryLicense)[vs[1].(int)] + }).(GetRepositoryRepositoryLicenseOutput) +} + +type GetRepositoryRepositoryLicenseLicense struct { + // The text of the license. + Body string `pulumi:"body"` + // Conditions associated with the license. + Conditions []string `pulumi:"conditions"` + // A description of the license. + Description string `pulumi:"description"` + // Indicates if the license is featured. + Featured bool `pulumi:"featured"` + // The URL to view the license details on GitHub. + HtmlUrl string `pulumi:"htmlUrl"` + // Details about the implementation of the license. + Implementation string `pulumi:"implementation"` + // A key representing the license type (e.g., "apache-2.0"). + Key string `pulumi:"key"` + // Limitations associated with the license. + Limitations []string `pulumi:"limitations"` + // The name of the repository. + Name string `pulumi:"name"` + // Permissions associated with the license. + Permissions []string `pulumi:"permissions"` + // The SPDX identifier for the license (e.g., "Apache-2.0"). + SpdxId string `pulumi:"spdxId"` + // The URL to access information about the license on GitHub. + Url string `pulumi:"url"` +} + +// GetRepositoryRepositoryLicenseLicenseInput is an input type that accepts GetRepositoryRepositoryLicenseLicenseArgs and GetRepositoryRepositoryLicenseLicenseOutput values. +// You can construct a concrete instance of `GetRepositoryRepositoryLicenseLicenseInput` via: +// +// GetRepositoryRepositoryLicenseLicenseArgs{...} +type GetRepositoryRepositoryLicenseLicenseInput interface { + pulumi.Input + + ToGetRepositoryRepositoryLicenseLicenseOutput() GetRepositoryRepositoryLicenseLicenseOutput + ToGetRepositoryRepositoryLicenseLicenseOutputWithContext(context.Context) GetRepositoryRepositoryLicenseLicenseOutput +} + +type GetRepositoryRepositoryLicenseLicenseArgs struct { + // The text of the license. + Body pulumi.StringInput `pulumi:"body"` + // Conditions associated with the license. + Conditions pulumi.StringArrayInput `pulumi:"conditions"` + // A description of the license. + Description pulumi.StringInput `pulumi:"description"` + // Indicates if the license is featured. + Featured pulumi.BoolInput `pulumi:"featured"` + // The URL to view the license details on GitHub. + HtmlUrl pulumi.StringInput `pulumi:"htmlUrl"` + // Details about the implementation of the license. + Implementation pulumi.StringInput `pulumi:"implementation"` + // A key representing the license type (e.g., "apache-2.0"). + Key pulumi.StringInput `pulumi:"key"` + // Limitations associated with the license. + Limitations pulumi.StringArrayInput `pulumi:"limitations"` + // The name of the repository. + Name pulumi.StringInput `pulumi:"name"` + // Permissions associated with the license. + Permissions pulumi.StringArrayInput `pulumi:"permissions"` + // The SPDX identifier for the license (e.g., "Apache-2.0"). + SpdxId pulumi.StringInput `pulumi:"spdxId"` + // The URL to access information about the license on GitHub. + Url pulumi.StringInput `pulumi:"url"` +} + +func (GetRepositoryRepositoryLicenseLicenseArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryRepositoryLicenseLicense)(nil)).Elem() +} + +func (i GetRepositoryRepositoryLicenseLicenseArgs) ToGetRepositoryRepositoryLicenseLicenseOutput() GetRepositoryRepositoryLicenseLicenseOutput { + return i.ToGetRepositoryRepositoryLicenseLicenseOutputWithContext(context.Background()) +} + +func (i GetRepositoryRepositoryLicenseLicenseArgs) ToGetRepositoryRepositoryLicenseLicenseOutputWithContext(ctx context.Context) GetRepositoryRepositoryLicenseLicenseOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryRepositoryLicenseLicenseOutput) +} + +// GetRepositoryRepositoryLicenseLicenseArrayInput is an input type that accepts GetRepositoryRepositoryLicenseLicenseArray and GetRepositoryRepositoryLicenseLicenseArrayOutput values. +// You can construct a concrete instance of `GetRepositoryRepositoryLicenseLicenseArrayInput` via: +// +// GetRepositoryRepositoryLicenseLicenseArray{ GetRepositoryRepositoryLicenseLicenseArgs{...} } +type GetRepositoryRepositoryLicenseLicenseArrayInput interface { + pulumi.Input + + ToGetRepositoryRepositoryLicenseLicenseArrayOutput() GetRepositoryRepositoryLicenseLicenseArrayOutput + ToGetRepositoryRepositoryLicenseLicenseArrayOutputWithContext(context.Context) GetRepositoryRepositoryLicenseLicenseArrayOutput +} + +type GetRepositoryRepositoryLicenseLicenseArray []GetRepositoryRepositoryLicenseLicenseInput + +func (GetRepositoryRepositoryLicenseLicenseArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryRepositoryLicenseLicense)(nil)).Elem() +} + +func (i GetRepositoryRepositoryLicenseLicenseArray) ToGetRepositoryRepositoryLicenseLicenseArrayOutput() GetRepositoryRepositoryLicenseLicenseArrayOutput { + return i.ToGetRepositoryRepositoryLicenseLicenseArrayOutputWithContext(context.Background()) +} + +func (i GetRepositoryRepositoryLicenseLicenseArray) ToGetRepositoryRepositoryLicenseLicenseArrayOutputWithContext(ctx context.Context) GetRepositoryRepositoryLicenseLicenseArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryRepositoryLicenseLicenseArrayOutput) +} + +type GetRepositoryRepositoryLicenseLicenseOutput struct{ *pulumi.OutputState } + +func (GetRepositoryRepositoryLicenseLicenseOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryRepositoryLicenseLicense)(nil)).Elem() +} + +func (o GetRepositoryRepositoryLicenseLicenseOutput) ToGetRepositoryRepositoryLicenseLicenseOutput() GetRepositoryRepositoryLicenseLicenseOutput { + return o +} + +func (o GetRepositoryRepositoryLicenseLicenseOutput) ToGetRepositoryRepositoryLicenseLicenseOutputWithContext(ctx context.Context) GetRepositoryRepositoryLicenseLicenseOutput { + return o +} + +// The text of the license. +func (o GetRepositoryRepositoryLicenseLicenseOutput) Body() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicenseLicense) string { return v.Body }).(pulumi.StringOutput) +} + +// Conditions associated with the license. +func (o GetRepositoryRepositoryLicenseLicenseOutput) Conditions() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicenseLicense) []string { return v.Conditions }).(pulumi.StringArrayOutput) +} + +// A description of the license. +func (o GetRepositoryRepositoryLicenseLicenseOutput) Description() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicenseLicense) string { return v.Description }).(pulumi.StringOutput) +} + +// Indicates if the license is featured. +func (o GetRepositoryRepositoryLicenseLicenseOutput) Featured() pulumi.BoolOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicenseLicense) bool { return v.Featured }).(pulumi.BoolOutput) +} + +// The URL to view the license details on GitHub. +func (o GetRepositoryRepositoryLicenseLicenseOutput) HtmlUrl() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicenseLicense) string { return v.HtmlUrl }).(pulumi.StringOutput) +} + +// Details about the implementation of the license. +func (o GetRepositoryRepositoryLicenseLicenseOutput) Implementation() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicenseLicense) string { return v.Implementation }).(pulumi.StringOutput) +} + +// A key representing the license type (e.g., "apache-2.0"). +func (o GetRepositoryRepositoryLicenseLicenseOutput) Key() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicenseLicense) string { return v.Key }).(pulumi.StringOutput) +} + +// Limitations associated with the license. +func (o GetRepositoryRepositoryLicenseLicenseOutput) Limitations() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicenseLicense) []string { return v.Limitations }).(pulumi.StringArrayOutput) +} + +// The name of the repository. +func (o GetRepositoryRepositoryLicenseLicenseOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicenseLicense) string { return v.Name }).(pulumi.StringOutput) +} + +// Permissions associated with the license. +func (o GetRepositoryRepositoryLicenseLicenseOutput) Permissions() pulumi.StringArrayOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicenseLicense) []string { return v.Permissions }).(pulumi.StringArrayOutput) +} + +// The SPDX identifier for the license (e.g., "Apache-2.0"). +func (o GetRepositoryRepositoryLicenseLicenseOutput) SpdxId() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicenseLicense) string { return v.SpdxId }).(pulumi.StringOutput) +} + +// The URL to access information about the license on GitHub. +func (o GetRepositoryRepositoryLicenseLicenseOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryRepositoryLicenseLicense) string { return v.Url }).(pulumi.StringOutput) +} + +type GetRepositoryRepositoryLicenseLicenseArrayOutput struct{ *pulumi.OutputState } + +func (GetRepositoryRepositoryLicenseLicenseArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryRepositoryLicenseLicense)(nil)).Elem() +} + +func (o GetRepositoryRepositoryLicenseLicenseArrayOutput) ToGetRepositoryRepositoryLicenseLicenseArrayOutput() GetRepositoryRepositoryLicenseLicenseArrayOutput { + return o +} + +func (o GetRepositoryRepositoryLicenseLicenseArrayOutput) ToGetRepositoryRepositoryLicenseLicenseArrayOutputWithContext(ctx context.Context) GetRepositoryRepositoryLicenseLicenseArrayOutput { + return o +} + +func (o GetRepositoryRepositoryLicenseLicenseArrayOutput) Index(i pulumi.IntInput) GetRepositoryRepositoryLicenseLicenseOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryRepositoryLicenseLicense { + return vs[0].([]GetRepositoryRepositoryLicenseLicense)[vs[1].(int)] + }).(GetRepositoryRepositoryLicenseLicenseOutput) +} + +type GetRepositoryTeamsTeam struct { + // The name of the repository. + Name string `pulumi:"name"` + // Team permission + Permission string `pulumi:"permission"` + // Team slug + Slug string `pulumi:"slug"` +} + +// GetRepositoryTeamsTeamInput is an input type that accepts GetRepositoryTeamsTeamArgs and GetRepositoryTeamsTeamOutput values. +// You can construct a concrete instance of `GetRepositoryTeamsTeamInput` via: +// +// GetRepositoryTeamsTeamArgs{...} +type GetRepositoryTeamsTeamInput interface { + pulumi.Input + + ToGetRepositoryTeamsTeamOutput() GetRepositoryTeamsTeamOutput + ToGetRepositoryTeamsTeamOutputWithContext(context.Context) GetRepositoryTeamsTeamOutput +} + +type GetRepositoryTeamsTeamArgs struct { + // The name of the repository. + Name pulumi.StringInput `pulumi:"name"` + // Team permission + Permission pulumi.StringInput `pulumi:"permission"` + // Team slug + Slug pulumi.StringInput `pulumi:"slug"` +} + +func (GetRepositoryTeamsTeamArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryTeamsTeam)(nil)).Elem() +} + +func (i GetRepositoryTeamsTeamArgs) ToGetRepositoryTeamsTeamOutput() GetRepositoryTeamsTeamOutput { + return i.ToGetRepositoryTeamsTeamOutputWithContext(context.Background()) +} + +func (i GetRepositoryTeamsTeamArgs) ToGetRepositoryTeamsTeamOutputWithContext(ctx context.Context) GetRepositoryTeamsTeamOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryTeamsTeamOutput) +} + +// GetRepositoryTeamsTeamArrayInput is an input type that accepts GetRepositoryTeamsTeamArray and GetRepositoryTeamsTeamArrayOutput values. +// You can construct a concrete instance of `GetRepositoryTeamsTeamArrayInput` via: +// +// GetRepositoryTeamsTeamArray{ GetRepositoryTeamsTeamArgs{...} } +type GetRepositoryTeamsTeamArrayInput interface { + pulumi.Input + + ToGetRepositoryTeamsTeamArrayOutput() GetRepositoryTeamsTeamArrayOutput + ToGetRepositoryTeamsTeamArrayOutputWithContext(context.Context) GetRepositoryTeamsTeamArrayOutput +} + +type GetRepositoryTeamsTeamArray []GetRepositoryTeamsTeamInput + +func (GetRepositoryTeamsTeamArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryTeamsTeam)(nil)).Elem() +} + +func (i GetRepositoryTeamsTeamArray) ToGetRepositoryTeamsTeamArrayOutput() GetRepositoryTeamsTeamArrayOutput { + return i.ToGetRepositoryTeamsTeamArrayOutputWithContext(context.Background()) +} + +func (i GetRepositoryTeamsTeamArray) ToGetRepositoryTeamsTeamArrayOutputWithContext(ctx context.Context) GetRepositoryTeamsTeamArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryTeamsTeamArrayOutput) +} + +type GetRepositoryTeamsTeamOutput struct{ *pulumi.OutputState } + +func (GetRepositoryTeamsTeamOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryTeamsTeam)(nil)).Elem() +} + +func (o GetRepositoryTeamsTeamOutput) ToGetRepositoryTeamsTeamOutput() GetRepositoryTeamsTeamOutput { + return o +} + +func (o GetRepositoryTeamsTeamOutput) ToGetRepositoryTeamsTeamOutputWithContext(ctx context.Context) GetRepositoryTeamsTeamOutput { + return o +} + +// The name of the repository. +func (o GetRepositoryTeamsTeamOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryTeamsTeam) string { return v.Name }).(pulumi.StringOutput) +} + +// Team permission +func (o GetRepositoryTeamsTeamOutput) Permission() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryTeamsTeam) string { return v.Permission }).(pulumi.StringOutput) +} + +// Team slug +func (o GetRepositoryTeamsTeamOutput) Slug() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryTeamsTeam) string { return v.Slug }).(pulumi.StringOutput) +} + +type GetRepositoryTeamsTeamArrayOutput struct{ *pulumi.OutputState } + +func (GetRepositoryTeamsTeamArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryTeamsTeam)(nil)).Elem() +} + +func (o GetRepositoryTeamsTeamArrayOutput) ToGetRepositoryTeamsTeamArrayOutput() GetRepositoryTeamsTeamArrayOutput { + return o +} + +func (o GetRepositoryTeamsTeamArrayOutput) ToGetRepositoryTeamsTeamArrayOutputWithContext(ctx context.Context) GetRepositoryTeamsTeamArrayOutput { + return o +} + +func (o GetRepositoryTeamsTeamArrayOutput) Index(i pulumi.IntInput) GetRepositoryTeamsTeamOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryTeamsTeam { + return vs[0].([]GetRepositoryTeamsTeam)[vs[1].(int)] + }).(GetRepositoryTeamsTeamOutput) +} + +type GetRepositoryTemplate struct { + Owner string `pulumi:"owner"` + Repository string `pulumi:"repository"` +} + +// GetRepositoryTemplateInput is an input type that accepts GetRepositoryTemplateArgs and GetRepositoryTemplateOutput values. +// You can construct a concrete instance of `GetRepositoryTemplateInput` via: +// +// GetRepositoryTemplateArgs{...} +type GetRepositoryTemplateInput interface { + pulumi.Input + + ToGetRepositoryTemplateOutput() GetRepositoryTemplateOutput + ToGetRepositoryTemplateOutputWithContext(context.Context) GetRepositoryTemplateOutput +} + +type GetRepositoryTemplateArgs struct { + Owner pulumi.StringInput `pulumi:"owner"` + Repository pulumi.StringInput `pulumi:"repository"` +} + +func (GetRepositoryTemplateArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryTemplate)(nil)).Elem() +} + +func (i GetRepositoryTemplateArgs) ToGetRepositoryTemplateOutput() GetRepositoryTemplateOutput { + return i.ToGetRepositoryTemplateOutputWithContext(context.Background()) +} + +func (i GetRepositoryTemplateArgs) ToGetRepositoryTemplateOutputWithContext(ctx context.Context) GetRepositoryTemplateOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryTemplateOutput) +} + +// GetRepositoryTemplateArrayInput is an input type that accepts GetRepositoryTemplateArray and GetRepositoryTemplateArrayOutput values. +// You can construct a concrete instance of `GetRepositoryTemplateArrayInput` via: +// +// GetRepositoryTemplateArray{ GetRepositoryTemplateArgs{...} } +type GetRepositoryTemplateArrayInput interface { + pulumi.Input + + ToGetRepositoryTemplateArrayOutput() GetRepositoryTemplateArrayOutput + ToGetRepositoryTemplateArrayOutputWithContext(context.Context) GetRepositoryTemplateArrayOutput +} + +type GetRepositoryTemplateArray []GetRepositoryTemplateInput + +func (GetRepositoryTemplateArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryTemplate)(nil)).Elem() +} + +func (i GetRepositoryTemplateArray) ToGetRepositoryTemplateArrayOutput() GetRepositoryTemplateArrayOutput { + return i.ToGetRepositoryTemplateArrayOutputWithContext(context.Background()) +} + +func (i GetRepositoryTemplateArray) ToGetRepositoryTemplateArrayOutputWithContext(ctx context.Context) GetRepositoryTemplateArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryTemplateArrayOutput) +} + +type GetRepositoryTemplateOutput struct{ *pulumi.OutputState } + +func (GetRepositoryTemplateOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryTemplate)(nil)).Elem() +} + +func (o GetRepositoryTemplateOutput) ToGetRepositoryTemplateOutput() GetRepositoryTemplateOutput { + return o +} + +func (o GetRepositoryTemplateOutput) ToGetRepositoryTemplateOutputWithContext(ctx context.Context) GetRepositoryTemplateOutput { + return o +} + +func (o GetRepositoryTemplateOutput) Owner() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryTemplate) string { return v.Owner }).(pulumi.StringOutput) +} + +func (o GetRepositoryTemplateOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryTemplate) string { return v.Repository }).(pulumi.StringOutput) +} + +type GetRepositoryTemplateArrayOutput struct{ *pulumi.OutputState } + +func (GetRepositoryTemplateArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryTemplate)(nil)).Elem() +} + +func (o GetRepositoryTemplateArrayOutput) ToGetRepositoryTemplateArrayOutput() GetRepositoryTemplateArrayOutput { + return o +} + +func (o GetRepositoryTemplateArrayOutput) ToGetRepositoryTemplateArrayOutputWithContext(ctx context.Context) GetRepositoryTemplateArrayOutput { + return o +} + +func (o GetRepositoryTemplateArrayOutput) Index(i pulumi.IntInput) GetRepositoryTemplateOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryTemplate { + return vs[0].([]GetRepositoryTemplate)[vs[1].(int)] + }).(GetRepositoryTemplateOutput) +} + +type GetRepositoryWebhooksWebhook struct { + // `true` if the webhook is active. + Active bool `pulumi:"active"` + // the ID of the webhook. + Id int `pulumi:"id"` + // the name of the webhook. + Name string `pulumi:"name"` + // the type of the webhook. + Type string `pulumi:"type"` + // the url of the webhook. + Url string `pulumi:"url"` +} + +// GetRepositoryWebhooksWebhookInput is an input type that accepts GetRepositoryWebhooksWebhookArgs and GetRepositoryWebhooksWebhookOutput values. +// You can construct a concrete instance of `GetRepositoryWebhooksWebhookInput` via: +// +// GetRepositoryWebhooksWebhookArgs{...} +type GetRepositoryWebhooksWebhookInput interface { + pulumi.Input + + ToGetRepositoryWebhooksWebhookOutput() GetRepositoryWebhooksWebhookOutput + ToGetRepositoryWebhooksWebhookOutputWithContext(context.Context) GetRepositoryWebhooksWebhookOutput +} + +type GetRepositoryWebhooksWebhookArgs struct { + // `true` if the webhook is active. + Active pulumi.BoolInput `pulumi:"active"` + // the ID of the webhook. + Id pulumi.IntInput `pulumi:"id"` + // the name of the webhook. + Name pulumi.StringInput `pulumi:"name"` + // the type of the webhook. + Type pulumi.StringInput `pulumi:"type"` + // the url of the webhook. + Url pulumi.StringInput `pulumi:"url"` +} + +func (GetRepositoryWebhooksWebhookArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryWebhooksWebhook)(nil)).Elem() +} + +func (i GetRepositoryWebhooksWebhookArgs) ToGetRepositoryWebhooksWebhookOutput() GetRepositoryWebhooksWebhookOutput { + return i.ToGetRepositoryWebhooksWebhookOutputWithContext(context.Background()) +} + +func (i GetRepositoryWebhooksWebhookArgs) ToGetRepositoryWebhooksWebhookOutputWithContext(ctx context.Context) GetRepositoryWebhooksWebhookOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryWebhooksWebhookOutput) +} + +// GetRepositoryWebhooksWebhookArrayInput is an input type that accepts GetRepositoryWebhooksWebhookArray and GetRepositoryWebhooksWebhookArrayOutput values. +// You can construct a concrete instance of `GetRepositoryWebhooksWebhookArrayInput` via: +// +// GetRepositoryWebhooksWebhookArray{ GetRepositoryWebhooksWebhookArgs{...} } +type GetRepositoryWebhooksWebhookArrayInput interface { + pulumi.Input + + ToGetRepositoryWebhooksWebhookArrayOutput() GetRepositoryWebhooksWebhookArrayOutput + ToGetRepositoryWebhooksWebhookArrayOutputWithContext(context.Context) GetRepositoryWebhooksWebhookArrayOutput +} + +type GetRepositoryWebhooksWebhookArray []GetRepositoryWebhooksWebhookInput + +func (GetRepositoryWebhooksWebhookArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryWebhooksWebhook)(nil)).Elem() +} + +func (i GetRepositoryWebhooksWebhookArray) ToGetRepositoryWebhooksWebhookArrayOutput() GetRepositoryWebhooksWebhookArrayOutput { + return i.ToGetRepositoryWebhooksWebhookArrayOutputWithContext(context.Background()) +} + +func (i GetRepositoryWebhooksWebhookArray) ToGetRepositoryWebhooksWebhookArrayOutputWithContext(ctx context.Context) GetRepositoryWebhooksWebhookArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetRepositoryWebhooksWebhookArrayOutput) +} + +type GetRepositoryWebhooksWebhookOutput struct{ *pulumi.OutputState } + +func (GetRepositoryWebhooksWebhookOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetRepositoryWebhooksWebhook)(nil)).Elem() +} + +func (o GetRepositoryWebhooksWebhookOutput) ToGetRepositoryWebhooksWebhookOutput() GetRepositoryWebhooksWebhookOutput { + return o +} + +func (o GetRepositoryWebhooksWebhookOutput) ToGetRepositoryWebhooksWebhookOutputWithContext(ctx context.Context) GetRepositoryWebhooksWebhookOutput { + return o +} + +// `true` if the webhook is active. +func (o GetRepositoryWebhooksWebhookOutput) Active() pulumi.BoolOutput { + return o.ApplyT(func(v GetRepositoryWebhooksWebhook) bool { return v.Active }).(pulumi.BoolOutput) +} + +// the ID of the webhook. +func (o GetRepositoryWebhooksWebhookOutput) Id() pulumi.IntOutput { + return o.ApplyT(func(v GetRepositoryWebhooksWebhook) int { return v.Id }).(pulumi.IntOutput) +} + +// the name of the webhook. +func (o GetRepositoryWebhooksWebhookOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryWebhooksWebhook) string { return v.Name }).(pulumi.StringOutput) +} + +// the type of the webhook. +func (o GetRepositoryWebhooksWebhookOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryWebhooksWebhook) string { return v.Type }).(pulumi.StringOutput) +} + +// the url of the webhook. +func (o GetRepositoryWebhooksWebhookOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v GetRepositoryWebhooksWebhook) string { return v.Url }).(pulumi.StringOutput) +} + +type GetRepositoryWebhooksWebhookArrayOutput struct{ *pulumi.OutputState } + +func (GetRepositoryWebhooksWebhookArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetRepositoryWebhooksWebhook)(nil)).Elem() +} + +func (o GetRepositoryWebhooksWebhookArrayOutput) ToGetRepositoryWebhooksWebhookArrayOutput() GetRepositoryWebhooksWebhookArrayOutput { + return o +} + +func (o GetRepositoryWebhooksWebhookArrayOutput) ToGetRepositoryWebhooksWebhookArrayOutputWithContext(ctx context.Context) GetRepositoryWebhooksWebhookArrayOutput { + return o +} + +func (o GetRepositoryWebhooksWebhookArrayOutput) Index(i pulumi.IntInput) GetRepositoryWebhooksWebhookOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetRepositoryWebhooksWebhook { + return vs[0].([]GetRepositoryWebhooksWebhook)[vs[1].(int)] + }).(GetRepositoryWebhooksWebhookOutput) +} + +type GetTeamRepositoriesDetailed struct { + RepoId int `pulumi:"repoId"` + RepoName string `pulumi:"repoName"` + RoleName string `pulumi:"roleName"` +} + +// GetTeamRepositoriesDetailedInput is an input type that accepts GetTeamRepositoriesDetailedArgs and GetTeamRepositoriesDetailedOutput values. +// You can construct a concrete instance of `GetTeamRepositoriesDetailedInput` via: +// +// GetTeamRepositoriesDetailedArgs{...} +type GetTeamRepositoriesDetailedInput interface { + pulumi.Input + + ToGetTeamRepositoriesDetailedOutput() GetTeamRepositoriesDetailedOutput + ToGetTeamRepositoriesDetailedOutputWithContext(context.Context) GetTeamRepositoriesDetailedOutput +} + +type GetTeamRepositoriesDetailedArgs struct { + RepoId pulumi.IntInput `pulumi:"repoId"` + RepoName pulumi.StringInput `pulumi:"repoName"` + RoleName pulumi.StringInput `pulumi:"roleName"` +} + +func (GetTeamRepositoriesDetailedArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetTeamRepositoriesDetailed)(nil)).Elem() +} + +func (i GetTeamRepositoriesDetailedArgs) ToGetTeamRepositoriesDetailedOutput() GetTeamRepositoriesDetailedOutput { + return i.ToGetTeamRepositoriesDetailedOutputWithContext(context.Background()) +} + +func (i GetTeamRepositoriesDetailedArgs) ToGetTeamRepositoriesDetailedOutputWithContext(ctx context.Context) GetTeamRepositoriesDetailedOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetTeamRepositoriesDetailedOutput) +} + +// GetTeamRepositoriesDetailedArrayInput is an input type that accepts GetTeamRepositoriesDetailedArray and GetTeamRepositoriesDetailedArrayOutput values. +// You can construct a concrete instance of `GetTeamRepositoriesDetailedArrayInput` via: +// +// GetTeamRepositoriesDetailedArray{ GetTeamRepositoriesDetailedArgs{...} } +type GetTeamRepositoriesDetailedArrayInput interface { + pulumi.Input + + ToGetTeamRepositoriesDetailedArrayOutput() GetTeamRepositoriesDetailedArrayOutput + ToGetTeamRepositoriesDetailedArrayOutputWithContext(context.Context) GetTeamRepositoriesDetailedArrayOutput +} + +type GetTeamRepositoriesDetailedArray []GetTeamRepositoriesDetailedInput + +func (GetTeamRepositoriesDetailedArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetTeamRepositoriesDetailed)(nil)).Elem() +} + +func (i GetTeamRepositoriesDetailedArray) ToGetTeamRepositoriesDetailedArrayOutput() GetTeamRepositoriesDetailedArrayOutput { + return i.ToGetTeamRepositoriesDetailedArrayOutputWithContext(context.Background()) +} + +func (i GetTeamRepositoriesDetailedArray) ToGetTeamRepositoriesDetailedArrayOutputWithContext(ctx context.Context) GetTeamRepositoriesDetailedArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetTeamRepositoriesDetailedArrayOutput) +} + +type GetTeamRepositoriesDetailedOutput struct{ *pulumi.OutputState } + +func (GetTeamRepositoriesDetailedOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetTeamRepositoriesDetailed)(nil)).Elem() +} + +func (o GetTeamRepositoriesDetailedOutput) ToGetTeamRepositoriesDetailedOutput() GetTeamRepositoriesDetailedOutput { + return o +} + +func (o GetTeamRepositoriesDetailedOutput) ToGetTeamRepositoriesDetailedOutputWithContext(ctx context.Context) GetTeamRepositoriesDetailedOutput { + return o +} + +func (o GetTeamRepositoriesDetailedOutput) RepoId() pulumi.IntOutput { + return o.ApplyT(func(v GetTeamRepositoriesDetailed) int { return v.RepoId }).(pulumi.IntOutput) +} + +func (o GetTeamRepositoriesDetailedOutput) RepoName() pulumi.StringOutput { + return o.ApplyT(func(v GetTeamRepositoriesDetailed) string { return v.RepoName }).(pulumi.StringOutput) +} + +func (o GetTeamRepositoriesDetailedOutput) RoleName() pulumi.StringOutput { + return o.ApplyT(func(v GetTeamRepositoriesDetailed) string { return v.RoleName }).(pulumi.StringOutput) +} + +type GetTeamRepositoriesDetailedArrayOutput struct{ *pulumi.OutputState } + +func (GetTeamRepositoriesDetailedArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetTeamRepositoriesDetailed)(nil)).Elem() +} + +func (o GetTeamRepositoriesDetailedArrayOutput) ToGetTeamRepositoriesDetailedArrayOutput() GetTeamRepositoriesDetailedArrayOutput { + return o +} + +func (o GetTeamRepositoriesDetailedArrayOutput) ToGetTeamRepositoriesDetailedArrayOutputWithContext(ctx context.Context) GetTeamRepositoriesDetailedArrayOutput { + return o +} + +func (o GetTeamRepositoriesDetailedArrayOutput) Index(i pulumi.IntInput) GetTeamRepositoriesDetailedOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetTeamRepositoriesDetailed { + return vs[0].([]GetTeamRepositoriesDetailed)[vs[1].(int)] + }).(GetTeamRepositoriesDetailedOutput) +} + +type GetTreeEntry struct { + Mode string `pulumi:"mode"` + Path string `pulumi:"path"` + Sha string `pulumi:"sha"` + Size int `pulumi:"size"` + Type string `pulumi:"type"` +} + +// GetTreeEntryInput is an input type that accepts GetTreeEntryArgs and GetTreeEntryOutput values. +// You can construct a concrete instance of `GetTreeEntryInput` via: +// +// GetTreeEntryArgs{...} +type GetTreeEntryInput interface { + pulumi.Input + + ToGetTreeEntryOutput() GetTreeEntryOutput + ToGetTreeEntryOutputWithContext(context.Context) GetTreeEntryOutput +} + +type GetTreeEntryArgs struct { + Mode pulumi.StringInput `pulumi:"mode"` + Path pulumi.StringInput `pulumi:"path"` + Sha pulumi.StringInput `pulumi:"sha"` + Size pulumi.IntInput `pulumi:"size"` + Type pulumi.StringInput `pulumi:"type"` +} + +func (GetTreeEntryArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetTreeEntry)(nil)).Elem() +} + +func (i GetTreeEntryArgs) ToGetTreeEntryOutput() GetTreeEntryOutput { + return i.ToGetTreeEntryOutputWithContext(context.Background()) +} + +func (i GetTreeEntryArgs) ToGetTreeEntryOutputWithContext(ctx context.Context) GetTreeEntryOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetTreeEntryOutput) +} + +// GetTreeEntryArrayInput is an input type that accepts GetTreeEntryArray and GetTreeEntryArrayOutput values. +// You can construct a concrete instance of `GetTreeEntryArrayInput` via: +// +// GetTreeEntryArray{ GetTreeEntryArgs{...} } +type GetTreeEntryArrayInput interface { + pulumi.Input + + ToGetTreeEntryArrayOutput() GetTreeEntryArrayOutput + ToGetTreeEntryArrayOutputWithContext(context.Context) GetTreeEntryArrayOutput +} + +type GetTreeEntryArray []GetTreeEntryInput + +func (GetTreeEntryArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetTreeEntry)(nil)).Elem() +} + +func (i GetTreeEntryArray) ToGetTreeEntryArrayOutput() GetTreeEntryArrayOutput { + return i.ToGetTreeEntryArrayOutputWithContext(context.Background()) +} + +func (i GetTreeEntryArray) ToGetTreeEntryArrayOutputWithContext(ctx context.Context) GetTreeEntryArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetTreeEntryArrayOutput) +} + +type GetTreeEntryOutput struct{ *pulumi.OutputState } + +func (GetTreeEntryOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetTreeEntry)(nil)).Elem() +} + +func (o GetTreeEntryOutput) ToGetTreeEntryOutput() GetTreeEntryOutput { + return o +} + +func (o GetTreeEntryOutput) ToGetTreeEntryOutputWithContext(ctx context.Context) GetTreeEntryOutput { + return o +} + +func (o GetTreeEntryOutput) Mode() pulumi.StringOutput { + return o.ApplyT(func(v GetTreeEntry) string { return v.Mode }).(pulumi.StringOutput) +} + +func (o GetTreeEntryOutput) Path() pulumi.StringOutput { + return o.ApplyT(func(v GetTreeEntry) string { return v.Path }).(pulumi.StringOutput) +} + +func (o GetTreeEntryOutput) Sha() pulumi.StringOutput { + return o.ApplyT(func(v GetTreeEntry) string { return v.Sha }).(pulumi.StringOutput) +} + +func (o GetTreeEntryOutput) Size() pulumi.IntOutput { + return o.ApplyT(func(v GetTreeEntry) int { return v.Size }).(pulumi.IntOutput) +} + +func (o GetTreeEntryOutput) Type() pulumi.StringOutput { + return o.ApplyT(func(v GetTreeEntry) string { return v.Type }).(pulumi.StringOutput) +} + +type GetTreeEntryArrayOutput struct{ *pulumi.OutputState } + +func (GetTreeEntryArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetTreeEntry)(nil)).Elem() +} + +func (o GetTreeEntryArrayOutput) ToGetTreeEntryArrayOutput() GetTreeEntryArrayOutput { + return o +} + +func (o GetTreeEntryArrayOutput) ToGetTreeEntryArrayOutputWithContext(ctx context.Context) GetTreeEntryArrayOutput { + return o +} + +func (o GetTreeEntryArrayOutput) Index(i pulumi.IntInput) GetTreeEntryOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetTreeEntry { + return vs[0].([]GetTreeEntry)[vs[1].(int)] + }).(GetTreeEntryOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ActionsHostedRunnerImageInput)(nil)).Elem(), ActionsHostedRunnerImageArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsHostedRunnerImagePtrInput)(nil)).Elem(), ActionsHostedRunnerImageArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsHostedRunnerMachineSizeDetailInput)(nil)).Elem(), ActionsHostedRunnerMachineSizeDetailArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsHostedRunnerMachineSizeDetailArrayInput)(nil)).Elem(), ActionsHostedRunnerMachineSizeDetailArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsHostedRunnerPublicIpInput)(nil)).Elem(), ActionsHostedRunnerPublicIpArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsHostedRunnerPublicIpArrayInput)(nil)).Elem(), ActionsHostedRunnerPublicIpArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationPermissionsAllowedActionsConfigInput)(nil)).Elem(), ActionsOrganizationPermissionsAllowedActionsConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationPermissionsAllowedActionsConfigPtrInput)(nil)).Elem(), ActionsOrganizationPermissionsAllowedActionsConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationPermissionsEnabledRepositoriesConfigInput)(nil)).Elem(), ActionsOrganizationPermissionsEnabledRepositoriesConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrInput)(nil)).Elem(), ActionsOrganizationPermissionsEnabledRepositoriesConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsRepositoryPermissionsAllowedActionsConfigInput)(nil)).Elem(), ActionsRepositoryPermissionsAllowedActionsConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ActionsRepositoryPermissionsAllowedActionsConfigPtrInput)(nil)).Elem(), ActionsRepositoryPermissionsAllowedActionsConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionRequiredPullRequestReviewInput)(nil)).Elem(), BranchProtectionRequiredPullRequestReviewArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionRequiredPullRequestReviewArrayInput)(nil)).Elem(), BranchProtectionRequiredPullRequestReviewArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionRequiredStatusCheckInput)(nil)).Elem(), BranchProtectionRequiredStatusCheckArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionRequiredStatusCheckArrayInput)(nil)).Elem(), BranchProtectionRequiredStatusCheckArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionRestrictPushInput)(nil)).Elem(), BranchProtectionRestrictPushArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionRestrictPushArrayInput)(nil)).Elem(), BranchProtectionRestrictPushArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionV3RequiredPullRequestReviewsInput)(nil)).Elem(), BranchProtectionV3RequiredPullRequestReviewsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionV3RequiredPullRequestReviewsPtrInput)(nil)).Elem(), BranchProtectionV3RequiredPullRequestReviewsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesInput)(nil)).Elem(), BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrInput)(nil)).Elem(), BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionV3RequiredStatusChecksInput)(nil)).Elem(), BranchProtectionV3RequiredStatusChecksArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionV3RequiredStatusChecksPtrInput)(nil)).Elem(), BranchProtectionV3RequiredStatusChecksArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionV3RestrictionsInput)(nil)).Elem(), BranchProtectionV3RestrictionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*BranchProtectionV3RestrictionsPtrInput)(nil)).Elem(), BranchProtectionV3RestrictionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseActionsPermissionsAllowedActionsConfigInput)(nil)).Elem(), EnterpriseActionsPermissionsAllowedActionsConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseActionsPermissionsAllowedActionsConfigPtrInput)(nil)).Elem(), EnterpriseActionsPermissionsAllowedActionsConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseActionsPermissionsEnabledOrganizationsConfigInput)(nil)).Elem(), EnterpriseActionsPermissionsEnabledOrganizationsConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrInput)(nil)).Elem(), EnterpriseActionsPermissionsEnabledOrganizationsConfigArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*IssueLabelsLabelInput)(nil)).Elem(), IssueLabelsLabelArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*IssueLabelsLabelArrayInput)(nil)).Elem(), IssueLabelsLabelArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetBypassActorInput)(nil)).Elem(), OrganizationRulesetBypassActorArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetBypassActorArrayInput)(nil)).Elem(), OrganizationRulesetBypassActorArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetConditionsInput)(nil)).Elem(), OrganizationRulesetConditionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetConditionsPtrInput)(nil)).Elem(), OrganizationRulesetConditionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetConditionsRefNameInput)(nil)).Elem(), OrganizationRulesetConditionsRefNameArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetConditionsRefNamePtrInput)(nil)).Elem(), OrganizationRulesetConditionsRefNameArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetConditionsRepositoryNameInput)(nil)).Elem(), OrganizationRulesetConditionsRepositoryNameArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetConditionsRepositoryNamePtrInput)(nil)).Elem(), OrganizationRulesetConditionsRepositoryNameArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetConditionsRepositoryPropertyInput)(nil)).Elem(), OrganizationRulesetConditionsRepositoryPropertyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetConditionsRepositoryPropertyPtrInput)(nil)).Elem(), OrganizationRulesetConditionsRepositoryPropertyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetConditionsRepositoryPropertyExcludeInput)(nil)).Elem(), OrganizationRulesetConditionsRepositoryPropertyExcludeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetConditionsRepositoryPropertyExcludeArrayInput)(nil)).Elem(), OrganizationRulesetConditionsRepositoryPropertyExcludeArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetConditionsRepositoryPropertyIncludeInput)(nil)).Elem(), OrganizationRulesetConditionsRepositoryPropertyIncludeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetConditionsRepositoryPropertyIncludeArrayInput)(nil)).Elem(), OrganizationRulesetConditionsRepositoryPropertyIncludeArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesInput)(nil)).Elem(), OrganizationRulesetRulesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesPtrInput)(nil)).Elem(), OrganizationRulesetRulesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesBranchNamePatternInput)(nil)).Elem(), OrganizationRulesetRulesBranchNamePatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesBranchNamePatternPtrInput)(nil)).Elem(), OrganizationRulesetRulesBranchNamePatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesCommitAuthorEmailPatternInput)(nil)).Elem(), OrganizationRulesetRulesCommitAuthorEmailPatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesCommitAuthorEmailPatternPtrInput)(nil)).Elem(), OrganizationRulesetRulesCommitAuthorEmailPatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesCommitMessagePatternInput)(nil)).Elem(), OrganizationRulesetRulesCommitMessagePatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesCommitMessagePatternPtrInput)(nil)).Elem(), OrganizationRulesetRulesCommitMessagePatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesCommitterEmailPatternInput)(nil)).Elem(), OrganizationRulesetRulesCommitterEmailPatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesCommitterEmailPatternPtrInput)(nil)).Elem(), OrganizationRulesetRulesCommitterEmailPatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesCopilotCodeReviewInput)(nil)).Elem(), OrganizationRulesetRulesCopilotCodeReviewArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesCopilotCodeReviewPtrInput)(nil)).Elem(), OrganizationRulesetRulesCopilotCodeReviewArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesFileExtensionRestrictionInput)(nil)).Elem(), OrganizationRulesetRulesFileExtensionRestrictionArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesFileExtensionRestrictionPtrInput)(nil)).Elem(), OrganizationRulesetRulesFileExtensionRestrictionArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesFilePathRestrictionInput)(nil)).Elem(), OrganizationRulesetRulesFilePathRestrictionArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesFilePathRestrictionPtrInput)(nil)).Elem(), OrganizationRulesetRulesFilePathRestrictionArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesMaxFilePathLengthInput)(nil)).Elem(), OrganizationRulesetRulesMaxFilePathLengthArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesMaxFilePathLengthPtrInput)(nil)).Elem(), OrganizationRulesetRulesMaxFilePathLengthArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesMaxFileSizeInput)(nil)).Elem(), OrganizationRulesetRulesMaxFileSizeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesMaxFileSizePtrInput)(nil)).Elem(), OrganizationRulesetRulesMaxFileSizeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesPullRequestInput)(nil)).Elem(), OrganizationRulesetRulesPullRequestArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesPullRequestPtrInput)(nil)).Elem(), OrganizationRulesetRulesPullRequestArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesPullRequestRequiredReviewerInput)(nil)).Elem(), OrganizationRulesetRulesPullRequestRequiredReviewerArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesPullRequestRequiredReviewerArrayInput)(nil)).Elem(), OrganizationRulesetRulesPullRequestRequiredReviewerArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesPullRequestRequiredReviewerReviewerInput)(nil)).Elem(), OrganizationRulesetRulesPullRequestRequiredReviewerReviewerArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesRequiredCodeScanningInput)(nil)).Elem(), OrganizationRulesetRulesRequiredCodeScanningArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesRequiredCodeScanningPtrInput)(nil)).Elem(), OrganizationRulesetRulesRequiredCodeScanningArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolInput)(nil)).Elem(), OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayInput)(nil)).Elem(), OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesRequiredStatusChecksInput)(nil)).Elem(), OrganizationRulesetRulesRequiredStatusChecksArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesRequiredStatusChecksPtrInput)(nil)).Elem(), OrganizationRulesetRulesRequiredStatusChecksArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesRequiredStatusChecksRequiredCheckInput)(nil)).Elem(), OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayInput)(nil)).Elem(), OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesRequiredWorkflowsInput)(nil)).Elem(), OrganizationRulesetRulesRequiredWorkflowsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesRequiredWorkflowsPtrInput)(nil)).Elem(), OrganizationRulesetRulesRequiredWorkflowsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowInput)(nil)).Elem(), OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayInput)(nil)).Elem(), OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesTagNamePatternInput)(nil)).Elem(), OrganizationRulesetRulesTagNamePatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationRulesetRulesTagNamePatternPtrInput)(nil)).Elem(), OrganizationRulesetRulesTagNamePatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationWebhookConfigurationInput)(nil)).Elem(), OrganizationWebhookConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*OrganizationWebhookConfigurationPtrInput)(nil)).Elem(), OrganizationWebhookConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ProviderAppAuthInput)(nil)).Elem(), ProviderAppAuthArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*ProviderAppAuthPtrInput)(nil)).Elem(), ProviderAppAuthArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryCollaboratorsIgnoreTeamInput)(nil)).Elem(), RepositoryCollaboratorsIgnoreTeamArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryCollaboratorsIgnoreTeamArrayInput)(nil)).Elem(), RepositoryCollaboratorsIgnoreTeamArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryCollaboratorsTeamInput)(nil)).Elem(), RepositoryCollaboratorsTeamArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryCollaboratorsTeamArrayInput)(nil)).Elem(), RepositoryCollaboratorsTeamArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryCollaboratorsUserInput)(nil)).Elem(), RepositoryCollaboratorsUserArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryCollaboratorsUserArrayInput)(nil)).Elem(), RepositoryCollaboratorsUserArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryEnvironmentDeploymentBranchPolicyInput)(nil)).Elem(), RepositoryEnvironmentDeploymentBranchPolicyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryEnvironmentDeploymentBranchPolicyPtrInput)(nil)).Elem(), RepositoryEnvironmentDeploymentBranchPolicyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryEnvironmentReviewerInput)(nil)).Elem(), RepositoryEnvironmentReviewerArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryEnvironmentReviewerArrayInput)(nil)).Elem(), RepositoryEnvironmentReviewerArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryPagesTypeInput)(nil)).Elem(), RepositoryPagesTypeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryPagesTypePtrInput)(nil)).Elem(), RepositoryPagesTypeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryPagesSourceInput)(nil)).Elem(), RepositoryPagesSourceArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryPagesSourcePtrInput)(nil)).Elem(), RepositoryPagesSourceArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetBypassActorInput)(nil)).Elem(), RepositoryRulesetBypassActorArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetBypassActorArrayInput)(nil)).Elem(), RepositoryRulesetBypassActorArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetConditionsInput)(nil)).Elem(), RepositoryRulesetConditionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetConditionsPtrInput)(nil)).Elem(), RepositoryRulesetConditionsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetConditionsRefNameInput)(nil)).Elem(), RepositoryRulesetConditionsRefNameArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetConditionsRefNamePtrInput)(nil)).Elem(), RepositoryRulesetConditionsRefNameArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesInput)(nil)).Elem(), RepositoryRulesetRulesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesPtrInput)(nil)).Elem(), RepositoryRulesetRulesArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesBranchNamePatternInput)(nil)).Elem(), RepositoryRulesetRulesBranchNamePatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesBranchNamePatternPtrInput)(nil)).Elem(), RepositoryRulesetRulesBranchNamePatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesCommitAuthorEmailPatternInput)(nil)).Elem(), RepositoryRulesetRulesCommitAuthorEmailPatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesCommitAuthorEmailPatternPtrInput)(nil)).Elem(), RepositoryRulesetRulesCommitAuthorEmailPatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesCommitMessagePatternInput)(nil)).Elem(), RepositoryRulesetRulesCommitMessagePatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesCommitMessagePatternPtrInput)(nil)).Elem(), RepositoryRulesetRulesCommitMessagePatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesCommitterEmailPatternInput)(nil)).Elem(), RepositoryRulesetRulesCommitterEmailPatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesCommitterEmailPatternPtrInput)(nil)).Elem(), RepositoryRulesetRulesCommitterEmailPatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesCopilotCodeReviewInput)(nil)).Elem(), RepositoryRulesetRulesCopilotCodeReviewArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesCopilotCodeReviewPtrInput)(nil)).Elem(), RepositoryRulesetRulesCopilotCodeReviewArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesFileExtensionRestrictionInput)(nil)).Elem(), RepositoryRulesetRulesFileExtensionRestrictionArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesFileExtensionRestrictionPtrInput)(nil)).Elem(), RepositoryRulesetRulesFileExtensionRestrictionArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesFilePathRestrictionInput)(nil)).Elem(), RepositoryRulesetRulesFilePathRestrictionArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesFilePathRestrictionPtrInput)(nil)).Elem(), RepositoryRulesetRulesFilePathRestrictionArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesMaxFilePathLengthInput)(nil)).Elem(), RepositoryRulesetRulesMaxFilePathLengthArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesMaxFilePathLengthPtrInput)(nil)).Elem(), RepositoryRulesetRulesMaxFilePathLengthArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesMaxFileSizeInput)(nil)).Elem(), RepositoryRulesetRulesMaxFileSizeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesMaxFileSizePtrInput)(nil)).Elem(), RepositoryRulesetRulesMaxFileSizeArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesMergeQueueInput)(nil)).Elem(), RepositoryRulesetRulesMergeQueueArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesMergeQueuePtrInput)(nil)).Elem(), RepositoryRulesetRulesMergeQueueArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesPullRequestInput)(nil)).Elem(), RepositoryRulesetRulesPullRequestArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesPullRequestPtrInput)(nil)).Elem(), RepositoryRulesetRulesPullRequestArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesPullRequestRequiredReviewerInput)(nil)).Elem(), RepositoryRulesetRulesPullRequestRequiredReviewerArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesPullRequestRequiredReviewerArrayInput)(nil)).Elem(), RepositoryRulesetRulesPullRequestRequiredReviewerArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesPullRequestRequiredReviewerReviewerInput)(nil)).Elem(), RepositoryRulesetRulesPullRequestRequiredReviewerReviewerArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesRequiredCodeScanningInput)(nil)).Elem(), RepositoryRulesetRulesRequiredCodeScanningArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesRequiredCodeScanningPtrInput)(nil)).Elem(), RepositoryRulesetRulesRequiredCodeScanningArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolInput)(nil)).Elem(), RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayInput)(nil)).Elem(), RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesRequiredDeploymentsInput)(nil)).Elem(), RepositoryRulesetRulesRequiredDeploymentsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesRequiredDeploymentsPtrInput)(nil)).Elem(), RepositoryRulesetRulesRequiredDeploymentsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesRequiredStatusChecksInput)(nil)).Elem(), RepositoryRulesetRulesRequiredStatusChecksArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesRequiredStatusChecksPtrInput)(nil)).Elem(), RepositoryRulesetRulesRequiredStatusChecksArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesRequiredStatusChecksRequiredCheckInput)(nil)).Elem(), RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayInput)(nil)).Elem(), RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesTagNamePatternInput)(nil)).Elem(), RepositoryRulesetRulesTagNamePatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetRulesTagNamePatternPtrInput)(nil)).Elem(), RepositoryRulesetRulesTagNamePatternArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositorySecurityAndAnalysisInput)(nil)).Elem(), RepositorySecurityAndAnalysisArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositorySecurityAndAnalysisPtrInput)(nil)).Elem(), RepositorySecurityAndAnalysisArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositorySecurityAndAnalysisAdvancedSecurityInput)(nil)).Elem(), RepositorySecurityAndAnalysisAdvancedSecurityArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositorySecurityAndAnalysisAdvancedSecurityPtrInput)(nil)).Elem(), RepositorySecurityAndAnalysisAdvancedSecurityArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositorySecurityAndAnalysisCodeSecurityInput)(nil)).Elem(), RepositorySecurityAndAnalysisCodeSecurityArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositorySecurityAndAnalysisCodeSecurityPtrInput)(nil)).Elem(), RepositorySecurityAndAnalysisCodeSecurityArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositorySecurityAndAnalysisSecretScanningInput)(nil)).Elem(), RepositorySecurityAndAnalysisSecretScanningArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositorySecurityAndAnalysisSecretScanningPtrInput)(nil)).Elem(), RepositorySecurityAndAnalysisSecretScanningArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositorySecurityAndAnalysisSecretScanningAiDetectionInput)(nil)).Elem(), RepositorySecurityAndAnalysisSecretScanningAiDetectionArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrInput)(nil)).Elem(), RepositorySecurityAndAnalysisSecretScanningAiDetectionArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsInput)(nil)).Elem(), RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrInput)(nil)).Elem(), RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositorySecurityAndAnalysisSecretScanningPushProtectionInput)(nil)).Elem(), RepositorySecurityAndAnalysisSecretScanningPushProtectionArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrInput)(nil)).Elem(), RepositorySecurityAndAnalysisSecretScanningPushProtectionArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryTemplateInput)(nil)).Elem(), RepositoryTemplateArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryTemplatePtrInput)(nil)).Elem(), RepositoryTemplateArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryWebhookConfigurationInput)(nil)).Elem(), RepositoryWebhookConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryWebhookConfigurationPtrInput)(nil)).Elem(), RepositoryWebhookConfigurationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamMembersMemberInput)(nil)).Elem(), TeamMembersMemberArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamMembersMemberArrayInput)(nil)).Elem(), TeamMembersMemberArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamSettingsReviewRequestDelegationInput)(nil)).Elem(), TeamSettingsReviewRequestDelegationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamSettingsReviewRequestDelegationPtrInput)(nil)).Elem(), TeamSettingsReviewRequestDelegationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamSyncGroupMappingGroupInput)(nil)).Elem(), TeamSyncGroupMappingGroupArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamSyncGroupMappingGroupArrayInput)(nil)).Elem(), TeamSyncGroupMappingGroupArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetActionsEnvironmentSecretsSecretInput)(nil)).Elem(), GetActionsEnvironmentSecretsSecretArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetActionsEnvironmentSecretsSecretArrayInput)(nil)).Elem(), GetActionsEnvironmentSecretsSecretArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetActionsEnvironmentVariablesVariableInput)(nil)).Elem(), GetActionsEnvironmentVariablesVariableArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetActionsEnvironmentVariablesVariableArrayInput)(nil)).Elem(), GetActionsEnvironmentVariablesVariableArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetActionsOrganizationSecretsSecretInput)(nil)).Elem(), GetActionsOrganizationSecretsSecretArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetActionsOrganizationSecretsSecretArrayInput)(nil)).Elem(), GetActionsOrganizationSecretsSecretArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetActionsOrganizationVariablesVariableInput)(nil)).Elem(), GetActionsOrganizationVariablesVariableArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetActionsOrganizationVariablesVariableArrayInput)(nil)).Elem(), GetActionsOrganizationVariablesVariableArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetActionsSecretsSecretInput)(nil)).Elem(), GetActionsSecretsSecretArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetActionsSecretsSecretArrayInput)(nil)).Elem(), GetActionsSecretsSecretArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetActionsVariablesVariableInput)(nil)).Elem(), GetActionsVariablesVariableArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetActionsVariablesVariableArrayInput)(nil)).Elem(), GetActionsVariablesVariableArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetBranchProtectionRulesRuleInput)(nil)).Elem(), GetBranchProtectionRulesRuleArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetBranchProtectionRulesRuleArrayInput)(nil)).Elem(), GetBranchProtectionRulesRuleArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetCodespacesOrganizationSecretsSecretInput)(nil)).Elem(), GetCodespacesOrganizationSecretsSecretArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetCodespacesOrganizationSecretsSecretArrayInput)(nil)).Elem(), GetCodespacesOrganizationSecretsSecretArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetCodespacesSecretsSecretInput)(nil)).Elem(), GetCodespacesSecretsSecretArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetCodespacesSecretsSecretArrayInput)(nil)).Elem(), GetCodespacesSecretsSecretArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetCodespacesUserSecretsSecretInput)(nil)).Elem(), GetCodespacesUserSecretsSecretArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetCodespacesUserSecretsSecretArrayInput)(nil)).Elem(), GetCodespacesUserSecretsSecretArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetCollaboratorsCollaboratorInput)(nil)).Elem(), GetCollaboratorsCollaboratorArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetCollaboratorsCollaboratorArrayInput)(nil)).Elem(), GetCollaboratorsCollaboratorArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetDependabotOrganizationSecretsSecretInput)(nil)).Elem(), GetDependabotOrganizationSecretsSecretArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetDependabotOrganizationSecretsSecretArrayInput)(nil)).Elem(), GetDependabotOrganizationSecretsSecretArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetDependabotSecretsSecretInput)(nil)).Elem(), GetDependabotSecretsSecretArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetDependabotSecretsSecretArrayInput)(nil)).Elem(), GetDependabotSecretsSecretArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetExternalGroupsExternalGroupInput)(nil)).Elem(), GetExternalGroupsExternalGroupArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetExternalGroupsExternalGroupArrayInput)(nil)).Elem(), GetExternalGroupsExternalGroupArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetIssueLabelsLabelInput)(nil)).Elem(), GetIssueLabelsLabelArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetIssueLabelsLabelArrayInput)(nil)).Elem(), GetIssueLabelsLabelArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationAppInstallationsInstallationInput)(nil)).Elem(), GetOrganizationAppInstallationsInstallationArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationAppInstallationsInstallationArrayInput)(nil)).Elem(), GetOrganizationAppInstallationsInstallationArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationExternalIdentitiesIdentityInput)(nil)).Elem(), GetOrganizationExternalIdentitiesIdentityArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationExternalIdentitiesIdentityArrayInput)(nil)).Elem(), GetOrganizationExternalIdentitiesIdentityArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationIpAllowListIpAllowListInput)(nil)).Elem(), GetOrganizationIpAllowListIpAllowListArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationIpAllowListIpAllowListArrayInput)(nil)).Elem(), GetOrganizationIpAllowListIpAllowListArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationRepositoryRolesRoleInput)(nil)).Elem(), GetOrganizationRepositoryRolesRoleArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationRepositoryRolesRoleArrayInput)(nil)).Elem(), GetOrganizationRepositoryRolesRoleArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationRoleTeamsTeamInput)(nil)).Elem(), GetOrganizationRoleTeamsTeamArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationRoleTeamsTeamArrayInput)(nil)).Elem(), GetOrganizationRoleTeamsTeamArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationRoleUsersUserInput)(nil)).Elem(), GetOrganizationRoleUsersUserArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationRoleUsersUserArrayInput)(nil)).Elem(), GetOrganizationRoleUsersUserArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationRolesRoleInput)(nil)).Elem(), GetOrganizationRolesRoleArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationRolesRoleArrayInput)(nil)).Elem(), GetOrganizationRolesRoleArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationSecurityManagersTeamInput)(nil)).Elem(), GetOrganizationSecurityManagersTeamArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationSecurityManagersTeamArrayInput)(nil)).Elem(), GetOrganizationSecurityManagersTeamArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationTeamSyncGroupsGroupInput)(nil)).Elem(), GetOrganizationTeamSyncGroupsGroupArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationTeamSyncGroupsGroupArrayInput)(nil)).Elem(), GetOrganizationTeamSyncGroupsGroupArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationTeamsTeamInput)(nil)).Elem(), GetOrganizationTeamsTeamArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationTeamsTeamArrayInput)(nil)).Elem(), GetOrganizationTeamsTeamArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationWebhooksWebhookInput)(nil)).Elem(), GetOrganizationWebhooksWebhookArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetOrganizationWebhooksWebhookArrayInput)(nil)).Elem(), GetOrganizationWebhooksWebhookArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetReleaseAssetInput)(nil)).Elem(), GetReleaseAssetArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetReleaseAssetArrayInput)(nil)).Elem(), GetReleaseAssetArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryAutolinkReferencesAutolinkReferenceInput)(nil)).Elem(), GetRepositoryAutolinkReferencesAutolinkReferenceArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryAutolinkReferencesAutolinkReferenceArrayInput)(nil)).Elem(), GetRepositoryAutolinkReferencesAutolinkReferenceArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryBranchesBranchInput)(nil)).Elem(), GetRepositoryBranchesBranchArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryBranchesBranchArrayInput)(nil)).Elem(), GetRepositoryBranchesBranchArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryCustomPropertiesPropertyInput)(nil)).Elem(), GetRepositoryCustomPropertiesPropertyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryCustomPropertiesPropertyArrayInput)(nil)).Elem(), GetRepositoryCustomPropertiesPropertyArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryDeployKeysKeyInput)(nil)).Elem(), GetRepositoryDeployKeysKeyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryDeployKeysKeyArrayInput)(nil)).Elem(), GetRepositoryDeployKeysKeyArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyInput)(nil)).Elem(), GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayInput)(nil)).Elem(), GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryEnvironmentDeploymentPoliciesPolicyInput)(nil)).Elem(), GetRepositoryEnvironmentDeploymentPoliciesPolicyArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayInput)(nil)).Elem(), GetRepositoryEnvironmentDeploymentPoliciesPolicyArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryEnvironmentsEnvironmentInput)(nil)).Elem(), GetRepositoryEnvironmentsEnvironmentArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryEnvironmentsEnvironmentArrayInput)(nil)).Elem(), GetRepositoryEnvironmentsEnvironmentArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryPageInput)(nil)).Elem(), GetRepositoryPageArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryPageArrayInput)(nil)).Elem(), GetRepositoryPageArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryPageSourceInput)(nil)).Elem(), GetRepositoryPageSourceArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryPageSourceArrayInput)(nil)).Elem(), GetRepositoryPageSourceArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryPagesSourceInput)(nil)).Elem(), GetRepositoryPagesSourceArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryPagesSourceArrayInput)(nil)).Elem(), GetRepositoryPagesSourceArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryPullRequestsResultInput)(nil)).Elem(), GetRepositoryPullRequestsResultArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryPullRequestsResultArrayInput)(nil)).Elem(), GetRepositoryPullRequestsResultArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryRepositoryLicenseInput)(nil)).Elem(), GetRepositoryRepositoryLicenseArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryRepositoryLicenseArrayInput)(nil)).Elem(), GetRepositoryRepositoryLicenseArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryRepositoryLicenseLicenseInput)(nil)).Elem(), GetRepositoryRepositoryLicenseLicenseArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryRepositoryLicenseLicenseArrayInput)(nil)).Elem(), GetRepositoryRepositoryLicenseLicenseArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryTeamsTeamInput)(nil)).Elem(), GetRepositoryTeamsTeamArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryTeamsTeamArrayInput)(nil)).Elem(), GetRepositoryTeamsTeamArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryTemplateInput)(nil)).Elem(), GetRepositoryTemplateArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryTemplateArrayInput)(nil)).Elem(), GetRepositoryTemplateArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryWebhooksWebhookInput)(nil)).Elem(), GetRepositoryWebhooksWebhookArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetRepositoryWebhooksWebhookArrayInput)(nil)).Elem(), GetRepositoryWebhooksWebhookArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetTeamRepositoriesDetailedInput)(nil)).Elem(), GetTeamRepositoriesDetailedArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetTeamRepositoriesDetailedArrayInput)(nil)).Elem(), GetTeamRepositoriesDetailedArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetTreeEntryInput)(nil)).Elem(), GetTreeEntryArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetTreeEntryArrayInput)(nil)).Elem(), GetTreeEntryArray{}) + pulumi.RegisterOutputType(ActionsHostedRunnerImageOutput{}) + pulumi.RegisterOutputType(ActionsHostedRunnerImagePtrOutput{}) + pulumi.RegisterOutputType(ActionsHostedRunnerMachineSizeDetailOutput{}) + pulumi.RegisterOutputType(ActionsHostedRunnerMachineSizeDetailArrayOutput{}) + pulumi.RegisterOutputType(ActionsHostedRunnerPublicIpOutput{}) + pulumi.RegisterOutputType(ActionsHostedRunnerPublicIpArrayOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationPermissionsAllowedActionsConfigOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationPermissionsAllowedActionsConfigPtrOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationPermissionsEnabledRepositoriesConfigOutput{}) + pulumi.RegisterOutputType(ActionsOrganizationPermissionsEnabledRepositoriesConfigPtrOutput{}) + pulumi.RegisterOutputType(ActionsRepositoryPermissionsAllowedActionsConfigOutput{}) + pulumi.RegisterOutputType(ActionsRepositoryPermissionsAllowedActionsConfigPtrOutput{}) + pulumi.RegisterOutputType(BranchProtectionRequiredPullRequestReviewOutput{}) + pulumi.RegisterOutputType(BranchProtectionRequiredPullRequestReviewArrayOutput{}) + pulumi.RegisterOutputType(BranchProtectionRequiredStatusCheckOutput{}) + pulumi.RegisterOutputType(BranchProtectionRequiredStatusCheckArrayOutput{}) + pulumi.RegisterOutputType(BranchProtectionRestrictPushOutput{}) + pulumi.RegisterOutputType(BranchProtectionRestrictPushArrayOutput{}) + pulumi.RegisterOutputType(BranchProtectionV3RequiredPullRequestReviewsOutput{}) + pulumi.RegisterOutputType(BranchProtectionV3RequiredPullRequestReviewsPtrOutput{}) + pulumi.RegisterOutputType(BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesOutput{}) + pulumi.RegisterOutputType(BranchProtectionV3RequiredPullRequestReviewsBypassPullRequestAllowancesPtrOutput{}) + pulumi.RegisterOutputType(BranchProtectionV3RequiredStatusChecksOutput{}) + pulumi.RegisterOutputType(BranchProtectionV3RequiredStatusChecksPtrOutput{}) + pulumi.RegisterOutputType(BranchProtectionV3RestrictionsOutput{}) + pulumi.RegisterOutputType(BranchProtectionV3RestrictionsPtrOutput{}) + pulumi.RegisterOutputType(EnterpriseActionsPermissionsAllowedActionsConfigOutput{}) + pulumi.RegisterOutputType(EnterpriseActionsPermissionsAllowedActionsConfigPtrOutput{}) + pulumi.RegisterOutputType(EnterpriseActionsPermissionsEnabledOrganizationsConfigOutput{}) + pulumi.RegisterOutputType(EnterpriseActionsPermissionsEnabledOrganizationsConfigPtrOutput{}) + pulumi.RegisterOutputType(IssueLabelsLabelOutput{}) + pulumi.RegisterOutputType(IssueLabelsLabelArrayOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetBypassActorOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetBypassActorArrayOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetConditionsOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetConditionsPtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetConditionsRefNameOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetConditionsRefNamePtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetConditionsRepositoryNameOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetConditionsRepositoryNamePtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetConditionsRepositoryPropertyOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetConditionsRepositoryPropertyPtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetConditionsRepositoryPropertyExcludeOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetConditionsRepositoryPropertyExcludeArrayOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetConditionsRepositoryPropertyIncludeOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetConditionsRepositoryPropertyIncludeArrayOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesPtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesBranchNamePatternOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesBranchNamePatternPtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesCommitAuthorEmailPatternOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesCommitAuthorEmailPatternPtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesCommitMessagePatternOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesCommitMessagePatternPtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesCommitterEmailPatternOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesCommitterEmailPatternPtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesCopilotCodeReviewOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesCopilotCodeReviewPtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesFileExtensionRestrictionOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesFileExtensionRestrictionPtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesFilePathRestrictionOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesFilePathRestrictionPtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesMaxFilePathLengthOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesMaxFilePathLengthPtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesMaxFileSizeOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesMaxFileSizePtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesPullRequestOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesPullRequestPtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesPullRequestRequiredReviewerOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesPullRequestRequiredReviewerArrayOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesPullRequestRequiredReviewerReviewerOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesRequiredCodeScanningOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesRequiredCodeScanningPtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesRequiredStatusChecksOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesRequiredStatusChecksPtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesRequiredStatusChecksRequiredCheckOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesRequiredWorkflowsOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesRequiredWorkflowsPtrOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesRequiredWorkflowsRequiredWorkflowArrayOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesTagNamePatternOutput{}) + pulumi.RegisterOutputType(OrganizationRulesetRulesTagNamePatternPtrOutput{}) + pulumi.RegisterOutputType(OrganizationWebhookConfigurationOutput{}) + pulumi.RegisterOutputType(OrganizationWebhookConfigurationPtrOutput{}) + pulumi.RegisterOutputType(ProviderAppAuthOutput{}) + pulumi.RegisterOutputType(ProviderAppAuthPtrOutput{}) + pulumi.RegisterOutputType(RepositoryCollaboratorsIgnoreTeamOutput{}) + pulumi.RegisterOutputType(RepositoryCollaboratorsIgnoreTeamArrayOutput{}) + pulumi.RegisterOutputType(RepositoryCollaboratorsTeamOutput{}) + pulumi.RegisterOutputType(RepositoryCollaboratorsTeamArrayOutput{}) + pulumi.RegisterOutputType(RepositoryCollaboratorsUserOutput{}) + pulumi.RegisterOutputType(RepositoryCollaboratorsUserArrayOutput{}) + pulumi.RegisterOutputType(RepositoryEnvironmentDeploymentBranchPolicyOutput{}) + pulumi.RegisterOutputType(RepositoryEnvironmentDeploymentBranchPolicyPtrOutput{}) + pulumi.RegisterOutputType(RepositoryEnvironmentReviewerOutput{}) + pulumi.RegisterOutputType(RepositoryEnvironmentReviewerArrayOutput{}) + pulumi.RegisterOutputType(RepositoryPagesTypeOutput{}) + pulumi.RegisterOutputType(RepositoryPagesTypePtrOutput{}) + pulumi.RegisterOutputType(RepositoryPagesSourceOutput{}) + pulumi.RegisterOutputType(RepositoryPagesSourcePtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetBypassActorOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetBypassActorArrayOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetConditionsOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetConditionsPtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetConditionsRefNameOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetConditionsRefNamePtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesPtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesBranchNamePatternOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesBranchNamePatternPtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesCommitAuthorEmailPatternOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesCommitAuthorEmailPatternPtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesCommitMessagePatternOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesCommitMessagePatternPtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesCommitterEmailPatternOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesCommitterEmailPatternPtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesCopilotCodeReviewOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesCopilotCodeReviewPtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesFileExtensionRestrictionOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesFileExtensionRestrictionPtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesFilePathRestrictionOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesFilePathRestrictionPtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesMaxFilePathLengthOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesMaxFilePathLengthPtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesMaxFileSizeOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesMaxFileSizePtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesMergeQueueOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesMergeQueuePtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesPullRequestOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesPullRequestPtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesPullRequestRequiredReviewerOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesPullRequestRequiredReviewerArrayOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesPullRequestRequiredReviewerReviewerOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesRequiredCodeScanningOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesRequiredCodeScanningPtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArrayOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesRequiredDeploymentsOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesRequiredDeploymentsPtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesRequiredStatusChecksOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesRequiredStatusChecksPtrOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesRequiredStatusChecksRequiredCheckOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesRequiredStatusChecksRequiredCheckArrayOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesTagNamePatternOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetRulesTagNamePatternPtrOutput{}) + pulumi.RegisterOutputType(RepositorySecurityAndAnalysisOutput{}) + pulumi.RegisterOutputType(RepositorySecurityAndAnalysisPtrOutput{}) + pulumi.RegisterOutputType(RepositorySecurityAndAnalysisAdvancedSecurityOutput{}) + pulumi.RegisterOutputType(RepositorySecurityAndAnalysisAdvancedSecurityPtrOutput{}) + pulumi.RegisterOutputType(RepositorySecurityAndAnalysisCodeSecurityOutput{}) + pulumi.RegisterOutputType(RepositorySecurityAndAnalysisCodeSecurityPtrOutput{}) + pulumi.RegisterOutputType(RepositorySecurityAndAnalysisSecretScanningOutput{}) + pulumi.RegisterOutputType(RepositorySecurityAndAnalysisSecretScanningPtrOutput{}) + pulumi.RegisterOutputType(RepositorySecurityAndAnalysisSecretScanningAiDetectionOutput{}) + pulumi.RegisterOutputType(RepositorySecurityAndAnalysisSecretScanningAiDetectionPtrOutput{}) + pulumi.RegisterOutputType(RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsOutput{}) + pulumi.RegisterOutputType(RepositorySecurityAndAnalysisSecretScanningNonProviderPatternsPtrOutput{}) + pulumi.RegisterOutputType(RepositorySecurityAndAnalysisSecretScanningPushProtectionOutput{}) + pulumi.RegisterOutputType(RepositorySecurityAndAnalysisSecretScanningPushProtectionPtrOutput{}) + pulumi.RegisterOutputType(RepositoryTemplateOutput{}) + pulumi.RegisterOutputType(RepositoryTemplatePtrOutput{}) + pulumi.RegisterOutputType(RepositoryWebhookConfigurationOutput{}) + pulumi.RegisterOutputType(RepositoryWebhookConfigurationPtrOutput{}) + pulumi.RegisterOutputType(TeamMembersMemberOutput{}) + pulumi.RegisterOutputType(TeamMembersMemberArrayOutput{}) + pulumi.RegisterOutputType(TeamSettingsReviewRequestDelegationOutput{}) + pulumi.RegisterOutputType(TeamSettingsReviewRequestDelegationPtrOutput{}) + pulumi.RegisterOutputType(TeamSyncGroupMappingGroupOutput{}) + pulumi.RegisterOutputType(TeamSyncGroupMappingGroupArrayOutput{}) + pulumi.RegisterOutputType(GetActionsEnvironmentSecretsSecretOutput{}) + pulumi.RegisterOutputType(GetActionsEnvironmentSecretsSecretArrayOutput{}) + pulumi.RegisterOutputType(GetActionsEnvironmentVariablesVariableOutput{}) + pulumi.RegisterOutputType(GetActionsEnvironmentVariablesVariableArrayOutput{}) + pulumi.RegisterOutputType(GetActionsOrganizationSecretsSecretOutput{}) + pulumi.RegisterOutputType(GetActionsOrganizationSecretsSecretArrayOutput{}) + pulumi.RegisterOutputType(GetActionsOrganizationVariablesVariableOutput{}) + pulumi.RegisterOutputType(GetActionsOrganizationVariablesVariableArrayOutput{}) + pulumi.RegisterOutputType(GetActionsSecretsSecretOutput{}) + pulumi.RegisterOutputType(GetActionsSecretsSecretArrayOutput{}) + pulumi.RegisterOutputType(GetActionsVariablesVariableOutput{}) + pulumi.RegisterOutputType(GetActionsVariablesVariableArrayOutput{}) + pulumi.RegisterOutputType(GetBranchProtectionRulesRuleOutput{}) + pulumi.RegisterOutputType(GetBranchProtectionRulesRuleArrayOutput{}) + pulumi.RegisterOutputType(GetCodespacesOrganizationSecretsSecretOutput{}) + pulumi.RegisterOutputType(GetCodespacesOrganizationSecretsSecretArrayOutput{}) + pulumi.RegisterOutputType(GetCodespacesSecretsSecretOutput{}) + pulumi.RegisterOutputType(GetCodespacesSecretsSecretArrayOutput{}) + pulumi.RegisterOutputType(GetCodespacesUserSecretsSecretOutput{}) + pulumi.RegisterOutputType(GetCodespacesUserSecretsSecretArrayOutput{}) + pulumi.RegisterOutputType(GetCollaboratorsCollaboratorOutput{}) + pulumi.RegisterOutputType(GetCollaboratorsCollaboratorArrayOutput{}) + pulumi.RegisterOutputType(GetDependabotOrganizationSecretsSecretOutput{}) + pulumi.RegisterOutputType(GetDependabotOrganizationSecretsSecretArrayOutput{}) + pulumi.RegisterOutputType(GetDependabotSecretsSecretOutput{}) + pulumi.RegisterOutputType(GetDependabotSecretsSecretArrayOutput{}) + pulumi.RegisterOutputType(GetExternalGroupsExternalGroupOutput{}) + pulumi.RegisterOutputType(GetExternalGroupsExternalGroupArrayOutput{}) + pulumi.RegisterOutputType(GetIssueLabelsLabelOutput{}) + pulumi.RegisterOutputType(GetIssueLabelsLabelArrayOutput{}) + pulumi.RegisterOutputType(GetOrganizationAppInstallationsInstallationOutput{}) + pulumi.RegisterOutputType(GetOrganizationAppInstallationsInstallationArrayOutput{}) + pulumi.RegisterOutputType(GetOrganizationExternalIdentitiesIdentityOutput{}) + pulumi.RegisterOutputType(GetOrganizationExternalIdentitiesIdentityArrayOutput{}) + pulumi.RegisterOutputType(GetOrganizationIpAllowListIpAllowListOutput{}) + pulumi.RegisterOutputType(GetOrganizationIpAllowListIpAllowListArrayOutput{}) + pulumi.RegisterOutputType(GetOrganizationRepositoryRolesRoleOutput{}) + pulumi.RegisterOutputType(GetOrganizationRepositoryRolesRoleArrayOutput{}) + pulumi.RegisterOutputType(GetOrganizationRoleTeamsTeamOutput{}) + pulumi.RegisterOutputType(GetOrganizationRoleTeamsTeamArrayOutput{}) + pulumi.RegisterOutputType(GetOrganizationRoleUsersUserOutput{}) + pulumi.RegisterOutputType(GetOrganizationRoleUsersUserArrayOutput{}) + pulumi.RegisterOutputType(GetOrganizationRolesRoleOutput{}) + pulumi.RegisterOutputType(GetOrganizationRolesRoleArrayOutput{}) + pulumi.RegisterOutputType(GetOrganizationSecurityManagersTeamOutput{}) + pulumi.RegisterOutputType(GetOrganizationSecurityManagersTeamArrayOutput{}) + pulumi.RegisterOutputType(GetOrganizationTeamSyncGroupsGroupOutput{}) + pulumi.RegisterOutputType(GetOrganizationTeamSyncGroupsGroupArrayOutput{}) + pulumi.RegisterOutputType(GetOrganizationTeamsTeamOutput{}) + pulumi.RegisterOutputType(GetOrganizationTeamsTeamArrayOutput{}) + pulumi.RegisterOutputType(GetOrganizationWebhooksWebhookOutput{}) + pulumi.RegisterOutputType(GetOrganizationWebhooksWebhookArrayOutput{}) + pulumi.RegisterOutputType(GetReleaseAssetOutput{}) + pulumi.RegisterOutputType(GetReleaseAssetArrayOutput{}) + pulumi.RegisterOutputType(GetRepositoryAutolinkReferencesAutolinkReferenceOutput{}) + pulumi.RegisterOutputType(GetRepositoryAutolinkReferencesAutolinkReferenceArrayOutput{}) + pulumi.RegisterOutputType(GetRepositoryBranchesBranchOutput{}) + pulumi.RegisterOutputType(GetRepositoryBranchesBranchArrayOutput{}) + pulumi.RegisterOutputType(GetRepositoryCustomPropertiesPropertyOutput{}) + pulumi.RegisterOutputType(GetRepositoryCustomPropertiesPropertyArrayOutput{}) + pulumi.RegisterOutputType(GetRepositoryDeployKeysKeyOutput{}) + pulumi.RegisterOutputType(GetRepositoryDeployKeysKeyArrayOutput{}) + pulumi.RegisterOutputType(GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyOutput{}) + pulumi.RegisterOutputType(GetRepositoryDeploymentBranchPoliciesDeploymentBranchPolicyArrayOutput{}) + pulumi.RegisterOutputType(GetRepositoryEnvironmentDeploymentPoliciesPolicyOutput{}) + pulumi.RegisterOutputType(GetRepositoryEnvironmentDeploymentPoliciesPolicyArrayOutput{}) + pulumi.RegisterOutputType(GetRepositoryEnvironmentsEnvironmentOutput{}) + pulumi.RegisterOutputType(GetRepositoryEnvironmentsEnvironmentArrayOutput{}) + pulumi.RegisterOutputType(GetRepositoryPageOutput{}) + pulumi.RegisterOutputType(GetRepositoryPageArrayOutput{}) + pulumi.RegisterOutputType(GetRepositoryPageSourceOutput{}) + pulumi.RegisterOutputType(GetRepositoryPageSourceArrayOutput{}) + pulumi.RegisterOutputType(GetRepositoryPagesSourceOutput{}) + pulumi.RegisterOutputType(GetRepositoryPagesSourceArrayOutput{}) + pulumi.RegisterOutputType(GetRepositoryPullRequestsResultOutput{}) + pulumi.RegisterOutputType(GetRepositoryPullRequestsResultArrayOutput{}) + pulumi.RegisterOutputType(GetRepositoryRepositoryLicenseOutput{}) + pulumi.RegisterOutputType(GetRepositoryRepositoryLicenseArrayOutput{}) + pulumi.RegisterOutputType(GetRepositoryRepositoryLicenseLicenseOutput{}) + pulumi.RegisterOutputType(GetRepositoryRepositoryLicenseLicenseArrayOutput{}) + pulumi.RegisterOutputType(GetRepositoryTeamsTeamOutput{}) + pulumi.RegisterOutputType(GetRepositoryTeamsTeamArrayOutput{}) + pulumi.RegisterOutputType(GetRepositoryTemplateOutput{}) + pulumi.RegisterOutputType(GetRepositoryTemplateArrayOutput{}) + pulumi.RegisterOutputType(GetRepositoryWebhooksWebhookOutput{}) + pulumi.RegisterOutputType(GetRepositoryWebhooksWebhookArrayOutput{}) + pulumi.RegisterOutputType(GetTeamRepositoriesDetailedOutput{}) + pulumi.RegisterOutputType(GetTeamRepositoriesDetailedArrayOutput{}) + pulumi.RegisterOutputType(GetTreeEntryOutput{}) + pulumi.RegisterOutputType(GetTreeEntryArrayOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/release.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/release.go new file mode 100644 index 000000000..6aefe3f64 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/release.go @@ -0,0 +1,548 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage a release in a specific +// GitHub repository. +// +// ## Example Usage +// +// ```go +// 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 { +// repo, err := github.NewRepository(ctx, "repo", &github.RepositoryArgs{ +// Name: pulumi.String("repo"), +// Description: pulumi.String("GitHub repo managed by Terraform"), +// Private: pulumi.Bool(false), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRelease(ctx, "example", &github.ReleaseArgs{ +// Repository: repo.Name, +// TagName: pulumi.String("v1.0.0"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ### On Non-Default Branch +// +// ```go +// 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("repo"), +// AutoInit: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// exampleBranch, err := github.NewBranch(ctx, "example", &github.BranchArgs{ +// Repository: example.Name, +// Branch: pulumi.String("branch_name"), +// SourceBranch: example.DefaultBranch, +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRelease(ctx, "example", &github.ReleaseArgs{ +// Repository: example.Name, +// TagName: pulumi.String("v1.0.0"), +// TargetCommitish: exampleBranch.Branch, +// Draft: pulumi.Bool(false), +// Prerelease: pulumi.Bool(false), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using the `name` of the repository, combined with the `id` of the release, and a `:` character for separating components, e.g. +// +// ```sh +// $ pulumi import github:index/release:Release example repo:12345678 +// ``` +type Release struct { + pulumi.CustomResourceState + + // URL that can be provided to API calls displaying the attached assets to this release. + AssetsUrl pulumi.StringOutput `pulumi:"assetsUrl"` + // Text describing the contents of the tag. + Body pulumi.StringPtrOutput `pulumi:"body"` + // This is the date of the commit used for the release, and not the date when the release was drafted or published. + CreatedAt pulumi.StringOutput `pulumi:"createdAt"` + // If specified, a discussion of the specified category is created and linked to the release. The value must be a category that already exists in the repository. For more information, see [Managing categories for discussions in your repository](https://docs.github.com/discussions/managing-discussions-for-your-community/managing-categories-for-discussions-in-your-repository). + DiscussionCategoryName pulumi.StringPtrOutput `pulumi:"discussionCategoryName"` + // Set to `false` to create a published release. + Draft pulumi.BoolPtrOutput `pulumi:"draft"` + Etag pulumi.StringOutput `pulumi:"etag"` + // Set to `true` to automatically generate the name and body for this release. If `name` is specified, the specified `name` will be used; otherwise, a name will be automatically generated. If `body` is specified, the `body` will be pre-pended to the automatically generated notes. + GenerateReleaseNotes pulumi.BoolPtrOutput `pulumi:"generateReleaseNotes"` + // URL of the release in GitHub. + HtmlUrl pulumi.StringOutput `pulumi:"htmlUrl"` + // The name of the release. + Name pulumi.StringOutput `pulumi:"name"` + // GraphQL global node id for use with v4 API + NodeId pulumi.StringOutput `pulumi:"nodeId"` + // Set to `false` to identify the release as a full release. + Prerelease pulumi.BoolPtrOutput `pulumi:"prerelease"` + // This is the date when the release was published. This will be empty if the release is a draft. + PublishedAt pulumi.StringOutput `pulumi:"publishedAt"` + // The ID of the release. + ReleaseId pulumi.IntOutput `pulumi:"releaseId"` + // The name of the repository. + Repository pulumi.StringOutput `pulumi:"repository"` + // The name of the tag. + TagName pulumi.StringOutput `pulumi:"tagName"` + // URL that can be provided to API calls to fetch the release TAR archive. + TarballUrl pulumi.StringOutput `pulumi:"tarballUrl"` + // The branch name or commit SHA the tag is created from. Defaults to the default branch of the repository. + TargetCommitish pulumi.StringPtrOutput `pulumi:"targetCommitish"` + // URL that can be provided to API calls to upload assets. + UploadUrl pulumi.StringOutput `pulumi:"uploadUrl"` + // URL that can be provided to API calls that reference this release. + Url pulumi.StringOutput `pulumi:"url"` + // URL that can be provided to API calls to fetch the release ZIP archive. + ZipballUrl pulumi.StringOutput `pulumi:"zipballUrl"` +} + +// NewRelease registers a new resource with the given unique name, arguments, and options. +func NewRelease(ctx *pulumi.Context, + name string, args *ReleaseArgs, opts ...pulumi.ResourceOption) (*Release, 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.TagName == nil { + return nil, errors.New("invalid value for required argument 'TagName'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource Release + err := ctx.RegisterResource("github:index/release:Release", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRelease gets an existing Release 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 GetRelease(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *ReleaseState, opts ...pulumi.ResourceOption) (*Release, error) { + var resource Release + err := ctx.ReadResource("github:index/release:Release", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering Release resources. +type releaseState struct { + // URL that can be provided to API calls displaying the attached assets to this release. + AssetsUrl *string `pulumi:"assetsUrl"` + // Text describing the contents of the tag. + Body *string `pulumi:"body"` + // This is the date of the commit used for the release, and not the date when the release was drafted or published. + CreatedAt *string `pulumi:"createdAt"` + // If specified, a discussion of the specified category is created and linked to the release. The value must be a category that already exists in the repository. For more information, see [Managing categories for discussions in your repository](https://docs.github.com/discussions/managing-discussions-for-your-community/managing-categories-for-discussions-in-your-repository). + DiscussionCategoryName *string `pulumi:"discussionCategoryName"` + // Set to `false` to create a published release. + Draft *bool `pulumi:"draft"` + Etag *string `pulumi:"etag"` + // Set to `true` to automatically generate the name and body for this release. If `name` is specified, the specified `name` will be used; otherwise, a name will be automatically generated. If `body` is specified, the `body` will be pre-pended to the automatically generated notes. + GenerateReleaseNotes *bool `pulumi:"generateReleaseNotes"` + // URL of the release in GitHub. + HtmlUrl *string `pulumi:"htmlUrl"` + // The name of the release. + Name *string `pulumi:"name"` + // GraphQL global node id for use with v4 API + NodeId *string `pulumi:"nodeId"` + // Set to `false` to identify the release as a full release. + Prerelease *bool `pulumi:"prerelease"` + // This is the date when the release was published. This will be empty if the release is a draft. + PublishedAt *string `pulumi:"publishedAt"` + // The ID of the release. + ReleaseId *int `pulumi:"releaseId"` + // The name of the repository. + Repository *string `pulumi:"repository"` + // The name of the tag. + TagName *string `pulumi:"tagName"` + // URL that can be provided to API calls to fetch the release TAR archive. + TarballUrl *string `pulumi:"tarballUrl"` + // The branch name or commit SHA the tag is created from. Defaults to the default branch of the repository. + TargetCommitish *string `pulumi:"targetCommitish"` + // URL that can be provided to API calls to upload assets. + UploadUrl *string `pulumi:"uploadUrl"` + // URL that can be provided to API calls that reference this release. + Url *string `pulumi:"url"` + // URL that can be provided to API calls to fetch the release ZIP archive. + ZipballUrl *string `pulumi:"zipballUrl"` +} + +type ReleaseState struct { + // URL that can be provided to API calls displaying the attached assets to this release. + AssetsUrl pulumi.StringPtrInput + // Text describing the contents of the tag. + Body pulumi.StringPtrInput + // This is the date of the commit used for the release, and not the date when the release was drafted or published. + CreatedAt pulumi.StringPtrInput + // If specified, a discussion of the specified category is created and linked to the release. The value must be a category that already exists in the repository. For more information, see [Managing categories for discussions in your repository](https://docs.github.com/discussions/managing-discussions-for-your-community/managing-categories-for-discussions-in-your-repository). + DiscussionCategoryName pulumi.StringPtrInput + // Set to `false` to create a published release. + Draft pulumi.BoolPtrInput + Etag pulumi.StringPtrInput + // Set to `true` to automatically generate the name and body for this release. If `name` is specified, the specified `name` will be used; otherwise, a name will be automatically generated. If `body` is specified, the `body` will be pre-pended to the automatically generated notes. + GenerateReleaseNotes pulumi.BoolPtrInput + // URL of the release in GitHub. + HtmlUrl pulumi.StringPtrInput + // The name of the release. + Name pulumi.StringPtrInput + // GraphQL global node id for use with v4 API + NodeId pulumi.StringPtrInput + // Set to `false` to identify the release as a full release. + Prerelease pulumi.BoolPtrInput + // This is the date when the release was published. This will be empty if the release is a draft. + PublishedAt pulumi.StringPtrInput + // The ID of the release. + ReleaseId pulumi.IntPtrInput + // The name of the repository. + Repository pulumi.StringPtrInput + // The name of the tag. + TagName pulumi.StringPtrInput + // URL that can be provided to API calls to fetch the release TAR archive. + TarballUrl pulumi.StringPtrInput + // The branch name or commit SHA the tag is created from. Defaults to the default branch of the repository. + TargetCommitish pulumi.StringPtrInput + // URL that can be provided to API calls to upload assets. + UploadUrl pulumi.StringPtrInput + // URL that can be provided to API calls that reference this release. + Url pulumi.StringPtrInput + // URL that can be provided to API calls to fetch the release ZIP archive. + ZipballUrl pulumi.StringPtrInput +} + +func (ReleaseState) ElementType() reflect.Type { + return reflect.TypeOf((*releaseState)(nil)).Elem() +} + +type releaseArgs struct { + // Text describing the contents of the tag. + Body *string `pulumi:"body"` + // If specified, a discussion of the specified category is created and linked to the release. The value must be a category that already exists in the repository. For more information, see [Managing categories for discussions in your repository](https://docs.github.com/discussions/managing-discussions-for-your-community/managing-categories-for-discussions-in-your-repository). + DiscussionCategoryName *string `pulumi:"discussionCategoryName"` + // Set to `false` to create a published release. + Draft *bool `pulumi:"draft"` + // Set to `true` to automatically generate the name and body for this release. If `name` is specified, the specified `name` will be used; otherwise, a name will be automatically generated. If `body` is specified, the `body` will be pre-pended to the automatically generated notes. + GenerateReleaseNotes *bool `pulumi:"generateReleaseNotes"` + // The name of the release. + Name *string `pulumi:"name"` + // Set to `false` to identify the release as a full release. + Prerelease *bool `pulumi:"prerelease"` + // The name of the repository. + Repository string `pulumi:"repository"` + // The name of the tag. + TagName string `pulumi:"tagName"` + // The branch name or commit SHA the tag is created from. Defaults to the default branch of the repository. + TargetCommitish *string `pulumi:"targetCommitish"` +} + +// The set of arguments for constructing a Release resource. +type ReleaseArgs struct { + // Text describing the contents of the tag. + Body pulumi.StringPtrInput + // If specified, a discussion of the specified category is created and linked to the release. The value must be a category that already exists in the repository. For more information, see [Managing categories for discussions in your repository](https://docs.github.com/discussions/managing-discussions-for-your-community/managing-categories-for-discussions-in-your-repository). + DiscussionCategoryName pulumi.StringPtrInput + // Set to `false` to create a published release. + Draft pulumi.BoolPtrInput + // Set to `true` to automatically generate the name and body for this release. If `name` is specified, the specified `name` will be used; otherwise, a name will be automatically generated. If `body` is specified, the `body` will be pre-pended to the automatically generated notes. + GenerateReleaseNotes pulumi.BoolPtrInput + // The name of the release. + Name pulumi.StringPtrInput + // Set to `false` to identify the release as a full release. + Prerelease pulumi.BoolPtrInput + // The name of the repository. + Repository pulumi.StringInput + // The name of the tag. + TagName pulumi.StringInput + // The branch name or commit SHA the tag is created from. Defaults to the default branch of the repository. + TargetCommitish pulumi.StringPtrInput +} + +func (ReleaseArgs) ElementType() reflect.Type { + return reflect.TypeOf((*releaseArgs)(nil)).Elem() +} + +type ReleaseInput interface { + pulumi.Input + + ToReleaseOutput() ReleaseOutput + ToReleaseOutputWithContext(ctx context.Context) ReleaseOutput +} + +func (*Release) ElementType() reflect.Type { + return reflect.TypeOf((**Release)(nil)).Elem() +} + +func (i *Release) ToReleaseOutput() ReleaseOutput { + return i.ToReleaseOutputWithContext(context.Background()) +} + +func (i *Release) ToReleaseOutputWithContext(ctx context.Context) ReleaseOutput { + return pulumi.ToOutputWithContext(ctx, i).(ReleaseOutput) +} + +// ReleaseArrayInput is an input type that accepts ReleaseArray and ReleaseArrayOutput values. +// You can construct a concrete instance of `ReleaseArrayInput` via: +// +// ReleaseArray{ ReleaseArgs{...} } +type ReleaseArrayInput interface { + pulumi.Input + + ToReleaseArrayOutput() ReleaseArrayOutput + ToReleaseArrayOutputWithContext(context.Context) ReleaseArrayOutput +} + +type ReleaseArray []ReleaseInput + +func (ReleaseArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Release)(nil)).Elem() +} + +func (i ReleaseArray) ToReleaseArrayOutput() ReleaseArrayOutput { + return i.ToReleaseArrayOutputWithContext(context.Background()) +} + +func (i ReleaseArray) ToReleaseArrayOutputWithContext(ctx context.Context) ReleaseArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(ReleaseArrayOutput) +} + +// ReleaseMapInput is an input type that accepts ReleaseMap and ReleaseMapOutput values. +// You can construct a concrete instance of `ReleaseMapInput` via: +// +// ReleaseMap{ "key": ReleaseArgs{...} } +type ReleaseMapInput interface { + pulumi.Input + + ToReleaseMapOutput() ReleaseMapOutput + ToReleaseMapOutputWithContext(context.Context) ReleaseMapOutput +} + +type ReleaseMap map[string]ReleaseInput + +func (ReleaseMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Release)(nil)).Elem() +} + +func (i ReleaseMap) ToReleaseMapOutput() ReleaseMapOutput { + return i.ToReleaseMapOutputWithContext(context.Background()) +} + +func (i ReleaseMap) ToReleaseMapOutputWithContext(ctx context.Context) ReleaseMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(ReleaseMapOutput) +} + +type ReleaseOutput struct{ *pulumi.OutputState } + +func (ReleaseOutput) ElementType() reflect.Type { + return reflect.TypeOf((**Release)(nil)).Elem() +} + +func (o ReleaseOutput) ToReleaseOutput() ReleaseOutput { + return o +} + +func (o ReleaseOutput) ToReleaseOutputWithContext(ctx context.Context) ReleaseOutput { + return o +} + +// URL that can be provided to API calls displaying the attached assets to this release. +func (o ReleaseOutput) AssetsUrl() pulumi.StringOutput { + return o.ApplyT(func(v *Release) pulumi.StringOutput { return v.AssetsUrl }).(pulumi.StringOutput) +} + +// Text describing the contents of the tag. +func (o ReleaseOutput) Body() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Release) pulumi.StringPtrOutput { return v.Body }).(pulumi.StringPtrOutput) +} + +// This is the date of the commit used for the release, and not the date when the release was drafted or published. +func (o ReleaseOutput) CreatedAt() pulumi.StringOutput { + return o.ApplyT(func(v *Release) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput) +} + +// If specified, a discussion of the specified category is created and linked to the release. The value must be a category that already exists in the repository. For more information, see [Managing categories for discussions in your repository](https://docs.github.com/discussions/managing-discussions-for-your-community/managing-categories-for-discussions-in-your-repository). +func (o ReleaseOutput) DiscussionCategoryName() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Release) pulumi.StringPtrOutput { return v.DiscussionCategoryName }).(pulumi.StringPtrOutput) +} + +// Set to `false` to create a published release. +func (o ReleaseOutput) Draft() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Release) pulumi.BoolPtrOutput { return v.Draft }).(pulumi.BoolPtrOutput) +} + +func (o ReleaseOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *Release) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// Set to `true` to automatically generate the name and body for this release. If `name` is specified, the specified `name` will be used; otherwise, a name will be automatically generated. If `body` is specified, the `body` will be pre-pended to the automatically generated notes. +func (o ReleaseOutput) GenerateReleaseNotes() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Release) pulumi.BoolPtrOutput { return v.GenerateReleaseNotes }).(pulumi.BoolPtrOutput) +} + +// URL of the release in GitHub. +func (o ReleaseOutput) HtmlUrl() pulumi.StringOutput { + return o.ApplyT(func(v *Release) pulumi.StringOutput { return v.HtmlUrl }).(pulumi.StringOutput) +} + +// The name of the release. +func (o ReleaseOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *Release) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// GraphQL global node id for use with v4 API +func (o ReleaseOutput) NodeId() pulumi.StringOutput { + return o.ApplyT(func(v *Release) pulumi.StringOutput { return v.NodeId }).(pulumi.StringOutput) +} + +// Set to `false` to identify the release as a full release. +func (o ReleaseOutput) Prerelease() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Release) pulumi.BoolPtrOutput { return v.Prerelease }).(pulumi.BoolPtrOutput) +} + +// This is the date when the release was published. This will be empty if the release is a draft. +func (o ReleaseOutput) PublishedAt() pulumi.StringOutput { + return o.ApplyT(func(v *Release) pulumi.StringOutput { return v.PublishedAt }).(pulumi.StringOutput) +} + +// The ID of the release. +func (o ReleaseOutput) ReleaseId() pulumi.IntOutput { + return o.ApplyT(func(v *Release) pulumi.IntOutput { return v.ReleaseId }).(pulumi.IntOutput) +} + +// The name of the repository. +func (o ReleaseOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *Release) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// The name of the tag. +func (o ReleaseOutput) TagName() pulumi.StringOutput { + return o.ApplyT(func(v *Release) pulumi.StringOutput { return v.TagName }).(pulumi.StringOutput) +} + +// URL that can be provided to API calls to fetch the release TAR archive. +func (o ReleaseOutput) TarballUrl() pulumi.StringOutput { + return o.ApplyT(func(v *Release) pulumi.StringOutput { return v.TarballUrl }).(pulumi.StringOutput) +} + +// The branch name or commit SHA the tag is created from. Defaults to the default branch of the repository. +func (o ReleaseOutput) TargetCommitish() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Release) pulumi.StringPtrOutput { return v.TargetCommitish }).(pulumi.StringPtrOutput) +} + +// URL that can be provided to API calls to upload assets. +func (o ReleaseOutput) UploadUrl() pulumi.StringOutput { + return o.ApplyT(func(v *Release) pulumi.StringOutput { return v.UploadUrl }).(pulumi.StringOutput) +} + +// URL that can be provided to API calls that reference this release. +func (o ReleaseOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v *Release) pulumi.StringOutput { return v.Url }).(pulumi.StringOutput) +} + +// URL that can be provided to API calls to fetch the release ZIP archive. +func (o ReleaseOutput) ZipballUrl() pulumi.StringOutput { + return o.ApplyT(func(v *Release) pulumi.StringOutput { return v.ZipballUrl }).(pulumi.StringOutput) +} + +type ReleaseArrayOutput struct{ *pulumi.OutputState } + +func (ReleaseArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Release)(nil)).Elem() +} + +func (o ReleaseArrayOutput) ToReleaseArrayOutput() ReleaseArrayOutput { + return o +} + +func (o ReleaseArrayOutput) ToReleaseArrayOutputWithContext(ctx context.Context) ReleaseArrayOutput { + return o +} + +func (o ReleaseArrayOutput) Index(i pulumi.IntInput) ReleaseOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Release { + return vs[0].([]*Release)[vs[1].(int)] + }).(ReleaseOutput) +} + +type ReleaseMapOutput struct{ *pulumi.OutputState } + +func (ReleaseMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Release)(nil)).Elem() +} + +func (o ReleaseMapOutput) ToReleaseMapOutput() ReleaseMapOutput { + return o +} + +func (o ReleaseMapOutput) ToReleaseMapOutputWithContext(ctx context.Context) ReleaseMapOutput { + return o +} + +func (o ReleaseMapOutput) MapIndex(k pulumi.StringInput) ReleaseOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Release { + return vs[0].(map[string]*Release)[vs[1].(string)] + }).(ReleaseOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*ReleaseInput)(nil)).Elem(), &Release{}) + pulumi.RegisterInputType(reflect.TypeOf((*ReleaseArrayInput)(nil)).Elem(), ReleaseArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*ReleaseMapInput)(nil)).Elem(), ReleaseMap{}) + pulumi.RegisterOutputType(ReleaseOutput{}) + pulumi.RegisterOutputType(ReleaseArrayOutput{}) + pulumi.RegisterOutputType(ReleaseMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repository.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repository.go new file mode 100644 index 000000000..1913c7699 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repository.go @@ -0,0 +1,1066 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage repositories within your +// GitHub organization or personal account. +// +// > **Note** When used with GitHub App authentication, even GET requests must have the `contents:write` permission. Without it, the following arguments will be ignored, leading to unexpected behavior and confusing diffs: `allowMergeCommit`, `allowSquashMerge`, `allowRebaseMerge`, `mergeCommitTitle`, `mergeCommitMessage`, `squashMergeCommitTitle` and `squashMergeCommitMessage`. +// +// ## Example Usage +// +// ```go +// 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.NewRepository(ctx, "example", &github.RepositoryArgs{ +// Name: pulumi.String("example"), +// Description: pulumi.String("My awesome codebase"), +// Visibility: pulumi.String("public"), +// Template: &github.RepositoryTemplateArgs{ +// Owner: pulumi.String("github"), +// Repository: pulumi.String("terraform-template-module"), +// IncludeAllBranches: pulumi.Bool(true), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ### With Repository Forking +// +// ```go +// 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.NewRepository(ctx, "forked_repo", &github.RepositoryArgs{ +// Name: pulumi.String("forked-repository"), +// Description: pulumi.String("This is a fork of another repository"), +// Fork: pulumi.String("true"), +// SourceOwner: pulumi.String("some-org"), +// SourceRepo: pulumi.String("original-repository"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// Repositories can be imported using the `name`, e.g. +// +// ```sh +// $ pulumi import github:index/repository:Repository terraform myrepo +// ``` +type Repository struct { + pulumi.CustomResourceState + + // Set to `true` to allow auto-merging pull requests on the repository. + AllowAutoMerge pulumi.BoolPtrOutput `pulumi:"allowAutoMerge"` + // Configure private forking for organization owned private and internal repositories; set to `true` to enable, `false` to disable, and leave unset for the default behaviour. Configuring this requires that private forking is not being explicitly configured at the organization level. + AllowForking pulumi.BoolOutput `pulumi:"allowForking"` + // Set to `false` to disable merge commits on the repository. + AllowMergeCommit pulumi.BoolPtrOutput `pulumi:"allowMergeCommit"` + // Set to `false` to disable rebase merges on the repository. + AllowRebaseMerge pulumi.BoolPtrOutput `pulumi:"allowRebaseMerge"` + // Set to `false` to disable squash merges on the repository. + AllowSquashMerge pulumi.BoolPtrOutput `pulumi:"allowSquashMerge"` + // Set to `true` to always suggest updating pull request branches. + AllowUpdateBranch pulumi.BoolPtrOutput `pulumi:"allowUpdateBranch"` + // Set to `true` to archive the repository instead of deleting on destroy. + ArchiveOnDestroy pulumi.BoolPtrOutput `pulumi:"archiveOnDestroy"` + // Specifies if the repository should be archived. Defaults to `false`. **NOTE** Currently, the API does not support unarchiving. + Archived pulumi.BoolPtrOutput `pulumi:"archived"` + // Set to `true` to produce an initial commit in the repository. + AutoInit pulumi.BoolPtrOutput `pulumi:"autoInit"` + // (Deprecated: Use `BranchDefault` resource instead) The name of the default branch of the repository. **NOTE:** This can only be set after a repository has already been created, + // and after a correct reference has been created for the target branch inside the repository. This means a user will have to omit this parameter from the + // initial repository creation and create the target branch inside of the repository prior to setting this attribute. + // + // Deprecated: Use the BranchDefault resource instead + DefaultBranch pulumi.StringOutput `pulumi:"defaultBranch"` + // Automatically delete head branch after a pull request is merged. Defaults to `false`. + DeleteBranchOnMerge pulumi.BoolPtrOutput `pulumi:"deleteBranchOnMerge"` + // A description of the repository. + Description pulumi.StringPtrOutput `pulumi:"description"` + Etag pulumi.StringOutput `pulumi:"etag"` + // Set to `true` to create a fork of an existing repository. When set to `true`, both `sourceOwner` and `sourceRepo` must also be specified. + Fork pulumi.StringOutput `pulumi:"fork"` + // A string of the form "orgname/reponame". + FullName pulumi.StringOutput `pulumi:"fullName"` + // URL that can be provided to `git clone` to clone the repository anonymously via the git protocol. + GitCloneUrl pulumi.StringOutput `pulumi:"gitCloneUrl"` + // Use the [name of the template](https://github.com/github/gitignore) without the extension. For example, "Haskell". + GitignoreTemplate pulumi.StringPtrOutput `pulumi:"gitignoreTemplate"` + // Set to `true` to enable GitHub Discussions on the repository. Defaults to `false`. + HasDiscussions pulumi.BoolPtrOutput `pulumi:"hasDiscussions"` + // (Optional) Set to `true` to enable the (deprecated) downloads features on the repository. This attribute is no longer in use, but it hasn't been removed yet. It will be removed in a future version. See [this discussion](https://github.com/orgs/community/discussions/102145#discussioncomment-8351756). + // + // Deprecated: This attribute is no longer in use, but it hasn't been removed yet. It will be removed in a future version. See https://github.com/orgs/community/discussions/102145#discussioncomment-8351756 + HasDownloads pulumi.BoolPtrOutput `pulumi:"hasDownloads"` + // Set to `true` to enable the GitHub Issues features + // on the repository. + HasIssues pulumi.BoolPtrOutput `pulumi:"hasIssues"` + // Set to `true` to enable the GitHub Projects features on the repository. Per the GitHub [documentation](https://developer.github.com/v3/repos/#create) when in an organization that has disabled repository projects it will default to `false` and will otherwise default to `true`. If you specify `true` when it has been disabled it will return an error. + HasProjects pulumi.BoolPtrOutput `pulumi:"hasProjects"` + // Set to `true` to enable the GitHub Wiki features on + // the repository. + HasWiki pulumi.BoolPtrOutput `pulumi:"hasWiki"` + // URL of a page describing the project. + HomepageUrl pulumi.StringPtrOutput `pulumi:"homepageUrl"` + // The absolute URL (including scheme) of the rendered GitHub Pages site e.g. `https://username.github.io`. + HtmlUrl pulumi.StringOutput `pulumi:"htmlUrl"` + // URL that can be provided to `git clone` to clone the repository via HTTPS. + HttpCloneUrl pulumi.StringOutput `pulumi:"httpCloneUrl"` + // (Optional) - This is ignored as the provider now handles lack of permissions automatically. This field will be removed in a future version. + // + // Deprecated: This is ignored as the provider now handles lack of permissions automatically. This field will be removed in a future version. + IgnoreVulnerabilityAlertsDuringRead pulumi.BoolPtrOutput `pulumi:"ignoreVulnerabilityAlertsDuringRead"` + // Set to `true` to tell GitHub that this is a template repository. + IsTemplate pulumi.BoolPtrOutput `pulumi:"isTemplate"` + // Use the [name of the template](https://github.com/github/choosealicense.com/tree/gh-pages/_licenses) without the extension. For example, "mit" or "mpl-2.0". + LicenseTemplate pulumi.StringPtrOutput `pulumi:"licenseTemplate"` + // Can be `PR_BODY`, `PR_TITLE`, or `BLANK` for a default merge commit message. Applicable only if `allowMergeCommit` is `true`. + MergeCommitMessage pulumi.StringPtrOutput `pulumi:"mergeCommitMessage"` + // Can be `PR_TITLE` or `MERGE_MESSAGE` for a default merge commit title. Applicable only if `allowMergeCommit` is `true`. + MergeCommitTitle pulumi.StringPtrOutput `pulumi:"mergeCommitTitle"` + // The name of the repository. + Name pulumi.StringOutput `pulumi:"name"` + // GraphQL global node id for use with v4 API + NodeId pulumi.StringOutput `pulumi:"nodeId"` + // (**DEPRECATED**) The repository's GitHub Pages configuration. Use the `RepositoryPages` resource instead. This field will be removed in a future version. See GitHub Pages Configuration below for details. + // + // Deprecated: Use the RepositoryPages resource instead. This field will be removed in a future version. + Pages RepositoryPagesTypePtrOutput `pulumi:"pages"` + // The primary language used in the repository. + PrimaryLanguage pulumi.StringOutput `pulumi:"primaryLanguage"` + // Set to `true` to create a private repository. + // Repositories are created as public (e.g. open source) by default. + // + // Deprecated: use visibility instead + Private pulumi.BoolOutput `pulumi:"private"` + // GitHub ID for the repository + RepoId pulumi.IntOutput `pulumi:"repoId"` + // The repository's [security and analysis](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/enabling-features-for-your-repository/managing-security-and-analysis-settings-for-your-repository) configuration. See Security and Analysis Configuration below for details. + SecurityAndAnalysis RepositorySecurityAndAnalysisOutput `pulumi:"securityAndAnalysis"` + // The GitHub username or organization that owns the repository being forked. Required when `fork` is `true`. + SourceOwner pulumi.StringOutput `pulumi:"sourceOwner"` + // The name of the repository to fork. Required when `fork` is `true`. + SourceRepo pulumi.StringOutput `pulumi:"sourceRepo"` + // Can be `PR_BODY`, `COMMIT_MESSAGES`, or `BLANK` for a default squash merge commit message. Applicable only if `allowSquashMerge` is `true`. + SquashMergeCommitMessage pulumi.StringPtrOutput `pulumi:"squashMergeCommitMessage"` + // Can be `PR_TITLE` or `COMMIT_OR_PR_TITLE` for a default squash merge commit title. Applicable only if `allowSquashMerge` is `true`. + SquashMergeCommitTitle pulumi.StringPtrOutput `pulumi:"squashMergeCommitTitle"` + // URL that can be provided to `git clone` to clone the repository via SSH. + SshCloneUrl pulumi.StringOutput `pulumi:"sshCloneUrl"` + // URL that can be provided to `svn checkout` to check out the repository via GitHub's Subversion protocol emulation. + SvnUrl pulumi.StringOutput `pulumi:"svnUrl"` + // Use a template repository to create this resource. See Template Repositories below for details. + Template RepositoryTemplatePtrOutput `pulumi:"template"` + // The list of topics of the repository. + // + // > Note: This attribute is not compatible with the `RepositoryTopics` resource. Use one of them. `RepositoryTopics` is only meant to be used if the repository itself is not handled via terraform, for example if it's only read as a datasource (see issue #1845). + Topics pulumi.StringArrayOutput `pulumi:"topics"` + // Can be `public` or `private`. If your organization is associated with an enterprise account using GitHub Enterprise Cloud or GitHub Enterprise Server 2.20+, visibility can also be `internal`. The `visibility` parameter overrides the `private` parameter. + Visibility pulumi.StringOutput `pulumi:"visibility"` + // (**DEPRECATED**) Configure [Dependabot security alerts](https://help.github.com/en/github/managing-security-vulnerabilities/about-security-alerts-for-vulnerable-dependencies) for vulnerable dependencies; set to `true` to enable, set to `false` to disable, and leave unset for the default behavior. Configuring this requires that alerts are not being explicitly configured at the organization level. This field will be removed in a future version. Use the `RepositoryVulnerabilityAlerts` resource instead. + // + // Deprecated: Use the RepositoryVulnerabilityAlerts resource instead. This field will be removed in a future version. + VulnerabilityAlerts pulumi.BoolOutput `pulumi:"vulnerabilityAlerts"` + // Require contributors to sign off on web-based commits. See more in the [GitHub documentation](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/managing-repository-settings/managing-the-commit-signoff-policy-for-your-repository). + WebCommitSignoffRequired pulumi.BoolOutput `pulumi:"webCommitSignoffRequired"` +} + +// NewRepository registers a new resource with the given unique name, arguments, and options. +func NewRepository(ctx *pulumi.Context, + name string, args *RepositoryArgs, opts ...pulumi.ResourceOption) (*Repository, error) { + if args == nil { + args = &RepositoryArgs{} + } + + opts = internal.PkgResourceDefaultOpts(opts) + var resource Repository + err := ctx.RegisterResource("github:index/repository:Repository", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepository gets an existing Repository 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 GetRepository(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryState, opts ...pulumi.ResourceOption) (*Repository, error) { + var resource Repository + err := ctx.ReadResource("github:index/repository:Repository", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering Repository resources. +type repositoryState struct { + // Set to `true` to allow auto-merging pull requests on the repository. + AllowAutoMerge *bool `pulumi:"allowAutoMerge"` + // Configure private forking for organization owned private and internal repositories; set to `true` to enable, `false` to disable, and leave unset for the default behaviour. Configuring this requires that private forking is not being explicitly configured at the organization level. + AllowForking *bool `pulumi:"allowForking"` + // Set to `false` to disable merge commits on the repository. + AllowMergeCommit *bool `pulumi:"allowMergeCommit"` + // Set to `false` to disable rebase merges on the repository. + AllowRebaseMerge *bool `pulumi:"allowRebaseMerge"` + // Set to `false` to disable squash merges on the repository. + AllowSquashMerge *bool `pulumi:"allowSquashMerge"` + // Set to `true` to always suggest updating pull request branches. + AllowUpdateBranch *bool `pulumi:"allowUpdateBranch"` + // Set to `true` to archive the repository instead of deleting on destroy. + ArchiveOnDestroy *bool `pulumi:"archiveOnDestroy"` + // Specifies if the repository should be archived. Defaults to `false`. **NOTE** Currently, the API does not support unarchiving. + Archived *bool `pulumi:"archived"` + // Set to `true` to produce an initial commit in the repository. + AutoInit *bool `pulumi:"autoInit"` + // (Deprecated: Use `BranchDefault` resource instead) The name of the default branch of the repository. **NOTE:** This can only be set after a repository has already been created, + // and after a correct reference has been created for the target branch inside the repository. This means a user will have to omit this parameter from the + // initial repository creation and create the target branch inside of the repository prior to setting this attribute. + // + // Deprecated: Use the BranchDefault resource instead + DefaultBranch *string `pulumi:"defaultBranch"` + // Automatically delete head branch after a pull request is merged. Defaults to `false`. + DeleteBranchOnMerge *bool `pulumi:"deleteBranchOnMerge"` + // A description of the repository. + Description *string `pulumi:"description"` + Etag *string `pulumi:"etag"` + // Set to `true` to create a fork of an existing repository. When set to `true`, both `sourceOwner` and `sourceRepo` must also be specified. + Fork *string `pulumi:"fork"` + // A string of the form "orgname/reponame". + FullName *string `pulumi:"fullName"` + // URL that can be provided to `git clone` to clone the repository anonymously via the git protocol. + GitCloneUrl *string `pulumi:"gitCloneUrl"` + // Use the [name of the template](https://github.com/github/gitignore) without the extension. For example, "Haskell". + GitignoreTemplate *string `pulumi:"gitignoreTemplate"` + // Set to `true` to enable GitHub Discussions on the repository. Defaults to `false`. + HasDiscussions *bool `pulumi:"hasDiscussions"` + // (Optional) Set to `true` to enable the (deprecated) downloads features on the repository. This attribute is no longer in use, but it hasn't been removed yet. It will be removed in a future version. See [this discussion](https://github.com/orgs/community/discussions/102145#discussioncomment-8351756). + // + // Deprecated: This attribute is no longer in use, but it hasn't been removed yet. It will be removed in a future version. See https://github.com/orgs/community/discussions/102145#discussioncomment-8351756 + HasDownloads *bool `pulumi:"hasDownloads"` + // Set to `true` to enable the GitHub Issues features + // on the repository. + HasIssues *bool `pulumi:"hasIssues"` + // Set to `true` to enable the GitHub Projects features on the repository. Per the GitHub [documentation](https://developer.github.com/v3/repos/#create) when in an organization that has disabled repository projects it will default to `false` and will otherwise default to `true`. If you specify `true` when it has been disabled it will return an error. + HasProjects *bool `pulumi:"hasProjects"` + // Set to `true` to enable the GitHub Wiki features on + // the repository. + HasWiki *bool `pulumi:"hasWiki"` + // URL of a page describing the project. + HomepageUrl *string `pulumi:"homepageUrl"` + // The absolute URL (including scheme) of the rendered GitHub Pages site e.g. `https://username.github.io`. + HtmlUrl *string `pulumi:"htmlUrl"` + // URL that can be provided to `git clone` to clone the repository via HTTPS. + HttpCloneUrl *string `pulumi:"httpCloneUrl"` + // (Optional) - This is ignored as the provider now handles lack of permissions automatically. This field will be removed in a future version. + // + // Deprecated: This is ignored as the provider now handles lack of permissions automatically. This field will be removed in a future version. + IgnoreVulnerabilityAlertsDuringRead *bool `pulumi:"ignoreVulnerabilityAlertsDuringRead"` + // Set to `true` to tell GitHub that this is a template repository. + IsTemplate *bool `pulumi:"isTemplate"` + // Use the [name of the template](https://github.com/github/choosealicense.com/tree/gh-pages/_licenses) without the extension. For example, "mit" or "mpl-2.0". + LicenseTemplate *string `pulumi:"licenseTemplate"` + // Can be `PR_BODY`, `PR_TITLE`, or `BLANK` for a default merge commit message. Applicable only if `allowMergeCommit` is `true`. + MergeCommitMessage *string `pulumi:"mergeCommitMessage"` + // Can be `PR_TITLE` or `MERGE_MESSAGE` for a default merge commit title. Applicable only if `allowMergeCommit` is `true`. + MergeCommitTitle *string `pulumi:"mergeCommitTitle"` + // The name of the repository. + Name *string `pulumi:"name"` + // GraphQL global node id for use with v4 API + NodeId *string `pulumi:"nodeId"` + // (**DEPRECATED**) The repository's GitHub Pages configuration. Use the `RepositoryPages` resource instead. This field will be removed in a future version. See GitHub Pages Configuration below for details. + // + // Deprecated: Use the RepositoryPages resource instead. This field will be removed in a future version. + Pages *RepositoryPagesType `pulumi:"pages"` + // The primary language used in the repository. + PrimaryLanguage *string `pulumi:"primaryLanguage"` + // Set to `true` to create a private repository. + // Repositories are created as public (e.g. open source) by default. + // + // Deprecated: use visibility instead + Private *bool `pulumi:"private"` + // GitHub ID for the repository + RepoId *int `pulumi:"repoId"` + // The repository's [security and analysis](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/enabling-features-for-your-repository/managing-security-and-analysis-settings-for-your-repository) configuration. See Security and Analysis Configuration below for details. + SecurityAndAnalysis *RepositorySecurityAndAnalysis `pulumi:"securityAndAnalysis"` + // The GitHub username or organization that owns the repository being forked. Required when `fork` is `true`. + SourceOwner *string `pulumi:"sourceOwner"` + // The name of the repository to fork. Required when `fork` is `true`. + SourceRepo *string `pulumi:"sourceRepo"` + // Can be `PR_BODY`, `COMMIT_MESSAGES`, or `BLANK` for a default squash merge commit message. Applicable only if `allowSquashMerge` is `true`. + SquashMergeCommitMessage *string `pulumi:"squashMergeCommitMessage"` + // Can be `PR_TITLE` or `COMMIT_OR_PR_TITLE` for a default squash merge commit title. Applicable only if `allowSquashMerge` is `true`. + SquashMergeCommitTitle *string `pulumi:"squashMergeCommitTitle"` + // URL that can be provided to `git clone` to clone the repository via SSH. + SshCloneUrl *string `pulumi:"sshCloneUrl"` + // URL that can be provided to `svn checkout` to check out the repository via GitHub's Subversion protocol emulation. + SvnUrl *string `pulumi:"svnUrl"` + // Use a template repository to create this resource. See Template Repositories below for details. + Template *RepositoryTemplate `pulumi:"template"` + // The list of topics of the repository. + // + // > Note: This attribute is not compatible with the `RepositoryTopics` resource. Use one of them. `RepositoryTopics` is only meant to be used if the repository itself is not handled via terraform, for example if it's only read as a datasource (see issue #1845). + Topics []string `pulumi:"topics"` + // Can be `public` or `private`. If your organization is associated with an enterprise account using GitHub Enterprise Cloud or GitHub Enterprise Server 2.20+, visibility can also be `internal`. The `visibility` parameter overrides the `private` parameter. + Visibility *string `pulumi:"visibility"` + // (**DEPRECATED**) Configure [Dependabot security alerts](https://help.github.com/en/github/managing-security-vulnerabilities/about-security-alerts-for-vulnerable-dependencies) for vulnerable dependencies; set to `true` to enable, set to `false` to disable, and leave unset for the default behavior. Configuring this requires that alerts are not being explicitly configured at the organization level. This field will be removed in a future version. Use the `RepositoryVulnerabilityAlerts` resource instead. + // + // Deprecated: Use the RepositoryVulnerabilityAlerts resource instead. This field will be removed in a future version. + VulnerabilityAlerts *bool `pulumi:"vulnerabilityAlerts"` + // Require contributors to sign off on web-based commits. See more in the [GitHub documentation](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/managing-repository-settings/managing-the-commit-signoff-policy-for-your-repository). + WebCommitSignoffRequired *bool `pulumi:"webCommitSignoffRequired"` +} + +type RepositoryState struct { + // Set to `true` to allow auto-merging pull requests on the repository. + AllowAutoMerge pulumi.BoolPtrInput + // Configure private forking for organization owned private and internal repositories; set to `true` to enable, `false` to disable, and leave unset for the default behaviour. Configuring this requires that private forking is not being explicitly configured at the organization level. + AllowForking pulumi.BoolPtrInput + // Set to `false` to disable merge commits on the repository. + AllowMergeCommit pulumi.BoolPtrInput + // Set to `false` to disable rebase merges on the repository. + AllowRebaseMerge pulumi.BoolPtrInput + // Set to `false` to disable squash merges on the repository. + AllowSquashMerge pulumi.BoolPtrInput + // Set to `true` to always suggest updating pull request branches. + AllowUpdateBranch pulumi.BoolPtrInput + // Set to `true` to archive the repository instead of deleting on destroy. + ArchiveOnDestroy pulumi.BoolPtrInput + // Specifies if the repository should be archived. Defaults to `false`. **NOTE** Currently, the API does not support unarchiving. + Archived pulumi.BoolPtrInput + // Set to `true` to produce an initial commit in the repository. + AutoInit pulumi.BoolPtrInput + // (Deprecated: Use `BranchDefault` resource instead) The name of the default branch of the repository. **NOTE:** This can only be set after a repository has already been created, + // and after a correct reference has been created for the target branch inside the repository. This means a user will have to omit this parameter from the + // initial repository creation and create the target branch inside of the repository prior to setting this attribute. + // + // Deprecated: Use the BranchDefault resource instead + DefaultBranch pulumi.StringPtrInput + // Automatically delete head branch after a pull request is merged. Defaults to `false`. + DeleteBranchOnMerge pulumi.BoolPtrInput + // A description of the repository. + Description pulumi.StringPtrInput + Etag pulumi.StringPtrInput + // Set to `true` to create a fork of an existing repository. When set to `true`, both `sourceOwner` and `sourceRepo` must also be specified. + Fork pulumi.StringPtrInput + // A string of the form "orgname/reponame". + FullName pulumi.StringPtrInput + // URL that can be provided to `git clone` to clone the repository anonymously via the git protocol. + GitCloneUrl pulumi.StringPtrInput + // Use the [name of the template](https://github.com/github/gitignore) without the extension. For example, "Haskell". + GitignoreTemplate pulumi.StringPtrInput + // Set to `true` to enable GitHub Discussions on the repository. Defaults to `false`. + HasDiscussions pulumi.BoolPtrInput + // (Optional) Set to `true` to enable the (deprecated) downloads features on the repository. This attribute is no longer in use, but it hasn't been removed yet. It will be removed in a future version. See [this discussion](https://github.com/orgs/community/discussions/102145#discussioncomment-8351756). + // + // Deprecated: This attribute is no longer in use, but it hasn't been removed yet. It will be removed in a future version. See https://github.com/orgs/community/discussions/102145#discussioncomment-8351756 + HasDownloads pulumi.BoolPtrInput + // Set to `true` to enable the GitHub Issues features + // on the repository. + HasIssues pulumi.BoolPtrInput + // Set to `true` to enable the GitHub Projects features on the repository. Per the GitHub [documentation](https://developer.github.com/v3/repos/#create) when in an organization that has disabled repository projects it will default to `false` and will otherwise default to `true`. If you specify `true` when it has been disabled it will return an error. + HasProjects pulumi.BoolPtrInput + // Set to `true` to enable the GitHub Wiki features on + // the repository. + HasWiki pulumi.BoolPtrInput + // URL of a page describing the project. + HomepageUrl pulumi.StringPtrInput + // The absolute URL (including scheme) of the rendered GitHub Pages site e.g. `https://username.github.io`. + HtmlUrl pulumi.StringPtrInput + // URL that can be provided to `git clone` to clone the repository via HTTPS. + HttpCloneUrl pulumi.StringPtrInput + // (Optional) - This is ignored as the provider now handles lack of permissions automatically. This field will be removed in a future version. + // + // Deprecated: This is ignored as the provider now handles lack of permissions automatically. This field will be removed in a future version. + IgnoreVulnerabilityAlertsDuringRead pulumi.BoolPtrInput + // Set to `true` to tell GitHub that this is a template repository. + IsTemplate pulumi.BoolPtrInput + // Use the [name of the template](https://github.com/github/choosealicense.com/tree/gh-pages/_licenses) without the extension. For example, "mit" or "mpl-2.0". + LicenseTemplate pulumi.StringPtrInput + // Can be `PR_BODY`, `PR_TITLE`, or `BLANK` for a default merge commit message. Applicable only if `allowMergeCommit` is `true`. + MergeCommitMessage pulumi.StringPtrInput + // Can be `PR_TITLE` or `MERGE_MESSAGE` for a default merge commit title. Applicable only if `allowMergeCommit` is `true`. + MergeCommitTitle pulumi.StringPtrInput + // The name of the repository. + Name pulumi.StringPtrInput + // GraphQL global node id for use with v4 API + NodeId pulumi.StringPtrInput + // (**DEPRECATED**) The repository's GitHub Pages configuration. Use the `RepositoryPages` resource instead. This field will be removed in a future version. See GitHub Pages Configuration below for details. + // + // Deprecated: Use the RepositoryPages resource instead. This field will be removed in a future version. + Pages RepositoryPagesTypePtrInput + // The primary language used in the repository. + PrimaryLanguage pulumi.StringPtrInput + // Set to `true` to create a private repository. + // Repositories are created as public (e.g. open source) by default. + // + // Deprecated: use visibility instead + Private pulumi.BoolPtrInput + // GitHub ID for the repository + RepoId pulumi.IntPtrInput + // The repository's [security and analysis](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/enabling-features-for-your-repository/managing-security-and-analysis-settings-for-your-repository) configuration. See Security and Analysis Configuration below for details. + SecurityAndAnalysis RepositorySecurityAndAnalysisPtrInput + // The GitHub username or organization that owns the repository being forked. Required when `fork` is `true`. + SourceOwner pulumi.StringPtrInput + // The name of the repository to fork. Required when `fork` is `true`. + SourceRepo pulumi.StringPtrInput + // Can be `PR_BODY`, `COMMIT_MESSAGES`, or `BLANK` for a default squash merge commit message. Applicable only if `allowSquashMerge` is `true`. + SquashMergeCommitMessage pulumi.StringPtrInput + // Can be `PR_TITLE` or `COMMIT_OR_PR_TITLE` for a default squash merge commit title. Applicable only if `allowSquashMerge` is `true`. + SquashMergeCommitTitle pulumi.StringPtrInput + // URL that can be provided to `git clone` to clone the repository via SSH. + SshCloneUrl pulumi.StringPtrInput + // URL that can be provided to `svn checkout` to check out the repository via GitHub's Subversion protocol emulation. + SvnUrl pulumi.StringPtrInput + // Use a template repository to create this resource. See Template Repositories below for details. + Template RepositoryTemplatePtrInput + // The list of topics of the repository. + // + // > Note: This attribute is not compatible with the `RepositoryTopics` resource. Use one of them. `RepositoryTopics` is only meant to be used if the repository itself is not handled via terraform, for example if it's only read as a datasource (see issue #1845). + Topics pulumi.StringArrayInput + // Can be `public` or `private`. If your organization is associated with an enterprise account using GitHub Enterprise Cloud or GitHub Enterprise Server 2.20+, visibility can also be `internal`. The `visibility` parameter overrides the `private` parameter. + Visibility pulumi.StringPtrInput + // (**DEPRECATED**) Configure [Dependabot security alerts](https://help.github.com/en/github/managing-security-vulnerabilities/about-security-alerts-for-vulnerable-dependencies) for vulnerable dependencies; set to `true` to enable, set to `false` to disable, and leave unset for the default behavior. Configuring this requires that alerts are not being explicitly configured at the organization level. This field will be removed in a future version. Use the `RepositoryVulnerabilityAlerts` resource instead. + // + // Deprecated: Use the RepositoryVulnerabilityAlerts resource instead. This field will be removed in a future version. + VulnerabilityAlerts pulumi.BoolPtrInput + // Require contributors to sign off on web-based commits. See more in the [GitHub documentation](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/managing-repository-settings/managing-the-commit-signoff-policy-for-your-repository). + WebCommitSignoffRequired pulumi.BoolPtrInput +} + +func (RepositoryState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryState)(nil)).Elem() +} + +type repositoryArgs struct { + // Set to `true` to allow auto-merging pull requests on the repository. + AllowAutoMerge *bool `pulumi:"allowAutoMerge"` + // Configure private forking for organization owned private and internal repositories; set to `true` to enable, `false` to disable, and leave unset for the default behaviour. Configuring this requires that private forking is not being explicitly configured at the organization level. + AllowForking *bool `pulumi:"allowForking"` + // Set to `false` to disable merge commits on the repository. + AllowMergeCommit *bool `pulumi:"allowMergeCommit"` + // Set to `false` to disable rebase merges on the repository. + AllowRebaseMerge *bool `pulumi:"allowRebaseMerge"` + // Set to `false` to disable squash merges on the repository. + AllowSquashMerge *bool `pulumi:"allowSquashMerge"` + // Set to `true` to always suggest updating pull request branches. + AllowUpdateBranch *bool `pulumi:"allowUpdateBranch"` + // Set to `true` to archive the repository instead of deleting on destroy. + ArchiveOnDestroy *bool `pulumi:"archiveOnDestroy"` + // Specifies if the repository should be archived. Defaults to `false`. **NOTE** Currently, the API does not support unarchiving. + Archived *bool `pulumi:"archived"` + // Set to `true` to produce an initial commit in the repository. + AutoInit *bool `pulumi:"autoInit"` + // (Deprecated: Use `BranchDefault` resource instead) The name of the default branch of the repository. **NOTE:** This can only be set after a repository has already been created, + // and after a correct reference has been created for the target branch inside the repository. This means a user will have to omit this parameter from the + // initial repository creation and create the target branch inside of the repository prior to setting this attribute. + // + // Deprecated: Use the BranchDefault resource instead + DefaultBranch *string `pulumi:"defaultBranch"` + // Automatically delete head branch after a pull request is merged. Defaults to `false`. + DeleteBranchOnMerge *bool `pulumi:"deleteBranchOnMerge"` + // A description of the repository. + Description *string `pulumi:"description"` + Etag *string `pulumi:"etag"` + // Set to `true` to create a fork of an existing repository. When set to `true`, both `sourceOwner` and `sourceRepo` must also be specified. + Fork *string `pulumi:"fork"` + // Use the [name of the template](https://github.com/github/gitignore) without the extension. For example, "Haskell". + GitignoreTemplate *string `pulumi:"gitignoreTemplate"` + // Set to `true` to enable GitHub Discussions on the repository. Defaults to `false`. + HasDiscussions *bool `pulumi:"hasDiscussions"` + // (Optional) Set to `true` to enable the (deprecated) downloads features on the repository. This attribute is no longer in use, but it hasn't been removed yet. It will be removed in a future version. See [this discussion](https://github.com/orgs/community/discussions/102145#discussioncomment-8351756). + // + // Deprecated: This attribute is no longer in use, but it hasn't been removed yet. It will be removed in a future version. See https://github.com/orgs/community/discussions/102145#discussioncomment-8351756 + HasDownloads *bool `pulumi:"hasDownloads"` + // Set to `true` to enable the GitHub Issues features + // on the repository. + HasIssues *bool `pulumi:"hasIssues"` + // Set to `true` to enable the GitHub Projects features on the repository. Per the GitHub [documentation](https://developer.github.com/v3/repos/#create) when in an organization that has disabled repository projects it will default to `false` and will otherwise default to `true`. If you specify `true` when it has been disabled it will return an error. + HasProjects *bool `pulumi:"hasProjects"` + // Set to `true` to enable the GitHub Wiki features on + // the repository. + HasWiki *bool `pulumi:"hasWiki"` + // URL of a page describing the project. + HomepageUrl *string `pulumi:"homepageUrl"` + // (Optional) - This is ignored as the provider now handles lack of permissions automatically. This field will be removed in a future version. + // + // Deprecated: This is ignored as the provider now handles lack of permissions automatically. This field will be removed in a future version. + IgnoreVulnerabilityAlertsDuringRead *bool `pulumi:"ignoreVulnerabilityAlertsDuringRead"` + // Set to `true` to tell GitHub that this is a template repository. + IsTemplate *bool `pulumi:"isTemplate"` + // Use the [name of the template](https://github.com/github/choosealicense.com/tree/gh-pages/_licenses) without the extension. For example, "mit" or "mpl-2.0". + LicenseTemplate *string `pulumi:"licenseTemplate"` + // Can be `PR_BODY`, `PR_TITLE`, or `BLANK` for a default merge commit message. Applicable only if `allowMergeCommit` is `true`. + MergeCommitMessage *string `pulumi:"mergeCommitMessage"` + // Can be `PR_TITLE` or `MERGE_MESSAGE` for a default merge commit title. Applicable only if `allowMergeCommit` is `true`. + MergeCommitTitle *string `pulumi:"mergeCommitTitle"` + // The name of the repository. + Name *string `pulumi:"name"` + // (**DEPRECATED**) The repository's GitHub Pages configuration. Use the `RepositoryPages` resource instead. This field will be removed in a future version. See GitHub Pages Configuration below for details. + // + // Deprecated: Use the RepositoryPages resource instead. This field will be removed in a future version. + Pages *RepositoryPagesType `pulumi:"pages"` + // Set to `true` to create a private repository. + // Repositories are created as public (e.g. open source) by default. + // + // Deprecated: use visibility instead + Private *bool `pulumi:"private"` + // The repository's [security and analysis](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/enabling-features-for-your-repository/managing-security-and-analysis-settings-for-your-repository) configuration. See Security and Analysis Configuration below for details. + SecurityAndAnalysis *RepositorySecurityAndAnalysis `pulumi:"securityAndAnalysis"` + // The GitHub username or organization that owns the repository being forked. Required when `fork` is `true`. + SourceOwner *string `pulumi:"sourceOwner"` + // The name of the repository to fork. Required when `fork` is `true`. + SourceRepo *string `pulumi:"sourceRepo"` + // Can be `PR_BODY`, `COMMIT_MESSAGES`, or `BLANK` for a default squash merge commit message. Applicable only if `allowSquashMerge` is `true`. + SquashMergeCommitMessage *string `pulumi:"squashMergeCommitMessage"` + // Can be `PR_TITLE` or `COMMIT_OR_PR_TITLE` for a default squash merge commit title. Applicable only if `allowSquashMerge` is `true`. + SquashMergeCommitTitle *string `pulumi:"squashMergeCommitTitle"` + // Use a template repository to create this resource. See Template Repositories below for details. + Template *RepositoryTemplate `pulumi:"template"` + // The list of topics of the repository. + // + // > Note: This attribute is not compatible with the `RepositoryTopics` resource. Use one of them. `RepositoryTopics` is only meant to be used if the repository itself is not handled via terraform, for example if it's only read as a datasource (see issue #1845). + Topics []string `pulumi:"topics"` + // Can be `public` or `private`. If your organization is associated with an enterprise account using GitHub Enterprise Cloud or GitHub Enterprise Server 2.20+, visibility can also be `internal`. The `visibility` parameter overrides the `private` parameter. + Visibility *string `pulumi:"visibility"` + // (**DEPRECATED**) Configure [Dependabot security alerts](https://help.github.com/en/github/managing-security-vulnerabilities/about-security-alerts-for-vulnerable-dependencies) for vulnerable dependencies; set to `true` to enable, set to `false` to disable, and leave unset for the default behavior. Configuring this requires that alerts are not being explicitly configured at the organization level. This field will be removed in a future version. Use the `RepositoryVulnerabilityAlerts` resource instead. + // + // Deprecated: Use the RepositoryVulnerabilityAlerts resource instead. This field will be removed in a future version. + VulnerabilityAlerts *bool `pulumi:"vulnerabilityAlerts"` + // Require contributors to sign off on web-based commits. See more in the [GitHub documentation](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/managing-repository-settings/managing-the-commit-signoff-policy-for-your-repository). + WebCommitSignoffRequired *bool `pulumi:"webCommitSignoffRequired"` +} + +// The set of arguments for constructing a Repository resource. +type RepositoryArgs struct { + // Set to `true` to allow auto-merging pull requests on the repository. + AllowAutoMerge pulumi.BoolPtrInput + // Configure private forking for organization owned private and internal repositories; set to `true` to enable, `false` to disable, and leave unset for the default behaviour. Configuring this requires that private forking is not being explicitly configured at the organization level. + AllowForking pulumi.BoolPtrInput + // Set to `false` to disable merge commits on the repository. + AllowMergeCommit pulumi.BoolPtrInput + // Set to `false` to disable rebase merges on the repository. + AllowRebaseMerge pulumi.BoolPtrInput + // Set to `false` to disable squash merges on the repository. + AllowSquashMerge pulumi.BoolPtrInput + // Set to `true` to always suggest updating pull request branches. + AllowUpdateBranch pulumi.BoolPtrInput + // Set to `true` to archive the repository instead of deleting on destroy. + ArchiveOnDestroy pulumi.BoolPtrInput + // Specifies if the repository should be archived. Defaults to `false`. **NOTE** Currently, the API does not support unarchiving. + Archived pulumi.BoolPtrInput + // Set to `true` to produce an initial commit in the repository. + AutoInit pulumi.BoolPtrInput + // (Deprecated: Use `BranchDefault` resource instead) The name of the default branch of the repository. **NOTE:** This can only be set after a repository has already been created, + // and after a correct reference has been created for the target branch inside the repository. This means a user will have to omit this parameter from the + // initial repository creation and create the target branch inside of the repository prior to setting this attribute. + // + // Deprecated: Use the BranchDefault resource instead + DefaultBranch pulumi.StringPtrInput + // Automatically delete head branch after a pull request is merged. Defaults to `false`. + DeleteBranchOnMerge pulumi.BoolPtrInput + // A description of the repository. + Description pulumi.StringPtrInput + Etag pulumi.StringPtrInput + // Set to `true` to create a fork of an existing repository. When set to `true`, both `sourceOwner` and `sourceRepo` must also be specified. + Fork pulumi.StringPtrInput + // Use the [name of the template](https://github.com/github/gitignore) without the extension. For example, "Haskell". + GitignoreTemplate pulumi.StringPtrInput + // Set to `true` to enable GitHub Discussions on the repository. Defaults to `false`. + HasDiscussions pulumi.BoolPtrInput + // (Optional) Set to `true` to enable the (deprecated) downloads features on the repository. This attribute is no longer in use, but it hasn't been removed yet. It will be removed in a future version. See [this discussion](https://github.com/orgs/community/discussions/102145#discussioncomment-8351756). + // + // Deprecated: This attribute is no longer in use, but it hasn't been removed yet. It will be removed in a future version. See https://github.com/orgs/community/discussions/102145#discussioncomment-8351756 + HasDownloads pulumi.BoolPtrInput + // Set to `true` to enable the GitHub Issues features + // on the repository. + HasIssues pulumi.BoolPtrInput + // Set to `true` to enable the GitHub Projects features on the repository. Per the GitHub [documentation](https://developer.github.com/v3/repos/#create) when in an organization that has disabled repository projects it will default to `false` and will otherwise default to `true`. If you specify `true` when it has been disabled it will return an error. + HasProjects pulumi.BoolPtrInput + // Set to `true` to enable the GitHub Wiki features on + // the repository. + HasWiki pulumi.BoolPtrInput + // URL of a page describing the project. + HomepageUrl pulumi.StringPtrInput + // (Optional) - This is ignored as the provider now handles lack of permissions automatically. This field will be removed in a future version. + // + // Deprecated: This is ignored as the provider now handles lack of permissions automatically. This field will be removed in a future version. + IgnoreVulnerabilityAlertsDuringRead pulumi.BoolPtrInput + // Set to `true` to tell GitHub that this is a template repository. + IsTemplate pulumi.BoolPtrInput + // Use the [name of the template](https://github.com/github/choosealicense.com/tree/gh-pages/_licenses) without the extension. For example, "mit" or "mpl-2.0". + LicenseTemplate pulumi.StringPtrInput + // Can be `PR_BODY`, `PR_TITLE`, or `BLANK` for a default merge commit message. Applicable only if `allowMergeCommit` is `true`. + MergeCommitMessage pulumi.StringPtrInput + // Can be `PR_TITLE` or `MERGE_MESSAGE` for a default merge commit title. Applicable only if `allowMergeCommit` is `true`. + MergeCommitTitle pulumi.StringPtrInput + // The name of the repository. + Name pulumi.StringPtrInput + // (**DEPRECATED**) The repository's GitHub Pages configuration. Use the `RepositoryPages` resource instead. This field will be removed in a future version. See GitHub Pages Configuration below for details. + // + // Deprecated: Use the RepositoryPages resource instead. This field will be removed in a future version. + Pages RepositoryPagesTypePtrInput + // Set to `true` to create a private repository. + // Repositories are created as public (e.g. open source) by default. + // + // Deprecated: use visibility instead + Private pulumi.BoolPtrInput + // The repository's [security and analysis](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/enabling-features-for-your-repository/managing-security-and-analysis-settings-for-your-repository) configuration. See Security and Analysis Configuration below for details. + SecurityAndAnalysis RepositorySecurityAndAnalysisPtrInput + // The GitHub username or organization that owns the repository being forked. Required when `fork` is `true`. + SourceOwner pulumi.StringPtrInput + // The name of the repository to fork. Required when `fork` is `true`. + SourceRepo pulumi.StringPtrInput + // Can be `PR_BODY`, `COMMIT_MESSAGES`, or `BLANK` for a default squash merge commit message. Applicable only if `allowSquashMerge` is `true`. + SquashMergeCommitMessage pulumi.StringPtrInput + // Can be `PR_TITLE` or `COMMIT_OR_PR_TITLE` for a default squash merge commit title. Applicable only if `allowSquashMerge` is `true`. + SquashMergeCommitTitle pulumi.StringPtrInput + // Use a template repository to create this resource. See Template Repositories below for details. + Template RepositoryTemplatePtrInput + // The list of topics of the repository. + // + // > Note: This attribute is not compatible with the `RepositoryTopics` resource. Use one of them. `RepositoryTopics` is only meant to be used if the repository itself is not handled via terraform, for example if it's only read as a datasource (see issue #1845). + Topics pulumi.StringArrayInput + // Can be `public` or `private`. If your organization is associated with an enterprise account using GitHub Enterprise Cloud or GitHub Enterprise Server 2.20+, visibility can also be `internal`. The `visibility` parameter overrides the `private` parameter. + Visibility pulumi.StringPtrInput + // (**DEPRECATED**) Configure [Dependabot security alerts](https://help.github.com/en/github/managing-security-vulnerabilities/about-security-alerts-for-vulnerable-dependencies) for vulnerable dependencies; set to `true` to enable, set to `false` to disable, and leave unset for the default behavior. Configuring this requires that alerts are not being explicitly configured at the organization level. This field will be removed in a future version. Use the `RepositoryVulnerabilityAlerts` resource instead. + // + // Deprecated: Use the RepositoryVulnerabilityAlerts resource instead. This field will be removed in a future version. + VulnerabilityAlerts pulumi.BoolPtrInput + // Require contributors to sign off on web-based commits. See more in the [GitHub documentation](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/managing-repository-settings/managing-the-commit-signoff-policy-for-your-repository). + WebCommitSignoffRequired pulumi.BoolPtrInput +} + +func (RepositoryArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryArgs)(nil)).Elem() +} + +type RepositoryInput interface { + pulumi.Input + + ToRepositoryOutput() RepositoryOutput + ToRepositoryOutputWithContext(ctx context.Context) RepositoryOutput +} + +func (*Repository) ElementType() reflect.Type { + return reflect.TypeOf((**Repository)(nil)).Elem() +} + +func (i *Repository) ToRepositoryOutput() RepositoryOutput { + return i.ToRepositoryOutputWithContext(context.Background()) +} + +func (i *Repository) ToRepositoryOutputWithContext(ctx context.Context) RepositoryOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryOutput) +} + +// RepositoryArrayInput is an input type that accepts RepositoryArray and RepositoryArrayOutput values. +// You can construct a concrete instance of `RepositoryArrayInput` via: +// +// RepositoryArray{ RepositoryArgs{...} } +type RepositoryArrayInput interface { + pulumi.Input + + ToRepositoryArrayOutput() RepositoryArrayOutput + ToRepositoryArrayOutputWithContext(context.Context) RepositoryArrayOutput +} + +type RepositoryArray []RepositoryInput + +func (RepositoryArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Repository)(nil)).Elem() +} + +func (i RepositoryArray) ToRepositoryArrayOutput() RepositoryArrayOutput { + return i.ToRepositoryArrayOutputWithContext(context.Background()) +} + +func (i RepositoryArray) ToRepositoryArrayOutputWithContext(ctx context.Context) RepositoryArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryArrayOutput) +} + +// RepositoryMapInput is an input type that accepts RepositoryMap and RepositoryMapOutput values. +// You can construct a concrete instance of `RepositoryMapInput` via: +// +// RepositoryMap{ "key": RepositoryArgs{...} } +type RepositoryMapInput interface { + pulumi.Input + + ToRepositoryMapOutput() RepositoryMapOutput + ToRepositoryMapOutputWithContext(context.Context) RepositoryMapOutput +} + +type RepositoryMap map[string]RepositoryInput + +func (RepositoryMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Repository)(nil)).Elem() +} + +func (i RepositoryMap) ToRepositoryMapOutput() RepositoryMapOutput { + return i.ToRepositoryMapOutputWithContext(context.Background()) +} + +func (i RepositoryMap) ToRepositoryMapOutputWithContext(ctx context.Context) RepositoryMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryMapOutput) +} + +type RepositoryOutput struct{ *pulumi.OutputState } + +func (RepositoryOutput) ElementType() reflect.Type { + return reflect.TypeOf((**Repository)(nil)).Elem() +} + +func (o RepositoryOutput) ToRepositoryOutput() RepositoryOutput { + return o +} + +func (o RepositoryOutput) ToRepositoryOutputWithContext(ctx context.Context) RepositoryOutput { + return o +} + +// Set to `true` to allow auto-merging pull requests on the repository. +func (o RepositoryOutput) AllowAutoMerge() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolPtrOutput { return v.AllowAutoMerge }).(pulumi.BoolPtrOutput) +} + +// Configure private forking for organization owned private and internal repositories; set to `true` to enable, `false` to disable, and leave unset for the default behaviour. Configuring this requires that private forking is not being explicitly configured at the organization level. +func (o RepositoryOutput) AllowForking() pulumi.BoolOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolOutput { return v.AllowForking }).(pulumi.BoolOutput) +} + +// Set to `false` to disable merge commits on the repository. +func (o RepositoryOutput) AllowMergeCommit() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolPtrOutput { return v.AllowMergeCommit }).(pulumi.BoolPtrOutput) +} + +// Set to `false` to disable rebase merges on the repository. +func (o RepositoryOutput) AllowRebaseMerge() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolPtrOutput { return v.AllowRebaseMerge }).(pulumi.BoolPtrOutput) +} + +// Set to `false` to disable squash merges on the repository. +func (o RepositoryOutput) AllowSquashMerge() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolPtrOutput { return v.AllowSquashMerge }).(pulumi.BoolPtrOutput) +} + +// Set to `true` to always suggest updating pull request branches. +func (o RepositoryOutput) AllowUpdateBranch() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolPtrOutput { return v.AllowUpdateBranch }).(pulumi.BoolPtrOutput) +} + +// Set to `true` to archive the repository instead of deleting on destroy. +func (o RepositoryOutput) ArchiveOnDestroy() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolPtrOutput { return v.ArchiveOnDestroy }).(pulumi.BoolPtrOutput) +} + +// Specifies if the repository should be archived. Defaults to `false`. **NOTE** Currently, the API does not support unarchiving. +func (o RepositoryOutput) Archived() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolPtrOutput { return v.Archived }).(pulumi.BoolPtrOutput) +} + +// Set to `true` to produce an initial commit in the repository. +func (o RepositoryOutput) AutoInit() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolPtrOutput { return v.AutoInit }).(pulumi.BoolPtrOutput) +} + +// (Deprecated: Use `BranchDefault` resource instead) The name of the default branch of the repository. **NOTE:** This can only be set after a repository has already been created, +// and after a correct reference has been created for the target branch inside the repository. This means a user will have to omit this parameter from the +// initial repository creation and create the target branch inside of the repository prior to setting this attribute. +// +// Deprecated: Use the BranchDefault resource instead +func (o RepositoryOutput) DefaultBranch() pulumi.StringOutput { + return o.ApplyT(func(v *Repository) pulumi.StringOutput { return v.DefaultBranch }).(pulumi.StringOutput) +} + +// Automatically delete head branch after a pull request is merged. Defaults to `false`. +func (o RepositoryOutput) DeleteBranchOnMerge() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolPtrOutput { return v.DeleteBranchOnMerge }).(pulumi.BoolPtrOutput) +} + +// A description of the repository. +func (o RepositoryOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) +} + +func (o RepositoryOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *Repository) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// Set to `true` to create a fork of an existing repository. When set to `true`, both `sourceOwner` and `sourceRepo` must also be specified. +func (o RepositoryOutput) Fork() pulumi.StringOutput { + return o.ApplyT(func(v *Repository) pulumi.StringOutput { return v.Fork }).(pulumi.StringOutput) +} + +// A string of the form "orgname/reponame". +func (o RepositoryOutput) FullName() pulumi.StringOutput { + return o.ApplyT(func(v *Repository) pulumi.StringOutput { return v.FullName }).(pulumi.StringOutput) +} + +// URL that can be provided to `git clone` to clone the repository anonymously via the git protocol. +func (o RepositoryOutput) GitCloneUrl() pulumi.StringOutput { + return o.ApplyT(func(v *Repository) pulumi.StringOutput { return v.GitCloneUrl }).(pulumi.StringOutput) +} + +// Use the [name of the template](https://github.com/github/gitignore) without the extension. For example, "Haskell". +func (o RepositoryOutput) GitignoreTemplate() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.StringPtrOutput { return v.GitignoreTemplate }).(pulumi.StringPtrOutput) +} + +// Set to `true` to enable GitHub Discussions on the repository. Defaults to `false`. +func (o RepositoryOutput) HasDiscussions() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolPtrOutput { return v.HasDiscussions }).(pulumi.BoolPtrOutput) +} + +// (Optional) Set to `true` to enable the (deprecated) downloads features on the repository. This attribute is no longer in use, but it hasn't been removed yet. It will be removed in a future version. See [this discussion](https://github.com/orgs/community/discussions/102145#discussioncomment-8351756). +// +// Deprecated: This attribute is no longer in use, but it hasn't been removed yet. It will be removed in a future version. See https://github.com/orgs/community/discussions/102145#discussioncomment-8351756 +func (o RepositoryOutput) HasDownloads() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolPtrOutput { return v.HasDownloads }).(pulumi.BoolPtrOutput) +} + +// Set to `true` to enable the GitHub Issues features +// on the repository. +func (o RepositoryOutput) HasIssues() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolPtrOutput { return v.HasIssues }).(pulumi.BoolPtrOutput) +} + +// Set to `true` to enable the GitHub Projects features on the repository. Per the GitHub [documentation](https://developer.github.com/v3/repos/#create) when in an organization that has disabled repository projects it will default to `false` and will otherwise default to `true`. If you specify `true` when it has been disabled it will return an error. +func (o RepositoryOutput) HasProjects() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolPtrOutput { return v.HasProjects }).(pulumi.BoolPtrOutput) +} + +// Set to `true` to enable the GitHub Wiki features on +// the repository. +func (o RepositoryOutput) HasWiki() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolPtrOutput { return v.HasWiki }).(pulumi.BoolPtrOutput) +} + +// URL of a page describing the project. +func (o RepositoryOutput) HomepageUrl() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.StringPtrOutput { return v.HomepageUrl }).(pulumi.StringPtrOutput) +} + +// The absolute URL (including scheme) of the rendered GitHub Pages site e.g. `https://username.github.io`. +func (o RepositoryOutput) HtmlUrl() pulumi.StringOutput { + return o.ApplyT(func(v *Repository) pulumi.StringOutput { return v.HtmlUrl }).(pulumi.StringOutput) +} + +// URL that can be provided to `git clone` to clone the repository via HTTPS. +func (o RepositoryOutput) HttpCloneUrl() pulumi.StringOutput { + return o.ApplyT(func(v *Repository) pulumi.StringOutput { return v.HttpCloneUrl }).(pulumi.StringOutput) +} + +// (Optional) - This is ignored as the provider now handles lack of permissions automatically. This field will be removed in a future version. +// +// Deprecated: This is ignored as the provider now handles lack of permissions automatically. This field will be removed in a future version. +func (o RepositoryOutput) IgnoreVulnerabilityAlertsDuringRead() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolPtrOutput { return v.IgnoreVulnerabilityAlertsDuringRead }).(pulumi.BoolPtrOutput) +} + +// Set to `true` to tell GitHub that this is a template repository. +func (o RepositoryOutput) IsTemplate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolPtrOutput { return v.IsTemplate }).(pulumi.BoolPtrOutput) +} + +// Use the [name of the template](https://github.com/github/choosealicense.com/tree/gh-pages/_licenses) without the extension. For example, "mit" or "mpl-2.0". +func (o RepositoryOutput) LicenseTemplate() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.StringPtrOutput { return v.LicenseTemplate }).(pulumi.StringPtrOutput) +} + +// Can be `PR_BODY`, `PR_TITLE`, or `BLANK` for a default merge commit message. Applicable only if `allowMergeCommit` is `true`. +func (o RepositoryOutput) MergeCommitMessage() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.StringPtrOutput { return v.MergeCommitMessage }).(pulumi.StringPtrOutput) +} + +// Can be `PR_TITLE` or `MERGE_MESSAGE` for a default merge commit title. Applicable only if `allowMergeCommit` is `true`. +func (o RepositoryOutput) MergeCommitTitle() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.StringPtrOutput { return v.MergeCommitTitle }).(pulumi.StringPtrOutput) +} + +// The name of the repository. +func (o RepositoryOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *Repository) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// GraphQL global node id for use with v4 API +func (o RepositoryOutput) NodeId() pulumi.StringOutput { + return o.ApplyT(func(v *Repository) pulumi.StringOutput { return v.NodeId }).(pulumi.StringOutput) +} + +// (**DEPRECATED**) The repository's GitHub Pages configuration. Use the `RepositoryPages` resource instead. This field will be removed in a future version. See GitHub Pages Configuration below for details. +// +// Deprecated: Use the RepositoryPages resource instead. This field will be removed in a future version. +func (o RepositoryOutput) Pages() RepositoryPagesTypePtrOutput { + return o.ApplyT(func(v *Repository) RepositoryPagesTypePtrOutput { return v.Pages }).(RepositoryPagesTypePtrOutput) +} + +// The primary language used in the repository. +func (o RepositoryOutput) PrimaryLanguage() pulumi.StringOutput { + return o.ApplyT(func(v *Repository) pulumi.StringOutput { return v.PrimaryLanguage }).(pulumi.StringOutput) +} + +// Set to `true` to create a private repository. +// Repositories are created as public (e.g. open source) by default. +// +// Deprecated: use visibility instead +func (o RepositoryOutput) Private() pulumi.BoolOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolOutput { return v.Private }).(pulumi.BoolOutput) +} + +// GitHub ID for the repository +func (o RepositoryOutput) RepoId() pulumi.IntOutput { + return o.ApplyT(func(v *Repository) pulumi.IntOutput { return v.RepoId }).(pulumi.IntOutput) +} + +// The repository's [security and analysis](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/enabling-features-for-your-repository/managing-security-and-analysis-settings-for-your-repository) configuration. See Security and Analysis Configuration below for details. +func (o RepositoryOutput) SecurityAndAnalysis() RepositorySecurityAndAnalysisOutput { + return o.ApplyT(func(v *Repository) RepositorySecurityAndAnalysisOutput { return v.SecurityAndAnalysis }).(RepositorySecurityAndAnalysisOutput) +} + +// The GitHub username or organization that owns the repository being forked. Required when `fork` is `true`. +func (o RepositoryOutput) SourceOwner() pulumi.StringOutput { + return o.ApplyT(func(v *Repository) pulumi.StringOutput { return v.SourceOwner }).(pulumi.StringOutput) +} + +// The name of the repository to fork. Required when `fork` is `true`. +func (o RepositoryOutput) SourceRepo() pulumi.StringOutput { + return o.ApplyT(func(v *Repository) pulumi.StringOutput { return v.SourceRepo }).(pulumi.StringOutput) +} + +// Can be `PR_BODY`, `COMMIT_MESSAGES`, or `BLANK` for a default squash merge commit message. Applicable only if `allowSquashMerge` is `true`. +func (o RepositoryOutput) SquashMergeCommitMessage() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.StringPtrOutput { return v.SquashMergeCommitMessage }).(pulumi.StringPtrOutput) +} + +// Can be `PR_TITLE` or `COMMIT_OR_PR_TITLE` for a default squash merge commit title. Applicable only if `allowSquashMerge` is `true`. +func (o RepositoryOutput) SquashMergeCommitTitle() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Repository) pulumi.StringPtrOutput { return v.SquashMergeCommitTitle }).(pulumi.StringPtrOutput) +} + +// URL that can be provided to `git clone` to clone the repository via SSH. +func (o RepositoryOutput) SshCloneUrl() pulumi.StringOutput { + return o.ApplyT(func(v *Repository) pulumi.StringOutput { return v.SshCloneUrl }).(pulumi.StringOutput) +} + +// URL that can be provided to `svn checkout` to check out the repository via GitHub's Subversion protocol emulation. +func (o RepositoryOutput) SvnUrl() pulumi.StringOutput { + return o.ApplyT(func(v *Repository) pulumi.StringOutput { return v.SvnUrl }).(pulumi.StringOutput) +} + +// Use a template repository to create this resource. See Template Repositories below for details. +func (o RepositoryOutput) Template() RepositoryTemplatePtrOutput { + return o.ApplyT(func(v *Repository) RepositoryTemplatePtrOutput { return v.Template }).(RepositoryTemplatePtrOutput) +} + +// The list of topics of the repository. +// +// > Note: This attribute is not compatible with the `RepositoryTopics` resource. Use one of them. `RepositoryTopics` is only meant to be used if the repository itself is not handled via terraform, for example if it's only read as a datasource (see issue #1845). +func (o RepositoryOutput) Topics() pulumi.StringArrayOutput { + return o.ApplyT(func(v *Repository) pulumi.StringArrayOutput { return v.Topics }).(pulumi.StringArrayOutput) +} + +// Can be `public` or `private`. If your organization is associated with an enterprise account using GitHub Enterprise Cloud or GitHub Enterprise Server 2.20+, visibility can also be `internal`. The `visibility` parameter overrides the `private` parameter. +func (o RepositoryOutput) Visibility() pulumi.StringOutput { + return o.ApplyT(func(v *Repository) pulumi.StringOutput { return v.Visibility }).(pulumi.StringOutput) +} + +// (**DEPRECATED**) Configure [Dependabot security alerts](https://help.github.com/en/github/managing-security-vulnerabilities/about-security-alerts-for-vulnerable-dependencies) for vulnerable dependencies; set to `true` to enable, set to `false` to disable, and leave unset for the default behavior. Configuring this requires that alerts are not being explicitly configured at the organization level. This field will be removed in a future version. Use the `RepositoryVulnerabilityAlerts` resource instead. +// +// Deprecated: Use the RepositoryVulnerabilityAlerts resource instead. This field will be removed in a future version. +func (o RepositoryOutput) VulnerabilityAlerts() pulumi.BoolOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolOutput { return v.VulnerabilityAlerts }).(pulumi.BoolOutput) +} + +// Require contributors to sign off on web-based commits. See more in the [GitHub documentation](https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/managing-repository-settings/managing-the-commit-signoff-policy-for-your-repository). +func (o RepositoryOutput) WebCommitSignoffRequired() pulumi.BoolOutput { + return o.ApplyT(func(v *Repository) pulumi.BoolOutput { return v.WebCommitSignoffRequired }).(pulumi.BoolOutput) +} + +type RepositoryArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Repository)(nil)).Elem() +} + +func (o RepositoryArrayOutput) ToRepositoryArrayOutput() RepositoryArrayOutput { + return o +} + +func (o RepositoryArrayOutput) ToRepositoryArrayOutputWithContext(ctx context.Context) RepositoryArrayOutput { + return o +} + +func (o RepositoryArrayOutput) Index(i pulumi.IntInput) RepositoryOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Repository { + return vs[0].([]*Repository)[vs[1].(int)] + }).(RepositoryOutput) +} + +type RepositoryMapOutput struct{ *pulumi.OutputState } + +func (RepositoryMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Repository)(nil)).Elem() +} + +func (o RepositoryMapOutput) ToRepositoryMapOutput() RepositoryMapOutput { + return o +} + +func (o RepositoryMapOutput) ToRepositoryMapOutputWithContext(ctx context.Context) RepositoryMapOutput { + return o +} + +func (o RepositoryMapOutput) MapIndex(k pulumi.StringInput) RepositoryOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Repository { + return vs[0].(map[string]*Repository)[vs[1].(string)] + }).(RepositoryOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryInput)(nil)).Elem(), &Repository{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryArrayInput)(nil)).Elem(), RepositoryArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryMapInput)(nil)).Elem(), RepositoryMap{}) + pulumi.RegisterOutputType(RepositoryOutput{}) + pulumi.RegisterOutputType(RepositoryArrayOutput{}) + pulumi.RegisterOutputType(RepositoryMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryAutolinkReference.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryAutolinkReference.go new file mode 100644 index 000000000..97bcb0cc4 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryAutolinkReference.go @@ -0,0 +1,335 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage an autolink reference for a single repository. +// +// ## Example Usage +// +// ```go +// 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 { +// repo, err := github.NewRepository(ctx, "repo", &github.RepositoryArgs{ +// Name: pulumi.String("my-repo"), +// Description: pulumi.String("GitHub repo managed by Terraform"), +// Private: pulumi.Bool(false), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryAutolinkReference(ctx, "autolink", &github.RepositoryAutolinkReferenceArgs{ +// Repository: repo.Name, +// KeyPrefix: pulumi.String("TICKET-"), +// TargetUrlTemplate: pulumi.String("https://example.com/TICKET?query="), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// Autolink references can be imported using the `name` of the repository, combined with the `id` or `key prefix` of the autolink reference and a `/` character for separating components, e.g. +// +// ### Import by ID +// +// ```sh +// $ pulumi import github:index/repositoryAutolinkReference:RepositoryAutolinkReference auto my-repo/123 +// ``` +// +// See the GitHub documentation for how to [list all autolinks of a repository](https://docs.github.com/en/rest/repos/autolinks#list-all-autolinks-of-a-repository) to learn the autolink ids to use with the import command. +// +// ### Import by key prefix +// +// ```sh +// $ pulumi import github:index/repositoryAutolinkReference:RepositoryAutolinkReference auto oof/OOF- +// ``` +type RepositoryAutolinkReference struct { + pulumi.CustomResourceState + + // An etag representing the autolink reference object. + Etag pulumi.StringOutput `pulumi:"etag"` + // Whether this autolink reference matches alphanumeric characters. If false, this autolink reference only matches numeric characters. Default is true. + IsAlphanumeric pulumi.BoolPtrOutput `pulumi:"isAlphanumeric"` + // This prefix appended by a number will generate a link any time it is found in an issue, pull request, or commit. + KeyPrefix pulumi.StringOutput `pulumi:"keyPrefix"` + // The repository of the autolink reference. + Repository pulumi.StringOutput `pulumi:"repository"` + // The template of the target URL used for the links; must be a valid URL and contain `` for the reference number + TargetUrlTemplate pulumi.StringOutput `pulumi:"targetUrlTemplate"` +} + +// NewRepositoryAutolinkReference registers a new resource with the given unique name, arguments, and options. +func NewRepositoryAutolinkReference(ctx *pulumi.Context, + name string, args *RepositoryAutolinkReferenceArgs, opts ...pulumi.ResourceOption) (*RepositoryAutolinkReference, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.KeyPrefix == nil { + return nil, errors.New("invalid value for required argument 'KeyPrefix'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + if args.TargetUrlTemplate == nil { + return nil, errors.New("invalid value for required argument 'TargetUrlTemplate'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryAutolinkReference + err := ctx.RegisterResource("github:index/repositoryAutolinkReference:RepositoryAutolinkReference", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryAutolinkReference gets an existing RepositoryAutolinkReference 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 GetRepositoryAutolinkReference(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryAutolinkReferenceState, opts ...pulumi.ResourceOption) (*RepositoryAutolinkReference, error) { + var resource RepositoryAutolinkReference + err := ctx.ReadResource("github:index/repositoryAutolinkReference:RepositoryAutolinkReference", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryAutolinkReference resources. +type repositoryAutolinkReferenceState struct { + // An etag representing the autolink reference object. + Etag *string `pulumi:"etag"` + // Whether this autolink reference matches alphanumeric characters. If false, this autolink reference only matches numeric characters. Default is true. + IsAlphanumeric *bool `pulumi:"isAlphanumeric"` + // This prefix appended by a number will generate a link any time it is found in an issue, pull request, or commit. + KeyPrefix *string `pulumi:"keyPrefix"` + // The repository of the autolink reference. + Repository *string `pulumi:"repository"` + // The template of the target URL used for the links; must be a valid URL and contain `` for the reference number + TargetUrlTemplate *string `pulumi:"targetUrlTemplate"` +} + +type RepositoryAutolinkReferenceState struct { + // An etag representing the autolink reference object. + Etag pulumi.StringPtrInput + // Whether this autolink reference matches alphanumeric characters. If false, this autolink reference only matches numeric characters. Default is true. + IsAlphanumeric pulumi.BoolPtrInput + // This prefix appended by a number will generate a link any time it is found in an issue, pull request, or commit. + KeyPrefix pulumi.StringPtrInput + // The repository of the autolink reference. + Repository pulumi.StringPtrInput + // The template of the target URL used for the links; must be a valid URL and contain `` for the reference number + TargetUrlTemplate pulumi.StringPtrInput +} + +func (RepositoryAutolinkReferenceState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryAutolinkReferenceState)(nil)).Elem() +} + +type repositoryAutolinkReferenceArgs struct { + // Whether this autolink reference matches alphanumeric characters. If false, this autolink reference only matches numeric characters. Default is true. + IsAlphanumeric *bool `pulumi:"isAlphanumeric"` + // This prefix appended by a number will generate a link any time it is found in an issue, pull request, or commit. + KeyPrefix string `pulumi:"keyPrefix"` + // The repository of the autolink reference. + Repository string `pulumi:"repository"` + // The template of the target URL used for the links; must be a valid URL and contain `` for the reference number + TargetUrlTemplate string `pulumi:"targetUrlTemplate"` +} + +// The set of arguments for constructing a RepositoryAutolinkReference resource. +type RepositoryAutolinkReferenceArgs struct { + // Whether this autolink reference matches alphanumeric characters. If false, this autolink reference only matches numeric characters. Default is true. + IsAlphanumeric pulumi.BoolPtrInput + // This prefix appended by a number will generate a link any time it is found in an issue, pull request, or commit. + KeyPrefix pulumi.StringInput + // The repository of the autolink reference. + Repository pulumi.StringInput + // The template of the target URL used for the links; must be a valid URL and contain `` for the reference number + TargetUrlTemplate pulumi.StringInput +} + +func (RepositoryAutolinkReferenceArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryAutolinkReferenceArgs)(nil)).Elem() +} + +type RepositoryAutolinkReferenceInput interface { + pulumi.Input + + ToRepositoryAutolinkReferenceOutput() RepositoryAutolinkReferenceOutput + ToRepositoryAutolinkReferenceOutputWithContext(ctx context.Context) RepositoryAutolinkReferenceOutput +} + +func (*RepositoryAutolinkReference) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryAutolinkReference)(nil)).Elem() +} + +func (i *RepositoryAutolinkReference) ToRepositoryAutolinkReferenceOutput() RepositoryAutolinkReferenceOutput { + return i.ToRepositoryAutolinkReferenceOutputWithContext(context.Background()) +} + +func (i *RepositoryAutolinkReference) ToRepositoryAutolinkReferenceOutputWithContext(ctx context.Context) RepositoryAutolinkReferenceOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryAutolinkReferenceOutput) +} + +// RepositoryAutolinkReferenceArrayInput is an input type that accepts RepositoryAutolinkReferenceArray and RepositoryAutolinkReferenceArrayOutput values. +// You can construct a concrete instance of `RepositoryAutolinkReferenceArrayInput` via: +// +// RepositoryAutolinkReferenceArray{ RepositoryAutolinkReferenceArgs{...} } +type RepositoryAutolinkReferenceArrayInput interface { + pulumi.Input + + ToRepositoryAutolinkReferenceArrayOutput() RepositoryAutolinkReferenceArrayOutput + ToRepositoryAutolinkReferenceArrayOutputWithContext(context.Context) RepositoryAutolinkReferenceArrayOutput +} + +type RepositoryAutolinkReferenceArray []RepositoryAutolinkReferenceInput + +func (RepositoryAutolinkReferenceArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryAutolinkReference)(nil)).Elem() +} + +func (i RepositoryAutolinkReferenceArray) ToRepositoryAutolinkReferenceArrayOutput() RepositoryAutolinkReferenceArrayOutput { + return i.ToRepositoryAutolinkReferenceArrayOutputWithContext(context.Background()) +} + +func (i RepositoryAutolinkReferenceArray) ToRepositoryAutolinkReferenceArrayOutputWithContext(ctx context.Context) RepositoryAutolinkReferenceArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryAutolinkReferenceArrayOutput) +} + +// RepositoryAutolinkReferenceMapInput is an input type that accepts RepositoryAutolinkReferenceMap and RepositoryAutolinkReferenceMapOutput values. +// You can construct a concrete instance of `RepositoryAutolinkReferenceMapInput` via: +// +// RepositoryAutolinkReferenceMap{ "key": RepositoryAutolinkReferenceArgs{...} } +type RepositoryAutolinkReferenceMapInput interface { + pulumi.Input + + ToRepositoryAutolinkReferenceMapOutput() RepositoryAutolinkReferenceMapOutput + ToRepositoryAutolinkReferenceMapOutputWithContext(context.Context) RepositoryAutolinkReferenceMapOutput +} + +type RepositoryAutolinkReferenceMap map[string]RepositoryAutolinkReferenceInput + +func (RepositoryAutolinkReferenceMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryAutolinkReference)(nil)).Elem() +} + +func (i RepositoryAutolinkReferenceMap) ToRepositoryAutolinkReferenceMapOutput() RepositoryAutolinkReferenceMapOutput { + return i.ToRepositoryAutolinkReferenceMapOutputWithContext(context.Background()) +} + +func (i RepositoryAutolinkReferenceMap) ToRepositoryAutolinkReferenceMapOutputWithContext(ctx context.Context) RepositoryAutolinkReferenceMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryAutolinkReferenceMapOutput) +} + +type RepositoryAutolinkReferenceOutput struct{ *pulumi.OutputState } + +func (RepositoryAutolinkReferenceOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryAutolinkReference)(nil)).Elem() +} + +func (o RepositoryAutolinkReferenceOutput) ToRepositoryAutolinkReferenceOutput() RepositoryAutolinkReferenceOutput { + return o +} + +func (o RepositoryAutolinkReferenceOutput) ToRepositoryAutolinkReferenceOutputWithContext(ctx context.Context) RepositoryAutolinkReferenceOutput { + return o +} + +// An etag representing the autolink reference object. +func (o RepositoryAutolinkReferenceOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryAutolinkReference) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// Whether this autolink reference matches alphanumeric characters. If false, this autolink reference only matches numeric characters. Default is true. +func (o RepositoryAutolinkReferenceOutput) IsAlphanumeric() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryAutolinkReference) pulumi.BoolPtrOutput { return v.IsAlphanumeric }).(pulumi.BoolPtrOutput) +} + +// This prefix appended by a number will generate a link any time it is found in an issue, pull request, or commit. +func (o RepositoryAutolinkReferenceOutput) KeyPrefix() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryAutolinkReference) pulumi.StringOutput { return v.KeyPrefix }).(pulumi.StringOutput) +} + +// The repository of the autolink reference. +func (o RepositoryAutolinkReferenceOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryAutolinkReference) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// The template of the target URL used for the links; must be a valid URL and contain `` for the reference number +func (o RepositoryAutolinkReferenceOutput) TargetUrlTemplate() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryAutolinkReference) pulumi.StringOutput { return v.TargetUrlTemplate }).(pulumi.StringOutput) +} + +type RepositoryAutolinkReferenceArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryAutolinkReferenceArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryAutolinkReference)(nil)).Elem() +} + +func (o RepositoryAutolinkReferenceArrayOutput) ToRepositoryAutolinkReferenceArrayOutput() RepositoryAutolinkReferenceArrayOutput { + return o +} + +func (o RepositoryAutolinkReferenceArrayOutput) ToRepositoryAutolinkReferenceArrayOutputWithContext(ctx context.Context) RepositoryAutolinkReferenceArrayOutput { + return o +} + +func (o RepositoryAutolinkReferenceArrayOutput) Index(i pulumi.IntInput) RepositoryAutolinkReferenceOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryAutolinkReference { + return vs[0].([]*RepositoryAutolinkReference)[vs[1].(int)] + }).(RepositoryAutolinkReferenceOutput) +} + +type RepositoryAutolinkReferenceMapOutput struct{ *pulumi.OutputState } + +func (RepositoryAutolinkReferenceMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryAutolinkReference)(nil)).Elem() +} + +func (o RepositoryAutolinkReferenceMapOutput) ToRepositoryAutolinkReferenceMapOutput() RepositoryAutolinkReferenceMapOutput { + return o +} + +func (o RepositoryAutolinkReferenceMapOutput) ToRepositoryAutolinkReferenceMapOutputWithContext(ctx context.Context) RepositoryAutolinkReferenceMapOutput { + return o +} + +func (o RepositoryAutolinkReferenceMapOutput) MapIndex(k pulumi.StringInput) RepositoryAutolinkReferenceOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryAutolinkReference { + return vs[0].(map[string]*RepositoryAutolinkReference)[vs[1].(string)] + }).(RepositoryAutolinkReferenceOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryAutolinkReferenceInput)(nil)).Elem(), &RepositoryAutolinkReference{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryAutolinkReferenceArrayInput)(nil)).Elem(), RepositoryAutolinkReferenceArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryAutolinkReferenceMapInput)(nil)).Elem(), RepositoryAutolinkReferenceMap{}) + pulumi.RegisterOutputType(RepositoryAutolinkReferenceOutput{}) + pulumi.RegisterOutputType(RepositoryAutolinkReferenceArrayOutput{}) + pulumi.RegisterOutputType(RepositoryAutolinkReferenceMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryCollaborator.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryCollaborator.go new file mode 100644 index 000000000..0b448b08c --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryCollaborator.go @@ -0,0 +1,364 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Provides a GitHub repository collaborator resource. +// +// > Note: RepositoryCollaborator cannot be used in conjunction with RepositoryCollaborators or +// they will fight over what your policy should be. +// +// 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 +// (implicitly 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. +// +// > **Note on Archived Repositories**: When a repository is archived, GitHub makes it read-only, preventing collaborator modifications. If you attempt to destroy resources associated with archived repositories, the provider will gracefully handle the operation by logging an informational message and removing the resource from Terraform state without attempting to modify the archived repository. +// +// This resource is non-authoritative, for managing ALL collaborators of a repo, use RepositoryCollaborators +// instead. +// +// 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/v6/go/github" +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// // Add a collaborator to a repository +// _, err := github.NewRepositoryCollaborator(ctx, "a_repo_collaborator", &github.RepositoryCollaboratorArgs{ +// Repository: pulumi.String("our-cool-repo"), +// Username: pulumi.String("SomeUser"), +// Permission: pulumi.String("admin"), +// }) +// 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` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organization 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 + // + // > Note: The owner of the repository can be passed as part of the repository name e.g. `owner-org-name/repo-name`. If owner is not supplied as part of the repository name, it may also be supplied by setting the environment variable `GITHUB_OWNER`. + 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'") + } + opts = internal.PkgResourceDefaultOpts(opts) + 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` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organization 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 + // + // > Note: The owner of the repository can be passed as part of the repository name e.g. `owner-org-name/repo-name`. If owner is not supplied as part of the repository name, it may also be supplied by setting the environment variable `GITHUB_OWNER`. + 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` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organization 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 + // + // > Note: The owner of the repository can be passed as part of the repository name e.g. `owner-org-name/repo-name`. If owner is not supplied as part of the repository name, it may also be supplied by setting the environment variable `GITHUB_OWNER`. + 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` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organization 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 + // + // > Note: The owner of the repository can be passed as part of the repository name e.g. `owner-org-name/repo-name`. If owner is not supplied as part of the repository name, it may also be supplied by setting the environment variable `GITHUB_OWNER`. + 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` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organization 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 + // + // > Note: The owner of the repository can be passed as part of the repository name e.g. `owner-org-name/repo-name`. If owner is not supplied as part of the repository name, it may also be supplied by setting the environment variable `GITHUB_OWNER`. + 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` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organization 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 +// +// > Note: The owner of the repository can be passed as part of the repository name e.g. `owner-org-name/repo-name`. If owner is not supplied as part of the repository name, it may also be supplied by setting the environment variable `GITHUB_OWNER`. +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{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryCollaborators.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryCollaborators.go new file mode 100644 index 000000000..0cdcd9a1d --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryCollaborators.go @@ -0,0 +1,367 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Provides a GitHub repository collaborators resource. +// +// > Note: RepositoryCollaborators cannot be used in conjunction with RepositoryCollaborator and +// TeamRepository or they will fight over what your policy should be. +// +// This resource allows you to manage all collaborators for 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 +// (implicitly includes read) permission. +// +// When applied, an invitation will be sent to the user to become a collaborators +// on a repository. When destroyed, either the invitation will be cancelled or the +// collaborators will be removed from the repository. +// +// > **Note on Archived Repositories**: When a repository is archived, GitHub makes it read-only, preventing collaborator modifications. If you attempt to destroy resources associated with archived repositories, the provider will gracefully handle the operation by logging an informational message and removing the resource from Terraform state without attempting to modify the archived repository. +// +// This resource is authoritative. For adding a collaborator to a repo in a non-authoritative manner, use +// RepositoryCollaborator instead. +// +// 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 collaborators](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/v6/go/github" +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// // Add collaborators to a repository +// someTeam, err := github.NewTeam(ctx, "some_team", &github.TeamArgs{ +// Name: pulumi.String("SomeTeam"), +// Description: pulumi.String("Some cool team"), +// }) +// if err != nil { +// return err +// } +// someRepo, err := github.NewRepository(ctx, "some_repo", &github.RepositoryArgs{ +// Name: pulumi.String("some-repo"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryCollaborators(ctx, "some_repo_collaborators", &github.RepositoryCollaboratorsArgs{ +// Repository: someRepo.Name, +// Users: github.RepositoryCollaboratorsUserArray{ +// &github.RepositoryCollaboratorsUserArgs{ +// Permission: pulumi.String("admin"), +// Username: pulumi.String("SomeUser"), +// }, +// }, +// Teams: github.RepositoryCollaboratorsTeamArray{ +// &github.RepositoryCollaboratorsTeamArgs{ +// Permission: pulumi.String("pull"), +// TeamId: someTeam.Slug, +// }, +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +type RepositoryCollaborators struct { + pulumi.CustomResourceState + + // List of teams to ignore when checking for repository access. This supports ignoring teams granted access at an organizational level. + IgnoreTeams RepositoryCollaboratorsIgnoreTeamArrayOutput `pulumi:"ignoreTeams"` + // Map of usernames to invitation ID for any users added as part of creation of this resource to + // be used in `UserInvitationAccepter`. + InvitationIds pulumi.StringMapOutput `pulumi:"invitationIds"` + // The GitHub repository. + Repository pulumi.StringOutput `pulumi:"repository"` + // ID of the repository. + RepositoryId pulumi.IntOutput `pulumi:"repositoryId"` + // List of teams to grant access to the repository. + Teams RepositoryCollaboratorsTeamArrayOutput `pulumi:"teams"` + // List of users to grant access to the repository. + Users RepositoryCollaboratorsUserArrayOutput `pulumi:"users"` +} + +// NewRepositoryCollaborators registers a new resource with the given unique name, arguments, and options. +func NewRepositoryCollaborators(ctx *pulumi.Context, + name string, args *RepositoryCollaboratorsArgs, opts ...pulumi.ResourceOption) (*RepositoryCollaborators, 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'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryCollaborators + err := ctx.RegisterResource("github:index/repositoryCollaborators:RepositoryCollaborators", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryCollaborators gets an existing RepositoryCollaborators 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 GetRepositoryCollaborators(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryCollaboratorsState, opts ...pulumi.ResourceOption) (*RepositoryCollaborators, error) { + var resource RepositoryCollaborators + err := ctx.ReadResource("github:index/repositoryCollaborators:RepositoryCollaborators", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryCollaborators resources. +type repositoryCollaboratorsState struct { + // List of teams to ignore when checking for repository access. This supports ignoring teams granted access at an organizational level. + IgnoreTeams []RepositoryCollaboratorsIgnoreTeam `pulumi:"ignoreTeams"` + // Map of usernames to invitation ID for any users added as part of creation of this resource to + // be used in `UserInvitationAccepter`. + InvitationIds map[string]string `pulumi:"invitationIds"` + // The GitHub repository. + Repository *string `pulumi:"repository"` + // ID of the repository. + RepositoryId *int `pulumi:"repositoryId"` + // List of teams to grant access to the repository. + Teams []RepositoryCollaboratorsTeam `pulumi:"teams"` + // List of users to grant access to the repository. + Users []RepositoryCollaboratorsUser `pulumi:"users"` +} + +type RepositoryCollaboratorsState struct { + // List of teams to ignore when checking for repository access. This supports ignoring teams granted access at an organizational level. + IgnoreTeams RepositoryCollaboratorsIgnoreTeamArrayInput + // Map of usernames to invitation ID for any users added as part of creation of this resource to + // be used in `UserInvitationAccepter`. + InvitationIds pulumi.StringMapInput + // The GitHub repository. + Repository pulumi.StringPtrInput + // ID of the repository. + RepositoryId pulumi.IntPtrInput + // List of teams to grant access to the repository. + Teams RepositoryCollaboratorsTeamArrayInput + // List of users to grant access to the repository. + Users RepositoryCollaboratorsUserArrayInput +} + +func (RepositoryCollaboratorsState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryCollaboratorsState)(nil)).Elem() +} + +type repositoryCollaboratorsArgs struct { + // List of teams to ignore when checking for repository access. This supports ignoring teams granted access at an organizational level. + IgnoreTeams []RepositoryCollaboratorsIgnoreTeam `pulumi:"ignoreTeams"` + // The GitHub repository. + Repository string `pulumi:"repository"` + // List of teams to grant access to the repository. + Teams []RepositoryCollaboratorsTeam `pulumi:"teams"` + // List of users to grant access to the repository. + Users []RepositoryCollaboratorsUser `pulumi:"users"` +} + +// The set of arguments for constructing a RepositoryCollaborators resource. +type RepositoryCollaboratorsArgs struct { + // List of teams to ignore when checking for repository access. This supports ignoring teams granted access at an organizational level. + IgnoreTeams RepositoryCollaboratorsIgnoreTeamArrayInput + // The GitHub repository. + Repository pulumi.StringInput + // List of teams to grant access to the repository. + Teams RepositoryCollaboratorsTeamArrayInput + // List of users to grant access to the repository. + Users RepositoryCollaboratorsUserArrayInput +} + +func (RepositoryCollaboratorsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryCollaboratorsArgs)(nil)).Elem() +} + +type RepositoryCollaboratorsInput interface { + pulumi.Input + + ToRepositoryCollaboratorsOutput() RepositoryCollaboratorsOutput + ToRepositoryCollaboratorsOutputWithContext(ctx context.Context) RepositoryCollaboratorsOutput +} + +func (*RepositoryCollaborators) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryCollaborators)(nil)).Elem() +} + +func (i *RepositoryCollaborators) ToRepositoryCollaboratorsOutput() RepositoryCollaboratorsOutput { + return i.ToRepositoryCollaboratorsOutputWithContext(context.Background()) +} + +func (i *RepositoryCollaborators) ToRepositoryCollaboratorsOutputWithContext(ctx context.Context) RepositoryCollaboratorsOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryCollaboratorsOutput) +} + +// RepositoryCollaboratorsArrayInput is an input type that accepts RepositoryCollaboratorsArray and RepositoryCollaboratorsArrayOutput values. +// You can construct a concrete instance of `RepositoryCollaboratorsArrayInput` via: +// +// RepositoryCollaboratorsArray{ RepositoryCollaboratorsArgs{...} } +type RepositoryCollaboratorsArrayInput interface { + pulumi.Input + + ToRepositoryCollaboratorsArrayOutput() RepositoryCollaboratorsArrayOutput + ToRepositoryCollaboratorsArrayOutputWithContext(context.Context) RepositoryCollaboratorsArrayOutput +} + +type RepositoryCollaboratorsArray []RepositoryCollaboratorsInput + +func (RepositoryCollaboratorsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryCollaborators)(nil)).Elem() +} + +func (i RepositoryCollaboratorsArray) ToRepositoryCollaboratorsArrayOutput() RepositoryCollaboratorsArrayOutput { + return i.ToRepositoryCollaboratorsArrayOutputWithContext(context.Background()) +} + +func (i RepositoryCollaboratorsArray) ToRepositoryCollaboratorsArrayOutputWithContext(ctx context.Context) RepositoryCollaboratorsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryCollaboratorsArrayOutput) +} + +// RepositoryCollaboratorsMapInput is an input type that accepts RepositoryCollaboratorsMap and RepositoryCollaboratorsMapOutput values. +// You can construct a concrete instance of `RepositoryCollaboratorsMapInput` via: +// +// RepositoryCollaboratorsMap{ "key": RepositoryCollaboratorsArgs{...} } +type RepositoryCollaboratorsMapInput interface { + pulumi.Input + + ToRepositoryCollaboratorsMapOutput() RepositoryCollaboratorsMapOutput + ToRepositoryCollaboratorsMapOutputWithContext(context.Context) RepositoryCollaboratorsMapOutput +} + +type RepositoryCollaboratorsMap map[string]RepositoryCollaboratorsInput + +func (RepositoryCollaboratorsMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryCollaborators)(nil)).Elem() +} + +func (i RepositoryCollaboratorsMap) ToRepositoryCollaboratorsMapOutput() RepositoryCollaboratorsMapOutput { + return i.ToRepositoryCollaboratorsMapOutputWithContext(context.Background()) +} + +func (i RepositoryCollaboratorsMap) ToRepositoryCollaboratorsMapOutputWithContext(ctx context.Context) RepositoryCollaboratorsMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryCollaboratorsMapOutput) +} + +type RepositoryCollaboratorsOutput struct{ *pulumi.OutputState } + +func (RepositoryCollaboratorsOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryCollaborators)(nil)).Elem() +} + +func (o RepositoryCollaboratorsOutput) ToRepositoryCollaboratorsOutput() RepositoryCollaboratorsOutput { + return o +} + +func (o RepositoryCollaboratorsOutput) ToRepositoryCollaboratorsOutputWithContext(ctx context.Context) RepositoryCollaboratorsOutput { + return o +} + +// List of teams to ignore when checking for repository access. This supports ignoring teams granted access at an organizational level. +func (o RepositoryCollaboratorsOutput) IgnoreTeams() RepositoryCollaboratorsIgnoreTeamArrayOutput { + return o.ApplyT(func(v *RepositoryCollaborators) RepositoryCollaboratorsIgnoreTeamArrayOutput { return v.IgnoreTeams }).(RepositoryCollaboratorsIgnoreTeamArrayOutput) +} + +// Map of usernames to invitation ID for any users added as part of creation of this resource to +// be used in `UserInvitationAccepter`. +func (o RepositoryCollaboratorsOutput) InvitationIds() pulumi.StringMapOutput { + return o.ApplyT(func(v *RepositoryCollaborators) pulumi.StringMapOutput { return v.InvitationIds }).(pulumi.StringMapOutput) +} + +// The GitHub repository. +func (o RepositoryCollaboratorsOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryCollaborators) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// ID of the repository. +func (o RepositoryCollaboratorsOutput) RepositoryId() pulumi.IntOutput { + return o.ApplyT(func(v *RepositoryCollaborators) pulumi.IntOutput { return v.RepositoryId }).(pulumi.IntOutput) +} + +// List of teams to grant access to the repository. +func (o RepositoryCollaboratorsOutput) Teams() RepositoryCollaboratorsTeamArrayOutput { + return o.ApplyT(func(v *RepositoryCollaborators) RepositoryCollaboratorsTeamArrayOutput { return v.Teams }).(RepositoryCollaboratorsTeamArrayOutput) +} + +// List of users to grant access to the repository. +func (o RepositoryCollaboratorsOutput) Users() RepositoryCollaboratorsUserArrayOutput { + return o.ApplyT(func(v *RepositoryCollaborators) RepositoryCollaboratorsUserArrayOutput { return v.Users }).(RepositoryCollaboratorsUserArrayOutput) +} + +type RepositoryCollaboratorsArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryCollaboratorsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryCollaborators)(nil)).Elem() +} + +func (o RepositoryCollaboratorsArrayOutput) ToRepositoryCollaboratorsArrayOutput() RepositoryCollaboratorsArrayOutput { + return o +} + +func (o RepositoryCollaboratorsArrayOutput) ToRepositoryCollaboratorsArrayOutputWithContext(ctx context.Context) RepositoryCollaboratorsArrayOutput { + return o +} + +func (o RepositoryCollaboratorsArrayOutput) Index(i pulumi.IntInput) RepositoryCollaboratorsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryCollaborators { + return vs[0].([]*RepositoryCollaborators)[vs[1].(int)] + }).(RepositoryCollaboratorsOutput) +} + +type RepositoryCollaboratorsMapOutput struct{ *pulumi.OutputState } + +func (RepositoryCollaboratorsMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryCollaborators)(nil)).Elem() +} + +func (o RepositoryCollaboratorsMapOutput) ToRepositoryCollaboratorsMapOutput() RepositoryCollaboratorsMapOutput { + return o +} + +func (o RepositoryCollaboratorsMapOutput) ToRepositoryCollaboratorsMapOutputWithContext(ctx context.Context) RepositoryCollaboratorsMapOutput { + return o +} + +func (o RepositoryCollaboratorsMapOutput) MapIndex(k pulumi.StringInput) RepositoryCollaboratorsOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryCollaborators { + return vs[0].(map[string]*RepositoryCollaborators)[vs[1].(string)] + }).(RepositoryCollaboratorsOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryCollaboratorsInput)(nil)).Elem(), &RepositoryCollaborators{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryCollaboratorsArrayInput)(nil)).Elem(), RepositoryCollaboratorsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryCollaboratorsMapInput)(nil)).Elem(), RepositoryCollaboratorsMap{}) + pulumi.RegisterOutputType(RepositoryCollaboratorsOutput{}) + pulumi.RegisterOutputType(RepositoryCollaboratorsArrayOutput{}) + pulumi.RegisterOutputType(RepositoryCollaboratorsMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryCustomProperty.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryCustomProperty.go new file mode 100644 index 000000000..ad7741b6c --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryCustomProperty.go @@ -0,0 +1,321 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage a specific custom property for a GitHub repository. +// +// ## Example Usage +// +// > Note that this assumes there already is a custom property defined on the org level called `my-cool-property` of type `string` +// +// ```go +// 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("example"), +// Description: pulumi.String("My awesome codebase"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryCustomProperty(ctx, "string", &github.RepositoryCustomPropertyArgs{ +// Repository: example.Name, +// PropertyName: pulumi.String("my-cool-property"), +// PropertyType: pulumi.String("string"), +// PropertyValues: pulumi.StringArray{ +// pulumi.String("test"), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Repository Custom Property can be imported using an ID made up of a combination of the names of the organization, repository, custom property separated by a `:` character, e.g. +// +// ```sh +// $ pulumi import github:index/repositoryCustomProperty:RepositoryCustomProperty example organization-name:repo-name:custom-property-name +// ``` +type RepositoryCustomProperty struct { + pulumi.CustomResourceState + + // Name of the custom property. Note that a pre-requisiste for this resource is that a custom property of this name has already been defined on the organization level + PropertyName pulumi.StringOutput `pulumi:"propertyName"` + // Type of the custom property. Can be one of `singleSelect`, `multiSelect`, `string`, or `trueFalse` + PropertyType pulumi.StringOutput `pulumi:"propertyType"` + // Value of the custom property in the form of an array. Properties of type `singleSelect`, `string`, and `trueFalse` are represented as a string array of length 1 + PropertyValues pulumi.StringArrayOutput `pulumi:"propertyValues"` + // The repository of the environment. + Repository pulumi.StringOutput `pulumi:"repository"` +} + +// NewRepositoryCustomProperty registers a new resource with the given unique name, arguments, and options. +func NewRepositoryCustomProperty(ctx *pulumi.Context, + name string, args *RepositoryCustomPropertyArgs, opts ...pulumi.ResourceOption) (*RepositoryCustomProperty, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.PropertyName == nil { + return nil, errors.New("invalid value for required argument 'PropertyName'") + } + if args.PropertyType == nil { + return nil, errors.New("invalid value for required argument 'PropertyType'") + } + if args.PropertyValues == nil { + return nil, errors.New("invalid value for required argument 'PropertyValues'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryCustomProperty + err := ctx.RegisterResource("github:index/repositoryCustomProperty:RepositoryCustomProperty", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryCustomProperty gets an existing RepositoryCustomProperty 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 GetRepositoryCustomProperty(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryCustomPropertyState, opts ...pulumi.ResourceOption) (*RepositoryCustomProperty, error) { + var resource RepositoryCustomProperty + err := ctx.ReadResource("github:index/repositoryCustomProperty:RepositoryCustomProperty", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryCustomProperty resources. +type repositoryCustomPropertyState struct { + // Name of the custom property. Note that a pre-requisiste for this resource is that a custom property of this name has already been defined on the organization level + PropertyName *string `pulumi:"propertyName"` + // Type of the custom property. Can be one of `singleSelect`, `multiSelect`, `string`, or `trueFalse` + PropertyType *string `pulumi:"propertyType"` + // Value of the custom property in the form of an array. Properties of type `singleSelect`, `string`, and `trueFalse` are represented as a string array of length 1 + PropertyValues []string `pulumi:"propertyValues"` + // The repository of the environment. + Repository *string `pulumi:"repository"` +} + +type RepositoryCustomPropertyState struct { + // Name of the custom property. Note that a pre-requisiste for this resource is that a custom property of this name has already been defined on the organization level + PropertyName pulumi.StringPtrInput + // Type of the custom property. Can be one of `singleSelect`, `multiSelect`, `string`, or `trueFalse` + PropertyType pulumi.StringPtrInput + // Value of the custom property in the form of an array. Properties of type `singleSelect`, `string`, and `trueFalse` are represented as a string array of length 1 + PropertyValues pulumi.StringArrayInput + // The repository of the environment. + Repository pulumi.StringPtrInput +} + +func (RepositoryCustomPropertyState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryCustomPropertyState)(nil)).Elem() +} + +type repositoryCustomPropertyArgs struct { + // Name of the custom property. Note that a pre-requisiste for this resource is that a custom property of this name has already been defined on the organization level + PropertyName string `pulumi:"propertyName"` + // Type of the custom property. Can be one of `singleSelect`, `multiSelect`, `string`, or `trueFalse` + PropertyType string `pulumi:"propertyType"` + // Value of the custom property in the form of an array. Properties of type `singleSelect`, `string`, and `trueFalse` are represented as a string array of length 1 + PropertyValues []string `pulumi:"propertyValues"` + // The repository of the environment. + Repository string `pulumi:"repository"` +} + +// The set of arguments for constructing a RepositoryCustomProperty resource. +type RepositoryCustomPropertyArgs struct { + // Name of the custom property. Note that a pre-requisiste for this resource is that a custom property of this name has already been defined on the organization level + PropertyName pulumi.StringInput + // Type of the custom property. Can be one of `singleSelect`, `multiSelect`, `string`, or `trueFalse` + PropertyType pulumi.StringInput + // Value of the custom property in the form of an array. Properties of type `singleSelect`, `string`, and `trueFalse` are represented as a string array of length 1 + PropertyValues pulumi.StringArrayInput + // The repository of the environment. + Repository pulumi.StringInput +} + +func (RepositoryCustomPropertyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryCustomPropertyArgs)(nil)).Elem() +} + +type RepositoryCustomPropertyInput interface { + pulumi.Input + + ToRepositoryCustomPropertyOutput() RepositoryCustomPropertyOutput + ToRepositoryCustomPropertyOutputWithContext(ctx context.Context) RepositoryCustomPropertyOutput +} + +func (*RepositoryCustomProperty) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryCustomProperty)(nil)).Elem() +} + +func (i *RepositoryCustomProperty) ToRepositoryCustomPropertyOutput() RepositoryCustomPropertyOutput { + return i.ToRepositoryCustomPropertyOutputWithContext(context.Background()) +} + +func (i *RepositoryCustomProperty) ToRepositoryCustomPropertyOutputWithContext(ctx context.Context) RepositoryCustomPropertyOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryCustomPropertyOutput) +} + +// RepositoryCustomPropertyArrayInput is an input type that accepts RepositoryCustomPropertyArray and RepositoryCustomPropertyArrayOutput values. +// You can construct a concrete instance of `RepositoryCustomPropertyArrayInput` via: +// +// RepositoryCustomPropertyArray{ RepositoryCustomPropertyArgs{...} } +type RepositoryCustomPropertyArrayInput interface { + pulumi.Input + + ToRepositoryCustomPropertyArrayOutput() RepositoryCustomPropertyArrayOutput + ToRepositoryCustomPropertyArrayOutputWithContext(context.Context) RepositoryCustomPropertyArrayOutput +} + +type RepositoryCustomPropertyArray []RepositoryCustomPropertyInput + +func (RepositoryCustomPropertyArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryCustomProperty)(nil)).Elem() +} + +func (i RepositoryCustomPropertyArray) ToRepositoryCustomPropertyArrayOutput() RepositoryCustomPropertyArrayOutput { + return i.ToRepositoryCustomPropertyArrayOutputWithContext(context.Background()) +} + +func (i RepositoryCustomPropertyArray) ToRepositoryCustomPropertyArrayOutputWithContext(ctx context.Context) RepositoryCustomPropertyArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryCustomPropertyArrayOutput) +} + +// RepositoryCustomPropertyMapInput is an input type that accepts RepositoryCustomPropertyMap and RepositoryCustomPropertyMapOutput values. +// You can construct a concrete instance of `RepositoryCustomPropertyMapInput` via: +// +// RepositoryCustomPropertyMap{ "key": RepositoryCustomPropertyArgs{...} } +type RepositoryCustomPropertyMapInput interface { + pulumi.Input + + ToRepositoryCustomPropertyMapOutput() RepositoryCustomPropertyMapOutput + ToRepositoryCustomPropertyMapOutputWithContext(context.Context) RepositoryCustomPropertyMapOutput +} + +type RepositoryCustomPropertyMap map[string]RepositoryCustomPropertyInput + +func (RepositoryCustomPropertyMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryCustomProperty)(nil)).Elem() +} + +func (i RepositoryCustomPropertyMap) ToRepositoryCustomPropertyMapOutput() RepositoryCustomPropertyMapOutput { + return i.ToRepositoryCustomPropertyMapOutputWithContext(context.Background()) +} + +func (i RepositoryCustomPropertyMap) ToRepositoryCustomPropertyMapOutputWithContext(ctx context.Context) RepositoryCustomPropertyMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryCustomPropertyMapOutput) +} + +type RepositoryCustomPropertyOutput struct{ *pulumi.OutputState } + +func (RepositoryCustomPropertyOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryCustomProperty)(nil)).Elem() +} + +func (o RepositoryCustomPropertyOutput) ToRepositoryCustomPropertyOutput() RepositoryCustomPropertyOutput { + return o +} + +func (o RepositoryCustomPropertyOutput) ToRepositoryCustomPropertyOutputWithContext(ctx context.Context) RepositoryCustomPropertyOutput { + return o +} + +// Name of the custom property. Note that a pre-requisiste for this resource is that a custom property of this name has already been defined on the organization level +func (o RepositoryCustomPropertyOutput) PropertyName() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryCustomProperty) pulumi.StringOutput { return v.PropertyName }).(pulumi.StringOutput) +} + +// Type of the custom property. Can be one of `singleSelect`, `multiSelect`, `string`, or `trueFalse` +func (o RepositoryCustomPropertyOutput) PropertyType() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryCustomProperty) pulumi.StringOutput { return v.PropertyType }).(pulumi.StringOutput) +} + +// Value of the custom property in the form of an array. Properties of type `singleSelect`, `string`, and `trueFalse` are represented as a string array of length 1 +func (o RepositoryCustomPropertyOutput) PropertyValues() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RepositoryCustomProperty) pulumi.StringArrayOutput { return v.PropertyValues }).(pulumi.StringArrayOutput) +} + +// The repository of the environment. +func (o RepositoryCustomPropertyOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryCustomProperty) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +type RepositoryCustomPropertyArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryCustomPropertyArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryCustomProperty)(nil)).Elem() +} + +func (o RepositoryCustomPropertyArrayOutput) ToRepositoryCustomPropertyArrayOutput() RepositoryCustomPropertyArrayOutput { + return o +} + +func (o RepositoryCustomPropertyArrayOutput) ToRepositoryCustomPropertyArrayOutputWithContext(ctx context.Context) RepositoryCustomPropertyArrayOutput { + return o +} + +func (o RepositoryCustomPropertyArrayOutput) Index(i pulumi.IntInput) RepositoryCustomPropertyOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryCustomProperty { + return vs[0].([]*RepositoryCustomProperty)[vs[1].(int)] + }).(RepositoryCustomPropertyOutput) +} + +type RepositoryCustomPropertyMapOutput struct{ *pulumi.OutputState } + +func (RepositoryCustomPropertyMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryCustomProperty)(nil)).Elem() +} + +func (o RepositoryCustomPropertyMapOutput) ToRepositoryCustomPropertyMapOutput() RepositoryCustomPropertyMapOutput { + return o +} + +func (o RepositoryCustomPropertyMapOutput) ToRepositoryCustomPropertyMapOutputWithContext(ctx context.Context) RepositoryCustomPropertyMapOutput { + return o +} + +func (o RepositoryCustomPropertyMapOutput) MapIndex(k pulumi.StringInput) RepositoryCustomPropertyOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryCustomProperty { + return vs[0].(map[string]*RepositoryCustomProperty)[vs[1].(string)] + }).(RepositoryCustomPropertyOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryCustomPropertyInput)(nil)).Elem(), &RepositoryCustomProperty{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryCustomPropertyArrayInput)(nil)).Elem(), RepositoryCustomPropertyArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryCustomPropertyMapInput)(nil)).Elem(), RepositoryCustomPropertyMap{}) + pulumi.RegisterOutputType(RepositoryCustomPropertyOutput{}) + pulumi.RegisterOutputType(RepositoryCustomPropertyArrayOutput{}) + pulumi.RegisterOutputType(RepositoryCustomPropertyMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryDependabotSecurityUpdates.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryDependabotSecurityUpdates.go new file mode 100644 index 000000000..185a2ade6 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryDependabotSecurityUpdates.go @@ -0,0 +1,285 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to manage dependabot automated security fixes for a single repository. See the +// [documentation](https://docs.github.com/en/code-security/dependabot/dependabot-security-updates/about-dependabot-security-updates) +// for details of usage and how this will impact your repository +// +// ## Example Usage +// +// ```go +// 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.NewRepository(ctx, "repo", &github.RepositoryArgs{ +// Name: pulumi.String("my-repo"), +// Description: pulumi.String("GitHub repo managed by Terraform"), +// Private: pulumi.Bool(false), +// VulnerabilityAlerts: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryDependabotSecurityUpdates(ctx, "example", &github.RepositoryDependabotSecurityUpdatesArgs{ +// Repository: pulumi.Any(test.Name), +// Enabled: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// # Automated security references can be imported using the `name` of the repository +// +// ### Import by name +// +// ```sh +// $ pulumi import github:index/repositoryDependabotSecurityUpdates:RepositoryDependabotSecurityUpdates example my-repo +// ``` +type RepositoryDependabotSecurityUpdates struct { + pulumi.CustomResourceState + + // The state of the automated security fixes. + Enabled pulumi.BoolOutput `pulumi:"enabled"` + // The name of the GitHub repository. + Repository pulumi.StringOutput `pulumi:"repository"` +} + +// NewRepositoryDependabotSecurityUpdates registers a new resource with the given unique name, arguments, and options. +func NewRepositoryDependabotSecurityUpdates(ctx *pulumi.Context, + name string, args *RepositoryDependabotSecurityUpdatesArgs, opts ...pulumi.ResourceOption) (*RepositoryDependabotSecurityUpdates, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Enabled == nil { + return nil, errors.New("invalid value for required argument 'Enabled'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryDependabotSecurityUpdates + err := ctx.RegisterResource("github:index/repositoryDependabotSecurityUpdates:RepositoryDependabotSecurityUpdates", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryDependabotSecurityUpdates gets an existing RepositoryDependabotSecurityUpdates 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 GetRepositoryDependabotSecurityUpdates(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryDependabotSecurityUpdatesState, opts ...pulumi.ResourceOption) (*RepositoryDependabotSecurityUpdates, error) { + var resource RepositoryDependabotSecurityUpdates + err := ctx.ReadResource("github:index/repositoryDependabotSecurityUpdates:RepositoryDependabotSecurityUpdates", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryDependabotSecurityUpdates resources. +type repositoryDependabotSecurityUpdatesState struct { + // The state of the automated security fixes. + Enabled *bool `pulumi:"enabled"` + // The name of the GitHub repository. + Repository *string `pulumi:"repository"` +} + +type RepositoryDependabotSecurityUpdatesState struct { + // The state of the automated security fixes. + Enabled pulumi.BoolPtrInput + // The name of the GitHub repository. + Repository pulumi.StringPtrInput +} + +func (RepositoryDependabotSecurityUpdatesState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryDependabotSecurityUpdatesState)(nil)).Elem() +} + +type repositoryDependabotSecurityUpdatesArgs struct { + // The state of the automated security fixes. + Enabled bool `pulumi:"enabled"` + // The name of the GitHub repository. + Repository string `pulumi:"repository"` +} + +// The set of arguments for constructing a RepositoryDependabotSecurityUpdates resource. +type RepositoryDependabotSecurityUpdatesArgs struct { + // The state of the automated security fixes. + Enabled pulumi.BoolInput + // The name of the GitHub repository. + Repository pulumi.StringInput +} + +func (RepositoryDependabotSecurityUpdatesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryDependabotSecurityUpdatesArgs)(nil)).Elem() +} + +type RepositoryDependabotSecurityUpdatesInput interface { + pulumi.Input + + ToRepositoryDependabotSecurityUpdatesOutput() RepositoryDependabotSecurityUpdatesOutput + ToRepositoryDependabotSecurityUpdatesOutputWithContext(ctx context.Context) RepositoryDependabotSecurityUpdatesOutput +} + +func (*RepositoryDependabotSecurityUpdates) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryDependabotSecurityUpdates)(nil)).Elem() +} + +func (i *RepositoryDependabotSecurityUpdates) ToRepositoryDependabotSecurityUpdatesOutput() RepositoryDependabotSecurityUpdatesOutput { + return i.ToRepositoryDependabotSecurityUpdatesOutputWithContext(context.Background()) +} + +func (i *RepositoryDependabotSecurityUpdates) ToRepositoryDependabotSecurityUpdatesOutputWithContext(ctx context.Context) RepositoryDependabotSecurityUpdatesOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryDependabotSecurityUpdatesOutput) +} + +// RepositoryDependabotSecurityUpdatesArrayInput is an input type that accepts RepositoryDependabotSecurityUpdatesArray and RepositoryDependabotSecurityUpdatesArrayOutput values. +// You can construct a concrete instance of `RepositoryDependabotSecurityUpdatesArrayInput` via: +// +// RepositoryDependabotSecurityUpdatesArray{ RepositoryDependabotSecurityUpdatesArgs{...} } +type RepositoryDependabotSecurityUpdatesArrayInput interface { + pulumi.Input + + ToRepositoryDependabotSecurityUpdatesArrayOutput() RepositoryDependabotSecurityUpdatesArrayOutput + ToRepositoryDependabotSecurityUpdatesArrayOutputWithContext(context.Context) RepositoryDependabotSecurityUpdatesArrayOutput +} + +type RepositoryDependabotSecurityUpdatesArray []RepositoryDependabotSecurityUpdatesInput + +func (RepositoryDependabotSecurityUpdatesArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryDependabotSecurityUpdates)(nil)).Elem() +} + +func (i RepositoryDependabotSecurityUpdatesArray) ToRepositoryDependabotSecurityUpdatesArrayOutput() RepositoryDependabotSecurityUpdatesArrayOutput { + return i.ToRepositoryDependabotSecurityUpdatesArrayOutputWithContext(context.Background()) +} + +func (i RepositoryDependabotSecurityUpdatesArray) ToRepositoryDependabotSecurityUpdatesArrayOutputWithContext(ctx context.Context) RepositoryDependabotSecurityUpdatesArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryDependabotSecurityUpdatesArrayOutput) +} + +// RepositoryDependabotSecurityUpdatesMapInput is an input type that accepts RepositoryDependabotSecurityUpdatesMap and RepositoryDependabotSecurityUpdatesMapOutput values. +// You can construct a concrete instance of `RepositoryDependabotSecurityUpdatesMapInput` via: +// +// RepositoryDependabotSecurityUpdatesMap{ "key": RepositoryDependabotSecurityUpdatesArgs{...} } +type RepositoryDependabotSecurityUpdatesMapInput interface { + pulumi.Input + + ToRepositoryDependabotSecurityUpdatesMapOutput() RepositoryDependabotSecurityUpdatesMapOutput + ToRepositoryDependabotSecurityUpdatesMapOutputWithContext(context.Context) RepositoryDependabotSecurityUpdatesMapOutput +} + +type RepositoryDependabotSecurityUpdatesMap map[string]RepositoryDependabotSecurityUpdatesInput + +func (RepositoryDependabotSecurityUpdatesMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryDependabotSecurityUpdates)(nil)).Elem() +} + +func (i RepositoryDependabotSecurityUpdatesMap) ToRepositoryDependabotSecurityUpdatesMapOutput() RepositoryDependabotSecurityUpdatesMapOutput { + return i.ToRepositoryDependabotSecurityUpdatesMapOutputWithContext(context.Background()) +} + +func (i RepositoryDependabotSecurityUpdatesMap) ToRepositoryDependabotSecurityUpdatesMapOutputWithContext(ctx context.Context) RepositoryDependabotSecurityUpdatesMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryDependabotSecurityUpdatesMapOutput) +} + +type RepositoryDependabotSecurityUpdatesOutput struct{ *pulumi.OutputState } + +func (RepositoryDependabotSecurityUpdatesOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryDependabotSecurityUpdates)(nil)).Elem() +} + +func (o RepositoryDependabotSecurityUpdatesOutput) ToRepositoryDependabotSecurityUpdatesOutput() RepositoryDependabotSecurityUpdatesOutput { + return o +} + +func (o RepositoryDependabotSecurityUpdatesOutput) ToRepositoryDependabotSecurityUpdatesOutputWithContext(ctx context.Context) RepositoryDependabotSecurityUpdatesOutput { + return o +} + +// The state of the automated security fixes. +func (o RepositoryDependabotSecurityUpdatesOutput) Enabled() pulumi.BoolOutput { + return o.ApplyT(func(v *RepositoryDependabotSecurityUpdates) pulumi.BoolOutput { return v.Enabled }).(pulumi.BoolOutput) +} + +// The name of the GitHub repository. +func (o RepositoryDependabotSecurityUpdatesOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryDependabotSecurityUpdates) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +type RepositoryDependabotSecurityUpdatesArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryDependabotSecurityUpdatesArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryDependabotSecurityUpdates)(nil)).Elem() +} + +func (o RepositoryDependabotSecurityUpdatesArrayOutput) ToRepositoryDependabotSecurityUpdatesArrayOutput() RepositoryDependabotSecurityUpdatesArrayOutput { + return o +} + +func (o RepositoryDependabotSecurityUpdatesArrayOutput) ToRepositoryDependabotSecurityUpdatesArrayOutputWithContext(ctx context.Context) RepositoryDependabotSecurityUpdatesArrayOutput { + return o +} + +func (o RepositoryDependabotSecurityUpdatesArrayOutput) Index(i pulumi.IntInput) RepositoryDependabotSecurityUpdatesOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryDependabotSecurityUpdates { + return vs[0].([]*RepositoryDependabotSecurityUpdates)[vs[1].(int)] + }).(RepositoryDependabotSecurityUpdatesOutput) +} + +type RepositoryDependabotSecurityUpdatesMapOutput struct{ *pulumi.OutputState } + +func (RepositoryDependabotSecurityUpdatesMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryDependabotSecurityUpdates)(nil)).Elem() +} + +func (o RepositoryDependabotSecurityUpdatesMapOutput) ToRepositoryDependabotSecurityUpdatesMapOutput() RepositoryDependabotSecurityUpdatesMapOutput { + return o +} + +func (o RepositoryDependabotSecurityUpdatesMapOutput) ToRepositoryDependabotSecurityUpdatesMapOutputWithContext(ctx context.Context) RepositoryDependabotSecurityUpdatesMapOutput { + return o +} + +func (o RepositoryDependabotSecurityUpdatesMapOutput) MapIndex(k pulumi.StringInput) RepositoryDependabotSecurityUpdatesOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryDependabotSecurityUpdates { + return vs[0].(map[string]*RepositoryDependabotSecurityUpdates)[vs[1].(string)] + }).(RepositoryDependabotSecurityUpdatesOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryDependabotSecurityUpdatesInput)(nil)).Elem(), &RepositoryDependabotSecurityUpdates{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryDependabotSecurityUpdatesArrayInput)(nil)).Elem(), RepositoryDependabotSecurityUpdatesArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryDependabotSecurityUpdatesMapInput)(nil)).Elem(), RepositoryDependabotSecurityUpdatesMap{}) + pulumi.RegisterOutputType(RepositoryDependabotSecurityUpdatesOutput{}) + pulumi.RegisterOutputType(RepositoryDependabotSecurityUpdatesArrayOutput{}) + pulumi.RegisterOutputType(RepositoryDependabotSecurityUpdatesMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryDeployKey.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryDeployKey.go new file mode 100644 index 000000000..d7cf7eb33 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryDeployKey.go @@ -0,0 +1,347 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Provides a GitHub repository deploy key resource. +// +// A deploy key is an SSH key that is stored on your server and grants +// access to a single GitHub repository. This key is attached directly to the repository instead of to a personal user +// account. +// +// This resource allows you to add/remove repository deploy keys. +// +// > **Note on Archived Repositories**: When a repository is archived, GitHub makes it read-only, preventing deploy key modifications. If you attempt to destroy resources associated with archived repositories, the provider will gracefully handle the operation by logging an informational message and removing the resource from Terraform state without attempting to modify the archived repository. +// +// Further documentation on GitHub repository deploy keys: +// - [About deploy keys](https://developer.github.com/guides/managing-deploy-keys/#deploy-keys) +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi-github/sdk/v6/go/github" +// "github.com/pulumi/pulumi-tls/sdk/v5/go/tls" +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// // Generate an ssh key using provider "hashicorp/tls" +// exampleRepositoryDeployKey, err := tls.NewPrivateKey(ctx, "example_repository_deploy_key", &tls.PrivateKeyArgs{ +// Algorithm: pulumi.String("ED25519"), +// }) +// if err != nil { +// return err +// } +// // Add the ssh key as a deploy key +// _, err = github.NewRepositoryDeployKey(ctx, "example_repository_deploy_key", &github.RepositoryDeployKeyArgs{ +// Title: pulumi.String("Repository test key"), +// Repository: pulumi.String("test-repo"), +// Key: exampleRepositoryDeployKey.PublicKeyOpenssh, +// ReadOnly: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// Repository deploy keys can be imported using a colon-separated pair of repository name +// and GitHub's key id. The latter can be obtained by GitHub's SDKs and API. +// +// ```sh +// $ pulumi import github:index/repositoryDeployKey:RepositoryDeployKey foo test-repo:23824728 +// ``` +type RepositoryDeployKey struct { + pulumi.CustomResourceState + + Etag pulumi.StringOutput `pulumi:"etag"` + // A SSH key. + Key pulumi.StringOutput `pulumi:"key"` + // A boolean qualifying the key to be either read only or read/write. + ReadOnly pulumi.BoolPtrOutput `pulumi:"readOnly"` + // Name of the GitHub repository. + Repository pulumi.StringOutput `pulumi:"repository"` + // A title. + // + // Changing any of the fields forces re-creating the resource. + Title pulumi.StringOutput `pulumi:"title"` +} + +// NewRepositoryDeployKey registers a new resource with the given unique name, arguments, and options. +func NewRepositoryDeployKey(ctx *pulumi.Context, + name string, args *RepositoryDeployKeyArgs, opts ...pulumi.ResourceOption) (*RepositoryDeployKey, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Key == nil { + return nil, errors.New("invalid value for required argument 'Key'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + if args.Title == nil { + return nil, errors.New("invalid value for required argument 'Title'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryDeployKey + err := ctx.RegisterResource("github:index/repositoryDeployKey:RepositoryDeployKey", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryDeployKey gets an existing RepositoryDeployKey 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 GetRepositoryDeployKey(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryDeployKeyState, opts ...pulumi.ResourceOption) (*RepositoryDeployKey, error) { + var resource RepositoryDeployKey + err := ctx.ReadResource("github:index/repositoryDeployKey:RepositoryDeployKey", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryDeployKey resources. +type repositoryDeployKeyState struct { + Etag *string `pulumi:"etag"` + // A SSH key. + Key *string `pulumi:"key"` + // A boolean qualifying the key to be either read only or read/write. + ReadOnly *bool `pulumi:"readOnly"` + // Name of the GitHub repository. + Repository *string `pulumi:"repository"` + // A title. + // + // Changing any of the fields forces re-creating the resource. + Title *string `pulumi:"title"` +} + +type RepositoryDeployKeyState struct { + Etag pulumi.StringPtrInput + // A SSH key. + Key pulumi.StringPtrInput + // A boolean qualifying the key to be either read only or read/write. + ReadOnly pulumi.BoolPtrInput + // Name of the GitHub repository. + Repository pulumi.StringPtrInput + // A title. + // + // Changing any of the fields forces re-creating the resource. + Title pulumi.StringPtrInput +} + +func (RepositoryDeployKeyState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryDeployKeyState)(nil)).Elem() +} + +type repositoryDeployKeyArgs struct { + // A SSH key. + Key string `pulumi:"key"` + // A boolean qualifying the key to be either read only or read/write. + ReadOnly *bool `pulumi:"readOnly"` + // Name of the GitHub repository. + Repository string `pulumi:"repository"` + // A title. + // + // Changing any of the fields forces re-creating the resource. + Title string `pulumi:"title"` +} + +// The set of arguments for constructing a RepositoryDeployKey resource. +type RepositoryDeployKeyArgs struct { + // A SSH key. + Key pulumi.StringInput + // A boolean qualifying the key to be either read only or read/write. + ReadOnly pulumi.BoolPtrInput + // Name of the GitHub repository. + Repository pulumi.StringInput + // A title. + // + // Changing any of the fields forces re-creating the resource. + Title pulumi.StringInput +} + +func (RepositoryDeployKeyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryDeployKeyArgs)(nil)).Elem() +} + +type RepositoryDeployKeyInput interface { + pulumi.Input + + ToRepositoryDeployKeyOutput() RepositoryDeployKeyOutput + ToRepositoryDeployKeyOutputWithContext(ctx context.Context) RepositoryDeployKeyOutput +} + +func (*RepositoryDeployKey) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryDeployKey)(nil)).Elem() +} + +func (i *RepositoryDeployKey) ToRepositoryDeployKeyOutput() RepositoryDeployKeyOutput { + return i.ToRepositoryDeployKeyOutputWithContext(context.Background()) +} + +func (i *RepositoryDeployKey) ToRepositoryDeployKeyOutputWithContext(ctx context.Context) RepositoryDeployKeyOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryDeployKeyOutput) +} + +// RepositoryDeployKeyArrayInput is an input type that accepts RepositoryDeployKeyArray and RepositoryDeployKeyArrayOutput values. +// You can construct a concrete instance of `RepositoryDeployKeyArrayInput` via: +// +// RepositoryDeployKeyArray{ RepositoryDeployKeyArgs{...} } +type RepositoryDeployKeyArrayInput interface { + pulumi.Input + + ToRepositoryDeployKeyArrayOutput() RepositoryDeployKeyArrayOutput + ToRepositoryDeployKeyArrayOutputWithContext(context.Context) RepositoryDeployKeyArrayOutput +} + +type RepositoryDeployKeyArray []RepositoryDeployKeyInput + +func (RepositoryDeployKeyArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryDeployKey)(nil)).Elem() +} + +func (i RepositoryDeployKeyArray) ToRepositoryDeployKeyArrayOutput() RepositoryDeployKeyArrayOutput { + return i.ToRepositoryDeployKeyArrayOutputWithContext(context.Background()) +} + +func (i RepositoryDeployKeyArray) ToRepositoryDeployKeyArrayOutputWithContext(ctx context.Context) RepositoryDeployKeyArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryDeployKeyArrayOutput) +} + +// RepositoryDeployKeyMapInput is an input type that accepts RepositoryDeployKeyMap and RepositoryDeployKeyMapOutput values. +// You can construct a concrete instance of `RepositoryDeployKeyMapInput` via: +// +// RepositoryDeployKeyMap{ "key": RepositoryDeployKeyArgs{...} } +type RepositoryDeployKeyMapInput interface { + pulumi.Input + + ToRepositoryDeployKeyMapOutput() RepositoryDeployKeyMapOutput + ToRepositoryDeployKeyMapOutputWithContext(context.Context) RepositoryDeployKeyMapOutput +} + +type RepositoryDeployKeyMap map[string]RepositoryDeployKeyInput + +func (RepositoryDeployKeyMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryDeployKey)(nil)).Elem() +} + +func (i RepositoryDeployKeyMap) ToRepositoryDeployKeyMapOutput() RepositoryDeployKeyMapOutput { + return i.ToRepositoryDeployKeyMapOutputWithContext(context.Background()) +} + +func (i RepositoryDeployKeyMap) ToRepositoryDeployKeyMapOutputWithContext(ctx context.Context) RepositoryDeployKeyMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryDeployKeyMapOutput) +} + +type RepositoryDeployKeyOutput struct{ *pulumi.OutputState } + +func (RepositoryDeployKeyOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryDeployKey)(nil)).Elem() +} + +func (o RepositoryDeployKeyOutput) ToRepositoryDeployKeyOutput() RepositoryDeployKeyOutput { + return o +} + +func (o RepositoryDeployKeyOutput) ToRepositoryDeployKeyOutputWithContext(ctx context.Context) RepositoryDeployKeyOutput { + return o +} + +func (o RepositoryDeployKeyOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryDeployKey) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// A SSH key. +func (o RepositoryDeployKeyOutput) Key() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryDeployKey) pulumi.StringOutput { return v.Key }).(pulumi.StringOutput) +} + +// A boolean qualifying the key to be either read only or read/write. +func (o RepositoryDeployKeyOutput) ReadOnly() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryDeployKey) pulumi.BoolPtrOutput { return v.ReadOnly }).(pulumi.BoolPtrOutput) +} + +// Name of the GitHub repository. +func (o RepositoryDeployKeyOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryDeployKey) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// A title. +// +// Changing any of the fields forces re-creating the resource. +func (o RepositoryDeployKeyOutput) Title() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryDeployKey) pulumi.StringOutput { return v.Title }).(pulumi.StringOutput) +} + +type RepositoryDeployKeyArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryDeployKeyArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryDeployKey)(nil)).Elem() +} + +func (o RepositoryDeployKeyArrayOutput) ToRepositoryDeployKeyArrayOutput() RepositoryDeployKeyArrayOutput { + return o +} + +func (o RepositoryDeployKeyArrayOutput) ToRepositoryDeployKeyArrayOutputWithContext(ctx context.Context) RepositoryDeployKeyArrayOutput { + return o +} + +func (o RepositoryDeployKeyArrayOutput) Index(i pulumi.IntInput) RepositoryDeployKeyOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryDeployKey { + return vs[0].([]*RepositoryDeployKey)[vs[1].(int)] + }).(RepositoryDeployKeyOutput) +} + +type RepositoryDeployKeyMapOutput struct{ *pulumi.OutputState } + +func (RepositoryDeployKeyMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryDeployKey)(nil)).Elem() +} + +func (o RepositoryDeployKeyMapOutput) ToRepositoryDeployKeyMapOutput() RepositoryDeployKeyMapOutput { + return o +} + +func (o RepositoryDeployKeyMapOutput) ToRepositoryDeployKeyMapOutputWithContext(ctx context.Context) RepositoryDeployKeyMapOutput { + return o +} + +func (o RepositoryDeployKeyMapOutput) MapIndex(k pulumi.StringInput) RepositoryDeployKeyOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryDeployKey { + return vs[0].(map[string]*RepositoryDeployKey)[vs[1].(string)] + }).(RepositoryDeployKeyOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryDeployKeyInput)(nil)).Elem(), &RepositoryDeployKey{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryDeployKeyArrayInput)(nil)).Elem(), RepositoryDeployKeyArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryDeployKeyMapInput)(nil)).Elem(), RepositoryDeployKeyMap{}) + pulumi.RegisterOutputType(RepositoryDeployKeyOutput{}) + pulumi.RegisterOutputType(RepositoryDeployKeyArrayOutput{}) + pulumi.RegisterOutputType(RepositoryDeployKeyMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryDeploymentBranchPolicy.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryDeploymentBranchPolicy.go new file mode 100644 index 000000000..ac97dc630 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryDeploymentBranchPolicy.go @@ -0,0 +1,312 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// > **Note:** This resource is deprecated, please use the `RepositoryEnvironmentDeploymentPolicy` resource instead. +// +// This resource allows you to create and manage deployment branch policies. +// +// ## Example Usage +// +// ```go +// 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 { +// env, err := github.NewRepositoryEnvironment(ctx, "env", &github.RepositoryEnvironmentArgs{ +// Repository: pulumi.String("my_repo"), +// Environment: pulumi.String("my_env"), +// DeploymentBranchPolicy: &github.RepositoryEnvironmentDeploymentBranchPolicyArgs{ +// ProtectedBranches: pulumi.Bool(false), +// CustomBranchPolicies: pulumi.Bool(true), +// }, +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryDeploymentBranchPolicy(ctx, "foo", &github.RepositoryDeploymentBranchPolicyArgs{ +// Repository: pulumi.String("my_repo"), +// EnvironmentName: pulumi.String("my_env"), +// Name: pulumi.String("foo"), +// }, pulumi.DependsOn([]pulumi.Resource{ +// env, +// })) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +type RepositoryDeploymentBranchPolicy struct { + pulumi.CustomResourceState + + // The name of the environment. This environment must have `deployment_branch_policy.custom_branch_policies` set to true or a 404 error will be thrown. + EnvironmentName pulumi.StringOutput `pulumi:"environmentName"` + // An etag representing the Branch object. + Etag pulumi.StringOutput `pulumi:"etag"` + // The name pattern that branches must match in order to deploy to the environment. + Name pulumi.StringOutput `pulumi:"name"` + // The repository to create the policy in. + Repository pulumi.StringOutput `pulumi:"repository"` +} + +// NewRepositoryDeploymentBranchPolicy registers a new resource with the given unique name, arguments, and options. +func NewRepositoryDeploymentBranchPolicy(ctx *pulumi.Context, + name string, args *RepositoryDeploymentBranchPolicyArgs, opts ...pulumi.ResourceOption) (*RepositoryDeploymentBranchPolicy, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.EnvironmentName == nil { + return nil, errors.New("invalid value for required argument 'EnvironmentName'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryDeploymentBranchPolicy + err := ctx.RegisterResource("github:index/repositoryDeploymentBranchPolicy:RepositoryDeploymentBranchPolicy", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryDeploymentBranchPolicy gets an existing RepositoryDeploymentBranchPolicy 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 GetRepositoryDeploymentBranchPolicy(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryDeploymentBranchPolicyState, opts ...pulumi.ResourceOption) (*RepositoryDeploymentBranchPolicy, error) { + var resource RepositoryDeploymentBranchPolicy + err := ctx.ReadResource("github:index/repositoryDeploymentBranchPolicy:RepositoryDeploymentBranchPolicy", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryDeploymentBranchPolicy resources. +type repositoryDeploymentBranchPolicyState struct { + // The name of the environment. This environment must have `deployment_branch_policy.custom_branch_policies` set to true or a 404 error will be thrown. + EnvironmentName *string `pulumi:"environmentName"` + // An etag representing the Branch object. + Etag *string `pulumi:"etag"` + // The name pattern that branches must match in order to deploy to the environment. + Name *string `pulumi:"name"` + // The repository to create the policy in. + Repository *string `pulumi:"repository"` +} + +type RepositoryDeploymentBranchPolicyState struct { + // The name of the environment. This environment must have `deployment_branch_policy.custom_branch_policies` set to true or a 404 error will be thrown. + EnvironmentName pulumi.StringPtrInput + // An etag representing the Branch object. + Etag pulumi.StringPtrInput + // The name pattern that branches must match in order to deploy to the environment. + Name pulumi.StringPtrInput + // The repository to create the policy in. + Repository pulumi.StringPtrInput +} + +func (RepositoryDeploymentBranchPolicyState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryDeploymentBranchPolicyState)(nil)).Elem() +} + +type repositoryDeploymentBranchPolicyArgs struct { + // The name of the environment. This environment must have `deployment_branch_policy.custom_branch_policies` set to true or a 404 error will be thrown. + EnvironmentName string `pulumi:"environmentName"` + // An etag representing the Branch object. + Etag *string `pulumi:"etag"` + // The name pattern that branches must match in order to deploy to the environment. + Name *string `pulumi:"name"` + // The repository to create the policy in. + Repository string `pulumi:"repository"` +} + +// The set of arguments for constructing a RepositoryDeploymentBranchPolicy resource. +type RepositoryDeploymentBranchPolicyArgs struct { + // The name of the environment. This environment must have `deployment_branch_policy.custom_branch_policies` set to true or a 404 error will be thrown. + EnvironmentName pulumi.StringInput + // An etag representing the Branch object. + Etag pulumi.StringPtrInput + // The name pattern that branches must match in order to deploy to the environment. + Name pulumi.StringPtrInput + // The repository to create the policy in. + Repository pulumi.StringInput +} + +func (RepositoryDeploymentBranchPolicyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryDeploymentBranchPolicyArgs)(nil)).Elem() +} + +type RepositoryDeploymentBranchPolicyInput interface { + pulumi.Input + + ToRepositoryDeploymentBranchPolicyOutput() RepositoryDeploymentBranchPolicyOutput + ToRepositoryDeploymentBranchPolicyOutputWithContext(ctx context.Context) RepositoryDeploymentBranchPolicyOutput +} + +func (*RepositoryDeploymentBranchPolicy) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryDeploymentBranchPolicy)(nil)).Elem() +} + +func (i *RepositoryDeploymentBranchPolicy) ToRepositoryDeploymentBranchPolicyOutput() RepositoryDeploymentBranchPolicyOutput { + return i.ToRepositoryDeploymentBranchPolicyOutputWithContext(context.Background()) +} + +func (i *RepositoryDeploymentBranchPolicy) ToRepositoryDeploymentBranchPolicyOutputWithContext(ctx context.Context) RepositoryDeploymentBranchPolicyOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryDeploymentBranchPolicyOutput) +} + +// RepositoryDeploymentBranchPolicyArrayInput is an input type that accepts RepositoryDeploymentBranchPolicyArray and RepositoryDeploymentBranchPolicyArrayOutput values. +// You can construct a concrete instance of `RepositoryDeploymentBranchPolicyArrayInput` via: +// +// RepositoryDeploymentBranchPolicyArray{ RepositoryDeploymentBranchPolicyArgs{...} } +type RepositoryDeploymentBranchPolicyArrayInput interface { + pulumi.Input + + ToRepositoryDeploymentBranchPolicyArrayOutput() RepositoryDeploymentBranchPolicyArrayOutput + ToRepositoryDeploymentBranchPolicyArrayOutputWithContext(context.Context) RepositoryDeploymentBranchPolicyArrayOutput +} + +type RepositoryDeploymentBranchPolicyArray []RepositoryDeploymentBranchPolicyInput + +func (RepositoryDeploymentBranchPolicyArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryDeploymentBranchPolicy)(nil)).Elem() +} + +func (i RepositoryDeploymentBranchPolicyArray) ToRepositoryDeploymentBranchPolicyArrayOutput() RepositoryDeploymentBranchPolicyArrayOutput { + return i.ToRepositoryDeploymentBranchPolicyArrayOutputWithContext(context.Background()) +} + +func (i RepositoryDeploymentBranchPolicyArray) ToRepositoryDeploymentBranchPolicyArrayOutputWithContext(ctx context.Context) RepositoryDeploymentBranchPolicyArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryDeploymentBranchPolicyArrayOutput) +} + +// RepositoryDeploymentBranchPolicyMapInput is an input type that accepts RepositoryDeploymentBranchPolicyMap and RepositoryDeploymentBranchPolicyMapOutput values. +// You can construct a concrete instance of `RepositoryDeploymentBranchPolicyMapInput` via: +// +// RepositoryDeploymentBranchPolicyMap{ "key": RepositoryDeploymentBranchPolicyArgs{...} } +type RepositoryDeploymentBranchPolicyMapInput interface { + pulumi.Input + + ToRepositoryDeploymentBranchPolicyMapOutput() RepositoryDeploymentBranchPolicyMapOutput + ToRepositoryDeploymentBranchPolicyMapOutputWithContext(context.Context) RepositoryDeploymentBranchPolicyMapOutput +} + +type RepositoryDeploymentBranchPolicyMap map[string]RepositoryDeploymentBranchPolicyInput + +func (RepositoryDeploymentBranchPolicyMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryDeploymentBranchPolicy)(nil)).Elem() +} + +func (i RepositoryDeploymentBranchPolicyMap) ToRepositoryDeploymentBranchPolicyMapOutput() RepositoryDeploymentBranchPolicyMapOutput { + return i.ToRepositoryDeploymentBranchPolicyMapOutputWithContext(context.Background()) +} + +func (i RepositoryDeploymentBranchPolicyMap) ToRepositoryDeploymentBranchPolicyMapOutputWithContext(ctx context.Context) RepositoryDeploymentBranchPolicyMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryDeploymentBranchPolicyMapOutput) +} + +type RepositoryDeploymentBranchPolicyOutput struct{ *pulumi.OutputState } + +func (RepositoryDeploymentBranchPolicyOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryDeploymentBranchPolicy)(nil)).Elem() +} + +func (o RepositoryDeploymentBranchPolicyOutput) ToRepositoryDeploymentBranchPolicyOutput() RepositoryDeploymentBranchPolicyOutput { + return o +} + +func (o RepositoryDeploymentBranchPolicyOutput) ToRepositoryDeploymentBranchPolicyOutputWithContext(ctx context.Context) RepositoryDeploymentBranchPolicyOutput { + return o +} + +// The name of the environment. This environment must have `deployment_branch_policy.custom_branch_policies` set to true or a 404 error will be thrown. +func (o RepositoryDeploymentBranchPolicyOutput) EnvironmentName() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryDeploymentBranchPolicy) pulumi.StringOutput { return v.EnvironmentName }).(pulumi.StringOutput) +} + +// An etag representing the Branch object. +func (o RepositoryDeploymentBranchPolicyOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryDeploymentBranchPolicy) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// The name pattern that branches must match in order to deploy to the environment. +func (o RepositoryDeploymentBranchPolicyOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryDeploymentBranchPolicy) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// The repository to create the policy in. +func (o RepositoryDeploymentBranchPolicyOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryDeploymentBranchPolicy) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +type RepositoryDeploymentBranchPolicyArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryDeploymentBranchPolicyArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryDeploymentBranchPolicy)(nil)).Elem() +} + +func (o RepositoryDeploymentBranchPolicyArrayOutput) ToRepositoryDeploymentBranchPolicyArrayOutput() RepositoryDeploymentBranchPolicyArrayOutput { + return o +} + +func (o RepositoryDeploymentBranchPolicyArrayOutput) ToRepositoryDeploymentBranchPolicyArrayOutputWithContext(ctx context.Context) RepositoryDeploymentBranchPolicyArrayOutput { + return o +} + +func (o RepositoryDeploymentBranchPolicyArrayOutput) Index(i pulumi.IntInput) RepositoryDeploymentBranchPolicyOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryDeploymentBranchPolicy { + return vs[0].([]*RepositoryDeploymentBranchPolicy)[vs[1].(int)] + }).(RepositoryDeploymentBranchPolicyOutput) +} + +type RepositoryDeploymentBranchPolicyMapOutput struct{ *pulumi.OutputState } + +func (RepositoryDeploymentBranchPolicyMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryDeploymentBranchPolicy)(nil)).Elem() +} + +func (o RepositoryDeploymentBranchPolicyMapOutput) ToRepositoryDeploymentBranchPolicyMapOutput() RepositoryDeploymentBranchPolicyMapOutput { + return o +} + +func (o RepositoryDeploymentBranchPolicyMapOutput) ToRepositoryDeploymentBranchPolicyMapOutputWithContext(ctx context.Context) RepositoryDeploymentBranchPolicyMapOutput { + return o +} + +func (o RepositoryDeploymentBranchPolicyMapOutput) MapIndex(k pulumi.StringInput) RepositoryDeploymentBranchPolicyOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryDeploymentBranchPolicy { + return vs[0].(map[string]*RepositoryDeploymentBranchPolicy)[vs[1].(string)] + }).(RepositoryDeploymentBranchPolicyOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryDeploymentBranchPolicyInput)(nil)).Elem(), &RepositoryDeploymentBranchPolicy{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryDeploymentBranchPolicyArrayInput)(nil)).Elem(), RepositoryDeploymentBranchPolicyArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryDeploymentBranchPolicyMapInput)(nil)).Elem(), RepositoryDeploymentBranchPolicyMap{}) + pulumi.RegisterOutputType(RepositoryDeploymentBranchPolicyOutput{}) + pulumi.RegisterOutputType(RepositoryDeploymentBranchPolicyArrayOutput{}) + pulumi.RegisterOutputType(RepositoryDeploymentBranchPolicyMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryEnvironment.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryEnvironment.go new file mode 100644 index 000000000..421a03ec9 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryEnvironment.go @@ -0,0 +1,389 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage environments for a GitHub repository. +// +// ## Example Usage +// +// ```go +// 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 { +// current, err := github.GetUser(ctx, &github.GetUserArgs{ +// Username: "", +// }, nil) +// if err != nil { +// return err +// } +// example, err := github.NewRepository(ctx, "example", &github.RepositoryArgs{ +// Name: pulumi.String("A Repository Project"), +// Description: pulumi.String("My awesome codebase"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryEnvironment(ctx, "example", &github.RepositoryEnvironmentArgs{ +// Environment: pulumi.String("example"), +// Repository: example.Name, +// PreventSelfReview: pulumi.Bool(true), +// Reviewers: github.RepositoryEnvironmentReviewerArray{ +// &github.RepositoryEnvironmentReviewerArgs{ +// Users: pulumi.IntArray{ +// pulumi.Int(pulumi.String(current.Id)), +// }, +// }, +// }, +// DeploymentBranchPolicy: &github.RepositoryEnvironmentDeploymentBranchPolicyArgs{ +// ProtectedBranches: pulumi.Bool(true), +// CustomBranchPolicies: pulumi.Bool(false), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using an ID made of the repository name and environment name (any `:` in the environment name need to be escaped as `??`) separated by a `:`. +// +// ### Import Command +// +// The following command imports an environment called `myenv` for the repo `myrepo` to a `RepositoryEnvironment` resource named `example`. +// +// ```sh +// $ pulumi import github:index/repositoryEnvironment:RepositoryEnvironment example myrepo:myenv +// ``` +type RepositoryEnvironment struct { + pulumi.CustomResourceState + + // Can repository admins bypass the environment protections. Defaults to `true`. + CanAdminsBypass pulumi.BoolPtrOutput `pulumi:"canAdminsBypass"` + // The deployment branch policy configuration + DeploymentBranchPolicy RepositoryEnvironmentDeploymentBranchPolicyPtrOutput `pulumi:"deploymentBranchPolicy"` + // The name of the environment. + Environment pulumi.StringOutput `pulumi:"environment"` + // Whether or not a user who created the job is prevented from approving their own job. Defaults to `false`. + PreventSelfReview pulumi.BoolPtrOutput `pulumi:"preventSelfReview"` + // The repository of the environment. + Repository pulumi.StringOutput `pulumi:"repository"` + // The ID of the repository. + RepositoryId pulumi.IntOutput `pulumi:"repositoryId"` + // The environment reviewers configuration. + Reviewers RepositoryEnvironmentReviewerArrayOutput `pulumi:"reviewers"` + // Amount of time to delay a job after the job is initially triggered. + WaitTimer pulumi.IntPtrOutput `pulumi:"waitTimer"` +} + +// NewRepositoryEnvironment registers a new resource with the given unique name, arguments, and options. +func NewRepositoryEnvironment(ctx *pulumi.Context, + name string, args *RepositoryEnvironmentArgs, opts ...pulumi.ResourceOption) (*RepositoryEnvironment, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Environment == nil { + return nil, errors.New("invalid value for required argument 'Environment'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryEnvironment + err := ctx.RegisterResource("github:index/repositoryEnvironment:RepositoryEnvironment", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryEnvironment gets an existing RepositoryEnvironment 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 GetRepositoryEnvironment(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryEnvironmentState, opts ...pulumi.ResourceOption) (*RepositoryEnvironment, error) { + var resource RepositoryEnvironment + err := ctx.ReadResource("github:index/repositoryEnvironment:RepositoryEnvironment", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryEnvironment resources. +type repositoryEnvironmentState struct { + // Can repository admins bypass the environment protections. Defaults to `true`. + CanAdminsBypass *bool `pulumi:"canAdminsBypass"` + // The deployment branch policy configuration + DeploymentBranchPolicy *RepositoryEnvironmentDeploymentBranchPolicy `pulumi:"deploymentBranchPolicy"` + // The name of the environment. + Environment *string `pulumi:"environment"` + // Whether or not a user who created the job is prevented from approving their own job. Defaults to `false`. + PreventSelfReview *bool `pulumi:"preventSelfReview"` + // The repository of the environment. + Repository *string `pulumi:"repository"` + // The ID of the repository. + RepositoryId *int `pulumi:"repositoryId"` + // The environment reviewers configuration. + Reviewers []RepositoryEnvironmentReviewer `pulumi:"reviewers"` + // Amount of time to delay a job after the job is initially triggered. + WaitTimer *int `pulumi:"waitTimer"` +} + +type RepositoryEnvironmentState struct { + // Can repository admins bypass the environment protections. Defaults to `true`. + CanAdminsBypass pulumi.BoolPtrInput + // The deployment branch policy configuration + DeploymentBranchPolicy RepositoryEnvironmentDeploymentBranchPolicyPtrInput + // The name of the environment. + Environment pulumi.StringPtrInput + // Whether or not a user who created the job is prevented from approving their own job. Defaults to `false`. + PreventSelfReview pulumi.BoolPtrInput + // The repository of the environment. + Repository pulumi.StringPtrInput + // The ID of the repository. + RepositoryId pulumi.IntPtrInput + // The environment reviewers configuration. + Reviewers RepositoryEnvironmentReviewerArrayInput + // Amount of time to delay a job after the job is initially triggered. + WaitTimer pulumi.IntPtrInput +} + +func (RepositoryEnvironmentState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryEnvironmentState)(nil)).Elem() +} + +type repositoryEnvironmentArgs struct { + // Can repository admins bypass the environment protections. Defaults to `true`. + CanAdminsBypass *bool `pulumi:"canAdminsBypass"` + // The deployment branch policy configuration + DeploymentBranchPolicy *RepositoryEnvironmentDeploymentBranchPolicy `pulumi:"deploymentBranchPolicy"` + // The name of the environment. + Environment string `pulumi:"environment"` + // Whether or not a user who created the job is prevented from approving their own job. Defaults to `false`. + PreventSelfReview *bool `pulumi:"preventSelfReview"` + // The repository of the environment. + Repository string `pulumi:"repository"` + // The environment reviewers configuration. + Reviewers []RepositoryEnvironmentReviewer `pulumi:"reviewers"` + // Amount of time to delay a job after the job is initially triggered. + WaitTimer *int `pulumi:"waitTimer"` +} + +// The set of arguments for constructing a RepositoryEnvironment resource. +type RepositoryEnvironmentArgs struct { + // Can repository admins bypass the environment protections. Defaults to `true`. + CanAdminsBypass pulumi.BoolPtrInput + // The deployment branch policy configuration + DeploymentBranchPolicy RepositoryEnvironmentDeploymentBranchPolicyPtrInput + // The name of the environment. + Environment pulumi.StringInput + // Whether or not a user who created the job is prevented from approving their own job. Defaults to `false`. + PreventSelfReview pulumi.BoolPtrInput + // The repository of the environment. + Repository pulumi.StringInput + // The environment reviewers configuration. + Reviewers RepositoryEnvironmentReviewerArrayInput + // Amount of time to delay a job after the job is initially triggered. + WaitTimer pulumi.IntPtrInput +} + +func (RepositoryEnvironmentArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryEnvironmentArgs)(nil)).Elem() +} + +type RepositoryEnvironmentInput interface { + pulumi.Input + + ToRepositoryEnvironmentOutput() RepositoryEnvironmentOutput + ToRepositoryEnvironmentOutputWithContext(ctx context.Context) RepositoryEnvironmentOutput +} + +func (*RepositoryEnvironment) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryEnvironment)(nil)).Elem() +} + +func (i *RepositoryEnvironment) ToRepositoryEnvironmentOutput() RepositoryEnvironmentOutput { + return i.ToRepositoryEnvironmentOutputWithContext(context.Background()) +} + +func (i *RepositoryEnvironment) ToRepositoryEnvironmentOutputWithContext(ctx context.Context) RepositoryEnvironmentOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryEnvironmentOutput) +} + +// RepositoryEnvironmentArrayInput is an input type that accepts RepositoryEnvironmentArray and RepositoryEnvironmentArrayOutput values. +// You can construct a concrete instance of `RepositoryEnvironmentArrayInput` via: +// +// RepositoryEnvironmentArray{ RepositoryEnvironmentArgs{...} } +type RepositoryEnvironmentArrayInput interface { + pulumi.Input + + ToRepositoryEnvironmentArrayOutput() RepositoryEnvironmentArrayOutput + ToRepositoryEnvironmentArrayOutputWithContext(context.Context) RepositoryEnvironmentArrayOutput +} + +type RepositoryEnvironmentArray []RepositoryEnvironmentInput + +func (RepositoryEnvironmentArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryEnvironment)(nil)).Elem() +} + +func (i RepositoryEnvironmentArray) ToRepositoryEnvironmentArrayOutput() RepositoryEnvironmentArrayOutput { + return i.ToRepositoryEnvironmentArrayOutputWithContext(context.Background()) +} + +func (i RepositoryEnvironmentArray) ToRepositoryEnvironmentArrayOutputWithContext(ctx context.Context) RepositoryEnvironmentArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryEnvironmentArrayOutput) +} + +// RepositoryEnvironmentMapInput is an input type that accepts RepositoryEnvironmentMap and RepositoryEnvironmentMapOutput values. +// You can construct a concrete instance of `RepositoryEnvironmentMapInput` via: +// +// RepositoryEnvironmentMap{ "key": RepositoryEnvironmentArgs{...} } +type RepositoryEnvironmentMapInput interface { + pulumi.Input + + ToRepositoryEnvironmentMapOutput() RepositoryEnvironmentMapOutput + ToRepositoryEnvironmentMapOutputWithContext(context.Context) RepositoryEnvironmentMapOutput +} + +type RepositoryEnvironmentMap map[string]RepositoryEnvironmentInput + +func (RepositoryEnvironmentMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryEnvironment)(nil)).Elem() +} + +func (i RepositoryEnvironmentMap) ToRepositoryEnvironmentMapOutput() RepositoryEnvironmentMapOutput { + return i.ToRepositoryEnvironmentMapOutputWithContext(context.Background()) +} + +func (i RepositoryEnvironmentMap) ToRepositoryEnvironmentMapOutputWithContext(ctx context.Context) RepositoryEnvironmentMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryEnvironmentMapOutput) +} + +type RepositoryEnvironmentOutput struct{ *pulumi.OutputState } + +func (RepositoryEnvironmentOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryEnvironment)(nil)).Elem() +} + +func (o RepositoryEnvironmentOutput) ToRepositoryEnvironmentOutput() RepositoryEnvironmentOutput { + return o +} + +func (o RepositoryEnvironmentOutput) ToRepositoryEnvironmentOutputWithContext(ctx context.Context) RepositoryEnvironmentOutput { + return o +} + +// Can repository admins bypass the environment protections. Defaults to `true`. +func (o RepositoryEnvironmentOutput) CanAdminsBypass() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryEnvironment) pulumi.BoolPtrOutput { return v.CanAdminsBypass }).(pulumi.BoolPtrOutput) +} + +// The deployment branch policy configuration +func (o RepositoryEnvironmentOutput) DeploymentBranchPolicy() RepositoryEnvironmentDeploymentBranchPolicyPtrOutput { + return o.ApplyT(func(v *RepositoryEnvironment) RepositoryEnvironmentDeploymentBranchPolicyPtrOutput { + return v.DeploymentBranchPolicy + }).(RepositoryEnvironmentDeploymentBranchPolicyPtrOutput) +} + +// The name of the environment. +func (o RepositoryEnvironmentOutput) Environment() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryEnvironment) pulumi.StringOutput { return v.Environment }).(pulumi.StringOutput) +} + +// Whether or not a user who created the job is prevented from approving their own job. Defaults to `false`. +func (o RepositoryEnvironmentOutput) PreventSelfReview() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryEnvironment) pulumi.BoolPtrOutput { return v.PreventSelfReview }).(pulumi.BoolPtrOutput) +} + +// The repository of the environment. +func (o RepositoryEnvironmentOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryEnvironment) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// The ID of the repository. +func (o RepositoryEnvironmentOutput) RepositoryId() pulumi.IntOutput { + return o.ApplyT(func(v *RepositoryEnvironment) pulumi.IntOutput { return v.RepositoryId }).(pulumi.IntOutput) +} + +// The environment reviewers configuration. +func (o RepositoryEnvironmentOutput) Reviewers() RepositoryEnvironmentReviewerArrayOutput { + return o.ApplyT(func(v *RepositoryEnvironment) RepositoryEnvironmentReviewerArrayOutput { return v.Reviewers }).(RepositoryEnvironmentReviewerArrayOutput) +} + +// Amount of time to delay a job after the job is initially triggered. +func (o RepositoryEnvironmentOutput) WaitTimer() pulumi.IntPtrOutput { + return o.ApplyT(func(v *RepositoryEnvironment) pulumi.IntPtrOutput { return v.WaitTimer }).(pulumi.IntPtrOutput) +} + +type RepositoryEnvironmentArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryEnvironmentArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryEnvironment)(nil)).Elem() +} + +func (o RepositoryEnvironmentArrayOutput) ToRepositoryEnvironmentArrayOutput() RepositoryEnvironmentArrayOutput { + return o +} + +func (o RepositoryEnvironmentArrayOutput) ToRepositoryEnvironmentArrayOutputWithContext(ctx context.Context) RepositoryEnvironmentArrayOutput { + return o +} + +func (o RepositoryEnvironmentArrayOutput) Index(i pulumi.IntInput) RepositoryEnvironmentOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryEnvironment { + return vs[0].([]*RepositoryEnvironment)[vs[1].(int)] + }).(RepositoryEnvironmentOutput) +} + +type RepositoryEnvironmentMapOutput struct{ *pulumi.OutputState } + +func (RepositoryEnvironmentMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryEnvironment)(nil)).Elem() +} + +func (o RepositoryEnvironmentMapOutput) ToRepositoryEnvironmentMapOutput() RepositoryEnvironmentMapOutput { + return o +} + +func (o RepositoryEnvironmentMapOutput) ToRepositoryEnvironmentMapOutputWithContext(ctx context.Context) RepositoryEnvironmentMapOutput { + return o +} + +func (o RepositoryEnvironmentMapOutput) MapIndex(k pulumi.StringInput) RepositoryEnvironmentOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryEnvironment { + return vs[0].(map[string]*RepositoryEnvironment)[vs[1].(string)] + }).(RepositoryEnvironmentOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryEnvironmentInput)(nil)).Elem(), &RepositoryEnvironment{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryEnvironmentArrayInput)(nil)).Elem(), RepositoryEnvironmentArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryEnvironmentMapInput)(nil)).Elem(), RepositoryEnvironmentMap{}) + pulumi.RegisterOutputType(RepositoryEnvironmentOutput{}) + pulumi.RegisterOutputType(RepositoryEnvironmentArrayOutput{}) + pulumi.RegisterOutputType(RepositoryEnvironmentMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryEnvironmentDeploymentPolicy.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryEnvironmentDeploymentPolicy.go new file mode 100644 index 000000000..b813078ed --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryEnvironmentDeploymentPolicy.go @@ -0,0 +1,421 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage environment deployment branch policies for a GitHub repository. +// +// ## Example Usage +// +// Create a branch-based deployment policy: +// +// ```go +// 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 { +// current, err := github.GetUser(ctx, &github.GetUserArgs{ +// Username: "", +// }, nil) +// if err != nil { +// return err +// } +// test, err := github.NewRepository(ctx, "test", &github.RepositoryArgs{ +// Name: pulumi.String("tf-acc-test-%s"), +// }) +// if err != nil { +// return err +// } +// testRepositoryEnvironment, err := github.NewRepositoryEnvironment(ctx, "test", &github.RepositoryEnvironmentArgs{ +// Repository: test.Name, +// Environment: pulumi.String("environment/test"), +// WaitTimer: pulumi.Int(10000), +// Reviewers: github.RepositoryEnvironmentReviewerArray{ +// &github.RepositoryEnvironmentReviewerArgs{ +// Users: pulumi.IntArray{ +// pulumi.Int(pulumi.String(current.Id)), +// }, +// }, +// }, +// DeploymentBranchPolicy: &github.RepositoryEnvironmentDeploymentBranchPolicyArgs{ +// ProtectedBranches: pulumi.Bool(false), +// CustomBranchPolicies: pulumi.Bool(true), +// }, +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryEnvironmentDeploymentPolicy(ctx, "test", &github.RepositoryEnvironmentDeploymentPolicyArgs{ +// Repository: test.Name, +// Environment: testRepositoryEnvironment.Environment, +// BranchPattern: pulumi.String("releases/*"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// Create a tag-based deployment policy: +// +// ```go +// 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 { +// current, err := github.GetUser(ctx, &github.GetUserArgs{ +// Username: "", +// }, nil) +// if err != nil { +// return err +// } +// test, err := github.NewRepository(ctx, "test", &github.RepositoryArgs{ +// Name: pulumi.String("tf-acc-test-%s"), +// }) +// if err != nil { +// return err +// } +// testRepositoryEnvironment, err := github.NewRepositoryEnvironment(ctx, "test", &github.RepositoryEnvironmentArgs{ +// Repository: test.Name, +// Environment: pulumi.String("environment/test"), +// WaitTimer: pulumi.Int(10000), +// Reviewers: github.RepositoryEnvironmentReviewerArray{ +// &github.RepositoryEnvironmentReviewerArgs{ +// Users: pulumi.IntArray{ +// pulumi.Int(pulumi.String(current.Id)), +// }, +// }, +// }, +// DeploymentBranchPolicy: &github.RepositoryEnvironmentDeploymentBranchPolicyArgs{ +// ProtectedBranches: pulumi.Bool(false), +// CustomBranchPolicies: pulumi.Bool(true), +// }, +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryEnvironmentDeploymentPolicy(ctx, "test", &github.RepositoryEnvironmentDeploymentPolicyArgs{ +// Repository: test.Name, +// Environment: testRepositoryEnvironment.Environment, +// TagPattern: pulumi.String("v*"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using an ID made of the repository name, environment name (any `:` in the environment name need to be escaped as `??`), and deployment policy ID name all separated by a `:`. +// +// ### Import Command +// +// The following command imports a deployment policy with the ID `123456` for the repo `myrepo` and environment `myenv` to a `RepositoryEnvironmentDeploymentPolicy` resource named `example`. +// +// ```sh +// $ pulumi import github:index/repositoryEnvironmentDeploymentPolicy:RepositoryEnvironmentDeploymentPolicy example myrepo:myenv:123456 +// ``` +type RepositoryEnvironmentDeploymentPolicy struct { + pulumi.CustomResourceState + + // The name pattern that branches must match in order to deploy to the environment. If not specified, `tagPattern` must be specified. + BranchPattern pulumi.StringPtrOutput `pulumi:"branchPattern"` + // The name of the environment. + Environment pulumi.StringOutput `pulumi:"environment"` + // The ID of the deployment policy. + PolicyId pulumi.IntOutput `pulumi:"policyId"` + // The repository of the environment. + Repository pulumi.StringOutput `pulumi:"repository"` + // The ID of the repository. + RepositoryId pulumi.IntOutput `pulumi:"repositoryId"` + // The name pattern that tags must match in order to deploy to the environment. If not specified, `branchPattern` must be specified. + TagPattern pulumi.StringPtrOutput `pulumi:"tagPattern"` +} + +// NewRepositoryEnvironmentDeploymentPolicy registers a new resource with the given unique name, arguments, and options. +func NewRepositoryEnvironmentDeploymentPolicy(ctx *pulumi.Context, + name string, args *RepositoryEnvironmentDeploymentPolicyArgs, opts ...pulumi.ResourceOption) (*RepositoryEnvironmentDeploymentPolicy, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Environment == nil { + return nil, errors.New("invalid value for required argument 'Environment'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryEnvironmentDeploymentPolicy + err := ctx.RegisterResource("github:index/repositoryEnvironmentDeploymentPolicy:RepositoryEnvironmentDeploymentPolicy", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryEnvironmentDeploymentPolicy gets an existing RepositoryEnvironmentDeploymentPolicy 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 GetRepositoryEnvironmentDeploymentPolicy(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryEnvironmentDeploymentPolicyState, opts ...pulumi.ResourceOption) (*RepositoryEnvironmentDeploymentPolicy, error) { + var resource RepositoryEnvironmentDeploymentPolicy + err := ctx.ReadResource("github:index/repositoryEnvironmentDeploymentPolicy:RepositoryEnvironmentDeploymentPolicy", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryEnvironmentDeploymentPolicy resources. +type repositoryEnvironmentDeploymentPolicyState struct { + // The name pattern that branches must match in order to deploy to the environment. If not specified, `tagPattern` must be specified. + BranchPattern *string `pulumi:"branchPattern"` + // The name of the environment. + Environment *string `pulumi:"environment"` + // The ID of the deployment policy. + PolicyId *int `pulumi:"policyId"` + // The repository of the environment. + Repository *string `pulumi:"repository"` + // The ID of the repository. + RepositoryId *int `pulumi:"repositoryId"` + // The name pattern that tags must match in order to deploy to the environment. If not specified, `branchPattern` must be specified. + TagPattern *string `pulumi:"tagPattern"` +} + +type RepositoryEnvironmentDeploymentPolicyState struct { + // The name pattern that branches must match in order to deploy to the environment. If not specified, `tagPattern` must be specified. + BranchPattern pulumi.StringPtrInput + // The name of the environment. + Environment pulumi.StringPtrInput + // The ID of the deployment policy. + PolicyId pulumi.IntPtrInput + // The repository of the environment. + Repository pulumi.StringPtrInput + // The ID of the repository. + RepositoryId pulumi.IntPtrInput + // The name pattern that tags must match in order to deploy to the environment. If not specified, `branchPattern` must be specified. + TagPattern pulumi.StringPtrInput +} + +func (RepositoryEnvironmentDeploymentPolicyState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryEnvironmentDeploymentPolicyState)(nil)).Elem() +} + +type repositoryEnvironmentDeploymentPolicyArgs struct { + // The name pattern that branches must match in order to deploy to the environment. If not specified, `tagPattern` must be specified. + BranchPattern *string `pulumi:"branchPattern"` + // The name of the environment. + Environment string `pulumi:"environment"` + // The repository of the environment. + Repository string `pulumi:"repository"` + // The name pattern that tags must match in order to deploy to the environment. If not specified, `branchPattern` must be specified. + TagPattern *string `pulumi:"tagPattern"` +} + +// The set of arguments for constructing a RepositoryEnvironmentDeploymentPolicy resource. +type RepositoryEnvironmentDeploymentPolicyArgs struct { + // The name pattern that branches must match in order to deploy to the environment. If not specified, `tagPattern` must be specified. + BranchPattern pulumi.StringPtrInput + // The name of the environment. + Environment pulumi.StringInput + // The repository of the environment. + Repository pulumi.StringInput + // The name pattern that tags must match in order to deploy to the environment. If not specified, `branchPattern` must be specified. + TagPattern pulumi.StringPtrInput +} + +func (RepositoryEnvironmentDeploymentPolicyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryEnvironmentDeploymentPolicyArgs)(nil)).Elem() +} + +type RepositoryEnvironmentDeploymentPolicyInput interface { + pulumi.Input + + ToRepositoryEnvironmentDeploymentPolicyOutput() RepositoryEnvironmentDeploymentPolicyOutput + ToRepositoryEnvironmentDeploymentPolicyOutputWithContext(ctx context.Context) RepositoryEnvironmentDeploymentPolicyOutput +} + +func (*RepositoryEnvironmentDeploymentPolicy) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryEnvironmentDeploymentPolicy)(nil)).Elem() +} + +func (i *RepositoryEnvironmentDeploymentPolicy) ToRepositoryEnvironmentDeploymentPolicyOutput() RepositoryEnvironmentDeploymentPolicyOutput { + return i.ToRepositoryEnvironmentDeploymentPolicyOutputWithContext(context.Background()) +} + +func (i *RepositoryEnvironmentDeploymentPolicy) ToRepositoryEnvironmentDeploymentPolicyOutputWithContext(ctx context.Context) RepositoryEnvironmentDeploymentPolicyOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryEnvironmentDeploymentPolicyOutput) +} + +// RepositoryEnvironmentDeploymentPolicyArrayInput is an input type that accepts RepositoryEnvironmentDeploymentPolicyArray and RepositoryEnvironmentDeploymentPolicyArrayOutput values. +// You can construct a concrete instance of `RepositoryEnvironmentDeploymentPolicyArrayInput` via: +// +// RepositoryEnvironmentDeploymentPolicyArray{ RepositoryEnvironmentDeploymentPolicyArgs{...} } +type RepositoryEnvironmentDeploymentPolicyArrayInput interface { + pulumi.Input + + ToRepositoryEnvironmentDeploymentPolicyArrayOutput() RepositoryEnvironmentDeploymentPolicyArrayOutput + ToRepositoryEnvironmentDeploymentPolicyArrayOutputWithContext(context.Context) RepositoryEnvironmentDeploymentPolicyArrayOutput +} + +type RepositoryEnvironmentDeploymentPolicyArray []RepositoryEnvironmentDeploymentPolicyInput + +func (RepositoryEnvironmentDeploymentPolicyArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryEnvironmentDeploymentPolicy)(nil)).Elem() +} + +func (i RepositoryEnvironmentDeploymentPolicyArray) ToRepositoryEnvironmentDeploymentPolicyArrayOutput() RepositoryEnvironmentDeploymentPolicyArrayOutput { + return i.ToRepositoryEnvironmentDeploymentPolicyArrayOutputWithContext(context.Background()) +} + +func (i RepositoryEnvironmentDeploymentPolicyArray) ToRepositoryEnvironmentDeploymentPolicyArrayOutputWithContext(ctx context.Context) RepositoryEnvironmentDeploymentPolicyArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryEnvironmentDeploymentPolicyArrayOutput) +} + +// RepositoryEnvironmentDeploymentPolicyMapInput is an input type that accepts RepositoryEnvironmentDeploymentPolicyMap and RepositoryEnvironmentDeploymentPolicyMapOutput values. +// You can construct a concrete instance of `RepositoryEnvironmentDeploymentPolicyMapInput` via: +// +// RepositoryEnvironmentDeploymentPolicyMap{ "key": RepositoryEnvironmentDeploymentPolicyArgs{...} } +type RepositoryEnvironmentDeploymentPolicyMapInput interface { + pulumi.Input + + ToRepositoryEnvironmentDeploymentPolicyMapOutput() RepositoryEnvironmentDeploymentPolicyMapOutput + ToRepositoryEnvironmentDeploymentPolicyMapOutputWithContext(context.Context) RepositoryEnvironmentDeploymentPolicyMapOutput +} + +type RepositoryEnvironmentDeploymentPolicyMap map[string]RepositoryEnvironmentDeploymentPolicyInput + +func (RepositoryEnvironmentDeploymentPolicyMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryEnvironmentDeploymentPolicy)(nil)).Elem() +} + +func (i RepositoryEnvironmentDeploymentPolicyMap) ToRepositoryEnvironmentDeploymentPolicyMapOutput() RepositoryEnvironmentDeploymentPolicyMapOutput { + return i.ToRepositoryEnvironmentDeploymentPolicyMapOutputWithContext(context.Background()) +} + +func (i RepositoryEnvironmentDeploymentPolicyMap) ToRepositoryEnvironmentDeploymentPolicyMapOutputWithContext(ctx context.Context) RepositoryEnvironmentDeploymentPolicyMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryEnvironmentDeploymentPolicyMapOutput) +} + +type RepositoryEnvironmentDeploymentPolicyOutput struct{ *pulumi.OutputState } + +func (RepositoryEnvironmentDeploymentPolicyOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryEnvironmentDeploymentPolicy)(nil)).Elem() +} + +func (o RepositoryEnvironmentDeploymentPolicyOutput) ToRepositoryEnvironmentDeploymentPolicyOutput() RepositoryEnvironmentDeploymentPolicyOutput { + return o +} + +func (o RepositoryEnvironmentDeploymentPolicyOutput) ToRepositoryEnvironmentDeploymentPolicyOutputWithContext(ctx context.Context) RepositoryEnvironmentDeploymentPolicyOutput { + return o +} + +// The name pattern that branches must match in order to deploy to the environment. If not specified, `tagPattern` must be specified. +func (o RepositoryEnvironmentDeploymentPolicyOutput) BranchPattern() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryEnvironmentDeploymentPolicy) pulumi.StringPtrOutput { return v.BranchPattern }).(pulumi.StringPtrOutput) +} + +// The name of the environment. +func (o RepositoryEnvironmentDeploymentPolicyOutput) Environment() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryEnvironmentDeploymentPolicy) pulumi.StringOutput { return v.Environment }).(pulumi.StringOutput) +} + +// The ID of the deployment policy. +func (o RepositoryEnvironmentDeploymentPolicyOutput) PolicyId() pulumi.IntOutput { + return o.ApplyT(func(v *RepositoryEnvironmentDeploymentPolicy) pulumi.IntOutput { return v.PolicyId }).(pulumi.IntOutput) +} + +// The repository of the environment. +func (o RepositoryEnvironmentDeploymentPolicyOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryEnvironmentDeploymentPolicy) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// The ID of the repository. +func (o RepositoryEnvironmentDeploymentPolicyOutput) RepositoryId() pulumi.IntOutput { + return o.ApplyT(func(v *RepositoryEnvironmentDeploymentPolicy) pulumi.IntOutput { return v.RepositoryId }).(pulumi.IntOutput) +} + +// The name pattern that tags must match in order to deploy to the environment. If not specified, `branchPattern` must be specified. +func (o RepositoryEnvironmentDeploymentPolicyOutput) TagPattern() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryEnvironmentDeploymentPolicy) pulumi.StringPtrOutput { return v.TagPattern }).(pulumi.StringPtrOutput) +} + +type RepositoryEnvironmentDeploymentPolicyArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryEnvironmentDeploymentPolicyArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryEnvironmentDeploymentPolicy)(nil)).Elem() +} + +func (o RepositoryEnvironmentDeploymentPolicyArrayOutput) ToRepositoryEnvironmentDeploymentPolicyArrayOutput() RepositoryEnvironmentDeploymentPolicyArrayOutput { + return o +} + +func (o RepositoryEnvironmentDeploymentPolicyArrayOutput) ToRepositoryEnvironmentDeploymentPolicyArrayOutputWithContext(ctx context.Context) RepositoryEnvironmentDeploymentPolicyArrayOutput { + return o +} + +func (o RepositoryEnvironmentDeploymentPolicyArrayOutput) Index(i pulumi.IntInput) RepositoryEnvironmentDeploymentPolicyOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryEnvironmentDeploymentPolicy { + return vs[0].([]*RepositoryEnvironmentDeploymentPolicy)[vs[1].(int)] + }).(RepositoryEnvironmentDeploymentPolicyOutput) +} + +type RepositoryEnvironmentDeploymentPolicyMapOutput struct{ *pulumi.OutputState } + +func (RepositoryEnvironmentDeploymentPolicyMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryEnvironmentDeploymentPolicy)(nil)).Elem() +} + +func (o RepositoryEnvironmentDeploymentPolicyMapOutput) ToRepositoryEnvironmentDeploymentPolicyMapOutput() RepositoryEnvironmentDeploymentPolicyMapOutput { + return o +} + +func (o RepositoryEnvironmentDeploymentPolicyMapOutput) ToRepositoryEnvironmentDeploymentPolicyMapOutputWithContext(ctx context.Context) RepositoryEnvironmentDeploymentPolicyMapOutput { + return o +} + +func (o RepositoryEnvironmentDeploymentPolicyMapOutput) MapIndex(k pulumi.StringInput) RepositoryEnvironmentDeploymentPolicyOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryEnvironmentDeploymentPolicy { + return vs[0].(map[string]*RepositoryEnvironmentDeploymentPolicy)[vs[1].(string)] + }).(RepositoryEnvironmentDeploymentPolicyOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryEnvironmentDeploymentPolicyInput)(nil)).Elem(), &RepositoryEnvironmentDeploymentPolicy{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryEnvironmentDeploymentPolicyArrayInput)(nil)).Elem(), RepositoryEnvironmentDeploymentPolicyArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryEnvironmentDeploymentPolicyMapInput)(nil)).Elem(), RepositoryEnvironmentDeploymentPolicyMap{}) + pulumi.RegisterOutputType(RepositoryEnvironmentDeploymentPolicyOutput{}) + pulumi.RegisterOutputType(RepositoryEnvironmentDeploymentPolicyArrayOutput{}) + pulumi.RegisterOutputType(RepositoryEnvironmentDeploymentPolicyMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryFile.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryFile.go new file mode 100644 index 000000000..cfcd510e5 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryFile.go @@ -0,0 +1,561 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage files within a +// GitHub repository. +// +// > **Note:** When a repository is archived, Terraform will skip deletion of repository files to avoid API errors, as archived repositories are read-only. The files will be removed from Terraform state without attempting to delete them from GitHub. +// +// ## Example Usage +// +// ### Existing Branch +// +// ```go +// 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 { +// foo, err := github.NewRepository(ctx, "foo", &github.RepositoryArgs{ +// Name: pulumi.String("example"), +// AutoInit: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryFile(ctx, "foo", &github.RepositoryFileArgs{ +// Repository: foo.Name, +// Branch: pulumi.String("main"), +// File: pulumi.String(".gitignore"), +// Content: pulumi.String("**/*.tfstate"), +// CommitMessage: pulumi.String("Managed by Pulumi"), +// CommitAuthor: pulumi.String("Terraform User"), +// CommitEmail: pulumi.String("terraform@example.com"), +// OverwriteOnCreate: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ### Auto Created Branch +// +// ```go +// 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 { +// foo, err := github.NewRepository(ctx, "foo", &github.RepositoryArgs{ +// Name: pulumi.String("example"), +// AutoInit: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryFile(ctx, "foo", &github.RepositoryFileArgs{ +// Repository: foo.Name, +// Branch: pulumi.String("does/not/exist"), +// File: pulumi.String(".gitignore"), +// Content: pulumi.String("**/*.tfstate"), +// CommitMessage: pulumi.String("Managed by Pulumi"), +// CommitAuthor: pulumi.String("Terraform User"), +// CommitEmail: pulumi.String("terraform@example.com"), +// OverwriteOnCreate: pulumi.Bool(true), +// AutocreateBranch: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// Repository files can be imported using a combination of the `repo`, `file` and `branch` or empty branch for the default branch, e.g. +// +// ```sh +// $ pulumi import github:index/repositoryFile:RepositoryFile gitignore example:.gitignore:feature-branch +// ``` +// +// and using default branch: +// +// ```sh +// $ pulumi import github:index/repositoryFile:RepositoryFile gitignore example:.gitignore: +// ``` +type RepositoryFile struct { + pulumi.CustomResourceState + + // **Deprecated** Automatically create the branch if it could not be found. Defaults to false. Subsequent reads if the branch is deleted will occur from 'autocreate_branch_source_branch'. Use the `Branch` resource instead. + // + // Deprecated: Use `Branch` resource instead + AutocreateBranch pulumi.BoolPtrOutput `pulumi:"autocreateBranch"` + // **Deprecated** The branch name to start from, if 'autocreate_branch' is set. Defaults to 'main'. Use the `Branch` resource instead. + // + // Deprecated: Use `Branch` resource instead + AutocreateBranchSourceBranch pulumi.StringPtrOutput `pulumi:"autocreateBranchSourceBranch"` + // **Deprecated** The commit hash to start from, if 'autocreate_branch' is set. Defaults to the tip of 'autocreate_branch_source_branch'. If provided, 'autocreate_branch_source_branch' is ignored. Use the `Branch` resource instead. + // + // Deprecated: Use `Branch` resource instead + AutocreateBranchSourceSha pulumi.StringOutput `pulumi:"autocreateBranchSourceSha"` + // Git branch (defaults to the repository's default branch). + // The branch must already exist, it will only be created automatically if 'autocreate_branch' is set true. + Branch pulumi.StringOutput `pulumi:"branch"` + // Committer author name to use. **NOTE:** GitHub app users may omit author and email information so GitHub can verify commits as the GitHub App. This maybe useful when a branch protection rule requires signed commits. + CommitAuthor pulumi.StringPtrOutput `pulumi:"commitAuthor"` + // Committer email address to use. **NOTE:** GitHub app users may omit author and email information so GitHub can verify commits as the GitHub App. This may be useful when a branch protection rule requires signed commits. + CommitEmail pulumi.StringPtrOutput `pulumi:"commitEmail"` + // The commit message when creating, updating or deleting the managed file. + CommitMessage pulumi.StringOutput `pulumi:"commitMessage"` + // The SHA of the commit that modified the file. + CommitSha pulumi.StringOutput `pulumi:"commitSha"` + // The file content. + Content pulumi.StringOutput `pulumi:"content"` + // The path of the file to manage. + File pulumi.StringOutput `pulumi:"file"` + // Enable overwriting existing files. If set to `true` it will overwrite an existing file with the same name. If set to `false` it will fail if there is an existing file with the same name. + OverwriteOnCreate pulumi.BoolPtrOutput `pulumi:"overwriteOnCreate"` + // The name of the commit/branch/tag. + Ref pulumi.StringOutput `pulumi:"ref"` + // The repository to create the file in. + Repository pulumi.StringOutput `pulumi:"repository"` + // The ID of the repository. + RepositoryId pulumi.IntOutput `pulumi:"repositoryId"` + // The SHA blob of the file. + Sha pulumi.StringOutput `pulumi:"sha"` +} + +// NewRepositoryFile registers a new resource with the given unique name, arguments, and options. +func NewRepositoryFile(ctx *pulumi.Context, + name string, args *RepositoryFileArgs, opts ...pulumi.ResourceOption) (*RepositoryFile, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Content == nil { + return nil, errors.New("invalid value for required argument 'Content'") + } + if args.File == nil { + return nil, errors.New("invalid value for required argument 'File'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryFile + err := ctx.RegisterResource("github:index/repositoryFile:RepositoryFile", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryFile gets an existing RepositoryFile 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 GetRepositoryFile(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryFileState, opts ...pulumi.ResourceOption) (*RepositoryFile, error) { + var resource RepositoryFile + err := ctx.ReadResource("github:index/repositoryFile:RepositoryFile", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryFile resources. +type repositoryFileState struct { + // **Deprecated** Automatically create the branch if it could not be found. Defaults to false. Subsequent reads if the branch is deleted will occur from 'autocreate_branch_source_branch'. Use the `Branch` resource instead. + // + // Deprecated: Use `Branch` resource instead + AutocreateBranch *bool `pulumi:"autocreateBranch"` + // **Deprecated** The branch name to start from, if 'autocreate_branch' is set. Defaults to 'main'. Use the `Branch` resource instead. + // + // Deprecated: Use `Branch` resource instead + AutocreateBranchSourceBranch *string `pulumi:"autocreateBranchSourceBranch"` + // **Deprecated** The commit hash to start from, if 'autocreate_branch' is set. Defaults to the tip of 'autocreate_branch_source_branch'. If provided, 'autocreate_branch_source_branch' is ignored. Use the `Branch` resource instead. + // + // Deprecated: Use `Branch` resource instead + AutocreateBranchSourceSha *string `pulumi:"autocreateBranchSourceSha"` + // Git branch (defaults to the repository's default branch). + // The branch must already exist, it will only be created automatically if 'autocreate_branch' is set true. + Branch *string `pulumi:"branch"` + // Committer author name to use. **NOTE:** GitHub app users may omit author and email information so GitHub can verify commits as the GitHub App. This maybe useful when a branch protection rule requires signed commits. + CommitAuthor *string `pulumi:"commitAuthor"` + // Committer email address to use. **NOTE:** GitHub app users may omit author and email information so GitHub can verify commits as the GitHub App. This may be useful when a branch protection rule requires signed commits. + CommitEmail *string `pulumi:"commitEmail"` + // The commit message when creating, updating or deleting the managed file. + CommitMessage *string `pulumi:"commitMessage"` + // The SHA of the commit that modified the file. + CommitSha *string `pulumi:"commitSha"` + // The file content. + Content *string `pulumi:"content"` + // The path of the file to manage. + File *string `pulumi:"file"` + // Enable overwriting existing files. If set to `true` it will overwrite an existing file with the same name. If set to `false` it will fail if there is an existing file with the same name. + OverwriteOnCreate *bool `pulumi:"overwriteOnCreate"` + // The name of the commit/branch/tag. + Ref *string `pulumi:"ref"` + // The repository to create the file in. + Repository *string `pulumi:"repository"` + // The ID of the repository. + RepositoryId *int `pulumi:"repositoryId"` + // The SHA blob of the file. + Sha *string `pulumi:"sha"` +} + +type RepositoryFileState struct { + // **Deprecated** Automatically create the branch if it could not be found. Defaults to false. Subsequent reads if the branch is deleted will occur from 'autocreate_branch_source_branch'. Use the `Branch` resource instead. + // + // Deprecated: Use `Branch` resource instead + AutocreateBranch pulumi.BoolPtrInput + // **Deprecated** The branch name to start from, if 'autocreate_branch' is set. Defaults to 'main'. Use the `Branch` resource instead. + // + // Deprecated: Use `Branch` resource instead + AutocreateBranchSourceBranch pulumi.StringPtrInput + // **Deprecated** The commit hash to start from, if 'autocreate_branch' is set. Defaults to the tip of 'autocreate_branch_source_branch'. If provided, 'autocreate_branch_source_branch' is ignored. Use the `Branch` resource instead. + // + // Deprecated: Use `Branch` resource instead + AutocreateBranchSourceSha pulumi.StringPtrInput + // Git branch (defaults to the repository's default branch). + // The branch must already exist, it will only be created automatically if 'autocreate_branch' is set true. + Branch pulumi.StringPtrInput + // Committer author name to use. **NOTE:** GitHub app users may omit author and email information so GitHub can verify commits as the GitHub App. This maybe useful when a branch protection rule requires signed commits. + CommitAuthor pulumi.StringPtrInput + // Committer email address to use. **NOTE:** GitHub app users may omit author and email information so GitHub can verify commits as the GitHub App. This may be useful when a branch protection rule requires signed commits. + CommitEmail pulumi.StringPtrInput + // The commit message when creating, updating or deleting the managed file. + CommitMessage pulumi.StringPtrInput + // The SHA of the commit that modified the file. + CommitSha pulumi.StringPtrInput + // The file content. + Content pulumi.StringPtrInput + // The path of the file to manage. + File pulumi.StringPtrInput + // Enable overwriting existing files. If set to `true` it will overwrite an existing file with the same name. If set to `false` it will fail if there is an existing file with the same name. + OverwriteOnCreate pulumi.BoolPtrInput + // The name of the commit/branch/tag. + Ref pulumi.StringPtrInput + // The repository to create the file in. + Repository pulumi.StringPtrInput + // The ID of the repository. + RepositoryId pulumi.IntPtrInput + // The SHA blob of the file. + Sha pulumi.StringPtrInput +} + +func (RepositoryFileState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryFileState)(nil)).Elem() +} + +type repositoryFileArgs struct { + // **Deprecated** Automatically create the branch if it could not be found. Defaults to false. Subsequent reads if the branch is deleted will occur from 'autocreate_branch_source_branch'. Use the `Branch` resource instead. + // + // Deprecated: Use `Branch` resource instead + AutocreateBranch *bool `pulumi:"autocreateBranch"` + // **Deprecated** The branch name to start from, if 'autocreate_branch' is set. Defaults to 'main'. Use the `Branch` resource instead. + // + // Deprecated: Use `Branch` resource instead + AutocreateBranchSourceBranch *string `pulumi:"autocreateBranchSourceBranch"` + // **Deprecated** The commit hash to start from, if 'autocreate_branch' is set. Defaults to the tip of 'autocreate_branch_source_branch'. If provided, 'autocreate_branch_source_branch' is ignored. Use the `Branch` resource instead. + // + // Deprecated: Use `Branch` resource instead + AutocreateBranchSourceSha *string `pulumi:"autocreateBranchSourceSha"` + // Git branch (defaults to the repository's default branch). + // The branch must already exist, it will only be created automatically if 'autocreate_branch' is set true. + Branch *string `pulumi:"branch"` + // Committer author name to use. **NOTE:** GitHub app users may omit author and email information so GitHub can verify commits as the GitHub App. This maybe useful when a branch protection rule requires signed commits. + CommitAuthor *string `pulumi:"commitAuthor"` + // Committer email address to use. **NOTE:** GitHub app users may omit author and email information so GitHub can verify commits as the GitHub App. This may be useful when a branch protection rule requires signed commits. + CommitEmail *string `pulumi:"commitEmail"` + // The commit message when creating, updating or deleting the managed file. + CommitMessage *string `pulumi:"commitMessage"` + // The file content. + Content string `pulumi:"content"` + // The path of the file to manage. + File string `pulumi:"file"` + // Enable overwriting existing files. If set to `true` it will overwrite an existing file with the same name. If set to `false` it will fail if there is an existing file with the same name. + OverwriteOnCreate *bool `pulumi:"overwriteOnCreate"` + // The repository to create the file in. + Repository string `pulumi:"repository"` +} + +// The set of arguments for constructing a RepositoryFile resource. +type RepositoryFileArgs struct { + // **Deprecated** Automatically create the branch if it could not be found. Defaults to false. Subsequent reads if the branch is deleted will occur from 'autocreate_branch_source_branch'. Use the `Branch` resource instead. + // + // Deprecated: Use `Branch` resource instead + AutocreateBranch pulumi.BoolPtrInput + // **Deprecated** The branch name to start from, if 'autocreate_branch' is set. Defaults to 'main'. Use the `Branch` resource instead. + // + // Deprecated: Use `Branch` resource instead + AutocreateBranchSourceBranch pulumi.StringPtrInput + // **Deprecated** The commit hash to start from, if 'autocreate_branch' is set. Defaults to the tip of 'autocreate_branch_source_branch'. If provided, 'autocreate_branch_source_branch' is ignored. Use the `Branch` resource instead. + // + // Deprecated: Use `Branch` resource instead + AutocreateBranchSourceSha pulumi.StringPtrInput + // Git branch (defaults to the repository's default branch). + // The branch must already exist, it will only be created automatically if 'autocreate_branch' is set true. + Branch pulumi.StringPtrInput + // Committer author name to use. **NOTE:** GitHub app users may omit author and email information so GitHub can verify commits as the GitHub App. This maybe useful when a branch protection rule requires signed commits. + CommitAuthor pulumi.StringPtrInput + // Committer email address to use. **NOTE:** GitHub app users may omit author and email information so GitHub can verify commits as the GitHub App. This may be useful when a branch protection rule requires signed commits. + CommitEmail pulumi.StringPtrInput + // The commit message when creating, updating or deleting the managed file. + CommitMessage pulumi.StringPtrInput + // The file content. + Content pulumi.StringInput + // The path of the file to manage. + File pulumi.StringInput + // Enable overwriting existing files. If set to `true` it will overwrite an existing file with the same name. If set to `false` it will fail if there is an existing file with the same name. + OverwriteOnCreate pulumi.BoolPtrInput + // The repository to create the file in. + Repository pulumi.StringInput +} + +func (RepositoryFileArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryFileArgs)(nil)).Elem() +} + +type RepositoryFileInput interface { + pulumi.Input + + ToRepositoryFileOutput() RepositoryFileOutput + ToRepositoryFileOutputWithContext(ctx context.Context) RepositoryFileOutput +} + +func (*RepositoryFile) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryFile)(nil)).Elem() +} + +func (i *RepositoryFile) ToRepositoryFileOutput() RepositoryFileOutput { + return i.ToRepositoryFileOutputWithContext(context.Background()) +} + +func (i *RepositoryFile) ToRepositoryFileOutputWithContext(ctx context.Context) RepositoryFileOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryFileOutput) +} + +// RepositoryFileArrayInput is an input type that accepts RepositoryFileArray and RepositoryFileArrayOutput values. +// You can construct a concrete instance of `RepositoryFileArrayInput` via: +// +// RepositoryFileArray{ RepositoryFileArgs{...} } +type RepositoryFileArrayInput interface { + pulumi.Input + + ToRepositoryFileArrayOutput() RepositoryFileArrayOutput + ToRepositoryFileArrayOutputWithContext(context.Context) RepositoryFileArrayOutput +} + +type RepositoryFileArray []RepositoryFileInput + +func (RepositoryFileArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryFile)(nil)).Elem() +} + +func (i RepositoryFileArray) ToRepositoryFileArrayOutput() RepositoryFileArrayOutput { + return i.ToRepositoryFileArrayOutputWithContext(context.Background()) +} + +func (i RepositoryFileArray) ToRepositoryFileArrayOutputWithContext(ctx context.Context) RepositoryFileArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryFileArrayOutput) +} + +// RepositoryFileMapInput is an input type that accepts RepositoryFileMap and RepositoryFileMapOutput values. +// You can construct a concrete instance of `RepositoryFileMapInput` via: +// +// RepositoryFileMap{ "key": RepositoryFileArgs{...} } +type RepositoryFileMapInput interface { + pulumi.Input + + ToRepositoryFileMapOutput() RepositoryFileMapOutput + ToRepositoryFileMapOutputWithContext(context.Context) RepositoryFileMapOutput +} + +type RepositoryFileMap map[string]RepositoryFileInput + +func (RepositoryFileMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryFile)(nil)).Elem() +} + +func (i RepositoryFileMap) ToRepositoryFileMapOutput() RepositoryFileMapOutput { + return i.ToRepositoryFileMapOutputWithContext(context.Background()) +} + +func (i RepositoryFileMap) ToRepositoryFileMapOutputWithContext(ctx context.Context) RepositoryFileMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryFileMapOutput) +} + +type RepositoryFileOutput struct{ *pulumi.OutputState } + +func (RepositoryFileOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryFile)(nil)).Elem() +} + +func (o RepositoryFileOutput) ToRepositoryFileOutput() RepositoryFileOutput { + return o +} + +func (o RepositoryFileOutput) ToRepositoryFileOutputWithContext(ctx context.Context) RepositoryFileOutput { + return o +} + +// **Deprecated** Automatically create the branch if it could not be found. Defaults to false. Subsequent reads if the branch is deleted will occur from 'autocreate_branch_source_branch'. Use the `Branch` resource instead. +// +// Deprecated: Use `Branch` resource instead +func (o RepositoryFileOutput) AutocreateBranch() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryFile) pulumi.BoolPtrOutput { return v.AutocreateBranch }).(pulumi.BoolPtrOutput) +} + +// **Deprecated** The branch name to start from, if 'autocreate_branch' is set. Defaults to 'main'. Use the `Branch` resource instead. +// +// Deprecated: Use `Branch` resource instead +func (o RepositoryFileOutput) AutocreateBranchSourceBranch() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryFile) pulumi.StringPtrOutput { return v.AutocreateBranchSourceBranch }).(pulumi.StringPtrOutput) +} + +// **Deprecated** The commit hash to start from, if 'autocreate_branch' is set. Defaults to the tip of 'autocreate_branch_source_branch'. If provided, 'autocreate_branch_source_branch' is ignored. Use the `Branch` resource instead. +// +// Deprecated: Use `Branch` resource instead +func (o RepositoryFileOutput) AutocreateBranchSourceSha() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryFile) pulumi.StringOutput { return v.AutocreateBranchSourceSha }).(pulumi.StringOutput) +} + +// Git branch (defaults to the repository's default branch). +// The branch must already exist, it will only be created automatically if 'autocreate_branch' is set true. +func (o RepositoryFileOutput) Branch() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryFile) pulumi.StringOutput { return v.Branch }).(pulumi.StringOutput) +} + +// Committer author name to use. **NOTE:** GitHub app users may omit author and email information so GitHub can verify commits as the GitHub App. This maybe useful when a branch protection rule requires signed commits. +func (o RepositoryFileOutput) CommitAuthor() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryFile) pulumi.StringPtrOutput { return v.CommitAuthor }).(pulumi.StringPtrOutput) +} + +// Committer email address to use. **NOTE:** GitHub app users may omit author and email information so GitHub can verify commits as the GitHub App. This may be useful when a branch protection rule requires signed commits. +func (o RepositoryFileOutput) CommitEmail() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryFile) pulumi.StringPtrOutput { return v.CommitEmail }).(pulumi.StringPtrOutput) +} + +// The commit message when creating, updating or deleting the managed file. +func (o RepositoryFileOutput) CommitMessage() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryFile) pulumi.StringOutput { return v.CommitMessage }).(pulumi.StringOutput) +} + +// The SHA of the commit that modified the file. +func (o RepositoryFileOutput) CommitSha() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryFile) pulumi.StringOutput { return v.CommitSha }).(pulumi.StringOutput) +} + +// The file content. +func (o RepositoryFileOutput) Content() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryFile) pulumi.StringOutput { return v.Content }).(pulumi.StringOutput) +} + +// The path of the file to manage. +func (o RepositoryFileOutput) File() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryFile) pulumi.StringOutput { return v.File }).(pulumi.StringOutput) +} + +// Enable overwriting existing files. If set to `true` it will overwrite an existing file with the same name. If set to `false` it will fail if there is an existing file with the same name. +func (o RepositoryFileOutput) OverwriteOnCreate() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryFile) pulumi.BoolPtrOutput { return v.OverwriteOnCreate }).(pulumi.BoolPtrOutput) +} + +// The name of the commit/branch/tag. +func (o RepositoryFileOutput) Ref() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryFile) pulumi.StringOutput { return v.Ref }).(pulumi.StringOutput) +} + +// The repository to create the file in. +func (o RepositoryFileOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryFile) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// The ID of the repository. +func (o RepositoryFileOutput) RepositoryId() pulumi.IntOutput { + return o.ApplyT(func(v *RepositoryFile) pulumi.IntOutput { return v.RepositoryId }).(pulumi.IntOutput) +} + +// The SHA blob of the file. +func (o RepositoryFileOutput) Sha() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryFile) pulumi.StringOutput { return v.Sha }).(pulumi.StringOutput) +} + +type RepositoryFileArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryFileArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryFile)(nil)).Elem() +} + +func (o RepositoryFileArrayOutput) ToRepositoryFileArrayOutput() RepositoryFileArrayOutput { + return o +} + +func (o RepositoryFileArrayOutput) ToRepositoryFileArrayOutputWithContext(ctx context.Context) RepositoryFileArrayOutput { + return o +} + +func (o RepositoryFileArrayOutput) Index(i pulumi.IntInput) RepositoryFileOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryFile { + return vs[0].([]*RepositoryFile)[vs[1].(int)] + }).(RepositoryFileOutput) +} + +type RepositoryFileMapOutput struct{ *pulumi.OutputState } + +func (RepositoryFileMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryFile)(nil)).Elem() +} + +func (o RepositoryFileMapOutput) ToRepositoryFileMapOutput() RepositoryFileMapOutput { + return o +} + +func (o RepositoryFileMapOutput) ToRepositoryFileMapOutputWithContext(ctx context.Context) RepositoryFileMapOutput { + return o +} + +func (o RepositoryFileMapOutput) MapIndex(k pulumi.StringInput) RepositoryFileOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryFile { + return vs[0].(map[string]*RepositoryFile)[vs[1].(string)] + }).(RepositoryFileOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryFileInput)(nil)).Elem(), &RepositoryFile{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryFileArrayInput)(nil)).Elem(), RepositoryFileArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryFileMapInput)(nil)).Elem(), RepositoryFileMap{}) + pulumi.RegisterOutputType(RepositoryFileOutput{}) + pulumi.RegisterOutputType(RepositoryFileArrayOutput{}) + pulumi.RegisterOutputType(RepositoryFileMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryMilestone.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryMilestone.go new file mode 100644 index 000000000..0bd5d39dc --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryMilestone.go @@ -0,0 +1,350 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Provides a GitHub repository milestone resource. +// +// This resource allows you to create and manage milestones for a GitHub Repository within an organization or user account. +// +// ## Example Usage +// +// ```go +// 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 { +// // Create a milestone for a repository +// _, err := github.NewRepositoryMilestone(ctx, "example", &github.RepositoryMilestoneArgs{ +// Owner: pulumi.String("example-owner"), +// Repository: pulumi.String("example-repository"), +// Title: pulumi.String("v1.1.0"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// A GitHub Repository Milestone can be imported using an ID made up of `owner/repository/number`, e.g. +// +// ```sh +// $ pulumi import github:index/repositoryMilestone:RepositoryMilestone example example-owner/example-repository/1 +// ``` +type RepositoryMilestone struct { + pulumi.CustomResourceState + + // A description of the milestone. + Description pulumi.StringPtrOutput `pulumi:"description"` + // The milestone due date. In `yyyy-mm-dd` format. + DueDate pulumi.StringPtrOutput `pulumi:"dueDate"` + // The number of the milestone. + Number pulumi.IntOutput `pulumi:"number"` + // The owner of the GitHub Repository. + Owner pulumi.StringOutput `pulumi:"owner"` + // The name of the GitHub Repository. + Repository pulumi.StringOutput `pulumi:"repository"` + // The state of the milestone. Either `open` or `closed`. Default: `open` + State pulumi.StringPtrOutput `pulumi:"state"` + // The title of the milestone. + Title pulumi.StringOutput `pulumi:"title"` +} + +// NewRepositoryMilestone registers a new resource with the given unique name, arguments, and options. +func NewRepositoryMilestone(ctx *pulumi.Context, + name string, args *RepositoryMilestoneArgs, opts ...pulumi.ResourceOption) (*RepositoryMilestone, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Owner == nil { + return nil, errors.New("invalid value for required argument 'Owner'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + if args.Title == nil { + return nil, errors.New("invalid value for required argument 'Title'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryMilestone + err := ctx.RegisterResource("github:index/repositoryMilestone:RepositoryMilestone", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryMilestone gets an existing RepositoryMilestone 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 GetRepositoryMilestone(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryMilestoneState, opts ...pulumi.ResourceOption) (*RepositoryMilestone, error) { + var resource RepositoryMilestone + err := ctx.ReadResource("github:index/repositoryMilestone:RepositoryMilestone", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryMilestone resources. +type repositoryMilestoneState struct { + // A description of the milestone. + Description *string `pulumi:"description"` + // The milestone due date. In `yyyy-mm-dd` format. + DueDate *string `pulumi:"dueDate"` + // The number of the milestone. + Number *int `pulumi:"number"` + // The owner of the GitHub Repository. + Owner *string `pulumi:"owner"` + // The name of the GitHub Repository. + Repository *string `pulumi:"repository"` + // The state of the milestone. Either `open` or `closed`. Default: `open` + State *string `pulumi:"state"` + // The title of the milestone. + Title *string `pulumi:"title"` +} + +type RepositoryMilestoneState struct { + // A description of the milestone. + Description pulumi.StringPtrInput + // The milestone due date. In `yyyy-mm-dd` format. + DueDate pulumi.StringPtrInput + // The number of the milestone. + Number pulumi.IntPtrInput + // The owner of the GitHub Repository. + Owner pulumi.StringPtrInput + // The name of the GitHub Repository. + Repository pulumi.StringPtrInput + // The state of the milestone. Either `open` or `closed`. Default: `open` + State pulumi.StringPtrInput + // The title of the milestone. + Title pulumi.StringPtrInput +} + +func (RepositoryMilestoneState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryMilestoneState)(nil)).Elem() +} + +type repositoryMilestoneArgs struct { + // A description of the milestone. + Description *string `pulumi:"description"` + // The milestone due date. In `yyyy-mm-dd` format. + DueDate *string `pulumi:"dueDate"` + // The owner of the GitHub Repository. + Owner string `pulumi:"owner"` + // The name of the GitHub Repository. + Repository string `pulumi:"repository"` + // The state of the milestone. Either `open` or `closed`. Default: `open` + State *string `pulumi:"state"` + // The title of the milestone. + Title string `pulumi:"title"` +} + +// The set of arguments for constructing a RepositoryMilestone resource. +type RepositoryMilestoneArgs struct { + // A description of the milestone. + Description pulumi.StringPtrInput + // The milestone due date. In `yyyy-mm-dd` format. + DueDate pulumi.StringPtrInput + // The owner of the GitHub Repository. + Owner pulumi.StringInput + // The name of the GitHub Repository. + Repository pulumi.StringInput + // The state of the milestone. Either `open` or `closed`. Default: `open` + State pulumi.StringPtrInput + // The title of the milestone. + Title pulumi.StringInput +} + +func (RepositoryMilestoneArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryMilestoneArgs)(nil)).Elem() +} + +type RepositoryMilestoneInput interface { + pulumi.Input + + ToRepositoryMilestoneOutput() RepositoryMilestoneOutput + ToRepositoryMilestoneOutputWithContext(ctx context.Context) RepositoryMilestoneOutput +} + +func (*RepositoryMilestone) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryMilestone)(nil)).Elem() +} + +func (i *RepositoryMilestone) ToRepositoryMilestoneOutput() RepositoryMilestoneOutput { + return i.ToRepositoryMilestoneOutputWithContext(context.Background()) +} + +func (i *RepositoryMilestone) ToRepositoryMilestoneOutputWithContext(ctx context.Context) RepositoryMilestoneOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryMilestoneOutput) +} + +// RepositoryMilestoneArrayInput is an input type that accepts RepositoryMilestoneArray and RepositoryMilestoneArrayOutput values. +// You can construct a concrete instance of `RepositoryMilestoneArrayInput` via: +// +// RepositoryMilestoneArray{ RepositoryMilestoneArgs{...} } +type RepositoryMilestoneArrayInput interface { + pulumi.Input + + ToRepositoryMilestoneArrayOutput() RepositoryMilestoneArrayOutput + ToRepositoryMilestoneArrayOutputWithContext(context.Context) RepositoryMilestoneArrayOutput +} + +type RepositoryMilestoneArray []RepositoryMilestoneInput + +func (RepositoryMilestoneArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryMilestone)(nil)).Elem() +} + +func (i RepositoryMilestoneArray) ToRepositoryMilestoneArrayOutput() RepositoryMilestoneArrayOutput { + return i.ToRepositoryMilestoneArrayOutputWithContext(context.Background()) +} + +func (i RepositoryMilestoneArray) ToRepositoryMilestoneArrayOutputWithContext(ctx context.Context) RepositoryMilestoneArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryMilestoneArrayOutput) +} + +// RepositoryMilestoneMapInput is an input type that accepts RepositoryMilestoneMap and RepositoryMilestoneMapOutput values. +// You can construct a concrete instance of `RepositoryMilestoneMapInput` via: +// +// RepositoryMilestoneMap{ "key": RepositoryMilestoneArgs{...} } +type RepositoryMilestoneMapInput interface { + pulumi.Input + + ToRepositoryMilestoneMapOutput() RepositoryMilestoneMapOutput + ToRepositoryMilestoneMapOutputWithContext(context.Context) RepositoryMilestoneMapOutput +} + +type RepositoryMilestoneMap map[string]RepositoryMilestoneInput + +func (RepositoryMilestoneMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryMilestone)(nil)).Elem() +} + +func (i RepositoryMilestoneMap) ToRepositoryMilestoneMapOutput() RepositoryMilestoneMapOutput { + return i.ToRepositoryMilestoneMapOutputWithContext(context.Background()) +} + +func (i RepositoryMilestoneMap) ToRepositoryMilestoneMapOutputWithContext(ctx context.Context) RepositoryMilestoneMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryMilestoneMapOutput) +} + +type RepositoryMilestoneOutput struct{ *pulumi.OutputState } + +func (RepositoryMilestoneOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryMilestone)(nil)).Elem() +} + +func (o RepositoryMilestoneOutput) ToRepositoryMilestoneOutput() RepositoryMilestoneOutput { + return o +} + +func (o RepositoryMilestoneOutput) ToRepositoryMilestoneOutputWithContext(ctx context.Context) RepositoryMilestoneOutput { + return o +} + +// A description of the milestone. +func (o RepositoryMilestoneOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryMilestone) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) +} + +// The milestone due date. In `yyyy-mm-dd` format. +func (o RepositoryMilestoneOutput) DueDate() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryMilestone) pulumi.StringPtrOutput { return v.DueDate }).(pulumi.StringPtrOutput) +} + +// The number of the milestone. +func (o RepositoryMilestoneOutput) Number() pulumi.IntOutput { + return o.ApplyT(func(v *RepositoryMilestone) pulumi.IntOutput { return v.Number }).(pulumi.IntOutput) +} + +// The owner of the GitHub Repository. +func (o RepositoryMilestoneOutput) Owner() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryMilestone) pulumi.StringOutput { return v.Owner }).(pulumi.StringOutput) +} + +// The name of the GitHub Repository. +func (o RepositoryMilestoneOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryMilestone) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// The state of the milestone. Either `open` or `closed`. Default: `open` +func (o RepositoryMilestoneOutput) State() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryMilestone) pulumi.StringPtrOutput { return v.State }).(pulumi.StringPtrOutput) +} + +// The title of the milestone. +func (o RepositoryMilestoneOutput) Title() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryMilestone) pulumi.StringOutput { return v.Title }).(pulumi.StringOutput) +} + +type RepositoryMilestoneArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryMilestoneArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryMilestone)(nil)).Elem() +} + +func (o RepositoryMilestoneArrayOutput) ToRepositoryMilestoneArrayOutput() RepositoryMilestoneArrayOutput { + return o +} + +func (o RepositoryMilestoneArrayOutput) ToRepositoryMilestoneArrayOutputWithContext(ctx context.Context) RepositoryMilestoneArrayOutput { + return o +} + +func (o RepositoryMilestoneArrayOutput) Index(i pulumi.IntInput) RepositoryMilestoneOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryMilestone { + return vs[0].([]*RepositoryMilestone)[vs[1].(int)] + }).(RepositoryMilestoneOutput) +} + +type RepositoryMilestoneMapOutput struct{ *pulumi.OutputState } + +func (RepositoryMilestoneMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryMilestone)(nil)).Elem() +} + +func (o RepositoryMilestoneMapOutput) ToRepositoryMilestoneMapOutput() RepositoryMilestoneMapOutput { + return o +} + +func (o RepositoryMilestoneMapOutput) ToRepositoryMilestoneMapOutputWithContext(ctx context.Context) RepositoryMilestoneMapOutput { + return o +} + +func (o RepositoryMilestoneMapOutput) MapIndex(k pulumi.StringInput) RepositoryMilestoneOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryMilestone { + return vs[0].(map[string]*RepositoryMilestone)[vs[1].(string)] + }).(RepositoryMilestoneOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryMilestoneInput)(nil)).Elem(), &RepositoryMilestone{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryMilestoneArrayInput)(nil)).Elem(), RepositoryMilestoneArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryMilestoneMapInput)(nil)).Elem(), RepositoryMilestoneMap{}) + pulumi.RegisterOutputType(RepositoryMilestoneOutput{}) + pulumi.RegisterOutputType(RepositoryMilestoneArrayOutput{}) + pulumi.RegisterOutputType(RepositoryMilestoneMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryPages.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryPages.go new file mode 100644 index 000000000..65eef842b --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryPages.go @@ -0,0 +1,478 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to manage GitHub Pages for a repository. See the +// [documentation](https://docs.github.com/en/pages/getting-started-with-github-pages/about-github-pages) +// for details on GitHub Pages. +// +// The authenticated user must be a repository administrator, maintainer, or have the 'manage GitHub Pages settings' permission. OAuth app tokens and personal access tokens (classic) need the repo scope to use this resource. +// +// ## Example Usage +// +// ### Legacy Build Type +// +// ```go +// 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-repo"), +// Visibility: pulumi.String("public"), +// AutoInit: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryPages(ctx, "example", &github.RepositoryPagesArgs{ +// Repository: example.Name, +// BuildType: pulumi.String("legacy"), +// Source: &github.RepositoryPagesSourceArgs{ +// Branch: pulumi.String("main"), +// Path: pulumi.String("/"), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ### Workflow Build Type (GitHub Actions) +// +// ```go +// 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-repo"), +// Visibility: pulumi.String("public"), +// AutoInit: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryPages(ctx, "example", &github.RepositoryPagesArgs{ +// Repository: example.Name, +// BuildType: pulumi.String("workflow"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ### With Custom Domain +// +// ```go +// 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-repo"), +// Visibility: pulumi.String("public"), +// AutoInit: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryPages(ctx, "example", &github.RepositoryPagesArgs{ +// Repository: example.Name, +// BuildType: pulumi.String("legacy"), +// Cname: pulumi.String("example.com"), +// HttpsEnforced: pulumi.Bool(true), +// Source: &github.RepositoryPagesSourceArgs{ +// Branch: pulumi.String("main"), +// Path: pulumi.String("/docs"), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub repository pages can be imported using the `repository-slug`, e.g. +// +// ```sh +// $ pulumi import github:index/repositoryPages:RepositoryPages example my-repo +// ``` +type RepositoryPages struct { + pulumi.CustomResourceState + + // The API URL of the GitHub Pages resource. + ApiUrl pulumi.StringOutput `pulumi:"apiUrl"` + // The GitHub Pages site's build status (e.g., `building` or `built`). + BuildStatus pulumi.StringOutput `pulumi:"buildStatus"` + // The type of GitHub Pages site to build. Can be `legacy` or `workflow`. Defaults to `legacy`. + BuildType pulumi.StringPtrOutput `pulumi:"buildType"` + // The custom domain for the repository. + Cname pulumi.StringPtrOutput `pulumi:"cname"` + // Whether the rendered GitHub Pages site has a custom 404 page. + Custom404 pulumi.BoolOutput `pulumi:"custom404"` + // The absolute URL (with scheme) to the rendered GitHub Pages site. + HtmlUrl pulumi.StringOutput `pulumi:"htmlUrl"` + // Whether HTTPS is enforced for the GitHub Pages site. GitHub Pages sites serve over HTTPS by default; this setting only applies when a custom domain (`cname`) is configured. Requires `cname` to be set. + HttpsEnforced pulumi.BoolOutput `pulumi:"httpsEnforced"` + // Whether the GitHub Pages site is public. + Public pulumi.BoolOutput `pulumi:"public"` + // The repository name to configure GitHub Pages for. + Repository pulumi.StringOutput `pulumi:"repository"` + // The ID of the repository. + RepositoryId pulumi.IntOutput `pulumi:"repositoryId"` + // The source branch and directory for the rendered Pages site. Required when `buildType` is `legacy`. See Source below for details. + Source RepositoryPagesSourcePtrOutput `pulumi:"source"` +} + +// NewRepositoryPages registers a new resource with the given unique name, arguments, and options. +func NewRepositoryPages(ctx *pulumi.Context, + name string, args *RepositoryPagesArgs, opts ...pulumi.ResourceOption) (*RepositoryPages, 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'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryPages + err := ctx.RegisterResource("github:index/repositoryPages:RepositoryPages", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryPages gets an existing RepositoryPages 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 GetRepositoryPages(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryPagesState, opts ...pulumi.ResourceOption) (*RepositoryPages, error) { + var resource RepositoryPages + err := ctx.ReadResource("github:index/repositoryPages:RepositoryPages", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryPages resources. +type repositoryPagesState struct { + // The API URL of the GitHub Pages resource. + ApiUrl *string `pulumi:"apiUrl"` + // The GitHub Pages site's build status (e.g., `building` or `built`). + BuildStatus *string `pulumi:"buildStatus"` + // The type of GitHub Pages site to build. Can be `legacy` or `workflow`. Defaults to `legacy`. + BuildType *string `pulumi:"buildType"` + // The custom domain for the repository. + Cname *string `pulumi:"cname"` + // Whether the rendered GitHub Pages site has a custom 404 page. + Custom404 *bool `pulumi:"custom404"` + // The absolute URL (with scheme) to the rendered GitHub Pages site. + HtmlUrl *string `pulumi:"htmlUrl"` + // Whether HTTPS is enforced for the GitHub Pages site. GitHub Pages sites serve over HTTPS by default; this setting only applies when a custom domain (`cname`) is configured. Requires `cname` to be set. + HttpsEnforced *bool `pulumi:"httpsEnforced"` + // Whether the GitHub Pages site is public. + Public *bool `pulumi:"public"` + // The repository name to configure GitHub Pages for. + Repository *string `pulumi:"repository"` + // The ID of the repository. + RepositoryId *int `pulumi:"repositoryId"` + // The source branch and directory for the rendered Pages site. Required when `buildType` is `legacy`. See Source below for details. + Source *RepositoryPagesSource `pulumi:"source"` +} + +type RepositoryPagesState struct { + // The API URL of the GitHub Pages resource. + ApiUrl pulumi.StringPtrInput + // The GitHub Pages site's build status (e.g., `building` or `built`). + BuildStatus pulumi.StringPtrInput + // The type of GitHub Pages site to build. Can be `legacy` or `workflow`. Defaults to `legacy`. + BuildType pulumi.StringPtrInput + // The custom domain for the repository. + Cname pulumi.StringPtrInput + // Whether the rendered GitHub Pages site has a custom 404 page. + Custom404 pulumi.BoolPtrInput + // The absolute URL (with scheme) to the rendered GitHub Pages site. + HtmlUrl pulumi.StringPtrInput + // Whether HTTPS is enforced for the GitHub Pages site. GitHub Pages sites serve over HTTPS by default; this setting only applies when a custom domain (`cname`) is configured. Requires `cname` to be set. + HttpsEnforced pulumi.BoolPtrInput + // Whether the GitHub Pages site is public. + Public pulumi.BoolPtrInput + // The repository name to configure GitHub Pages for. + Repository pulumi.StringPtrInput + // The ID of the repository. + RepositoryId pulumi.IntPtrInput + // The source branch and directory for the rendered Pages site. Required when `buildType` is `legacy`. See Source below for details. + Source RepositoryPagesSourcePtrInput +} + +func (RepositoryPagesState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryPagesState)(nil)).Elem() +} + +type repositoryPagesArgs struct { + // The type of GitHub Pages site to build. Can be `legacy` or `workflow`. Defaults to `legacy`. + BuildType *string `pulumi:"buildType"` + // The custom domain for the repository. + Cname *string `pulumi:"cname"` + // Whether HTTPS is enforced for the GitHub Pages site. GitHub Pages sites serve over HTTPS by default; this setting only applies when a custom domain (`cname`) is configured. Requires `cname` to be set. + HttpsEnforced *bool `pulumi:"httpsEnforced"` + // Whether the GitHub Pages site is public. + Public *bool `pulumi:"public"` + // The repository name to configure GitHub Pages for. + Repository string `pulumi:"repository"` + // The source branch and directory for the rendered Pages site. Required when `buildType` is `legacy`. See Source below for details. + Source *RepositoryPagesSource `pulumi:"source"` +} + +// The set of arguments for constructing a RepositoryPages resource. +type RepositoryPagesArgs struct { + // The type of GitHub Pages site to build. Can be `legacy` or `workflow`. Defaults to `legacy`. + BuildType pulumi.StringPtrInput + // The custom domain for the repository. + Cname pulumi.StringPtrInput + // Whether HTTPS is enforced for the GitHub Pages site. GitHub Pages sites serve over HTTPS by default; this setting only applies when a custom domain (`cname`) is configured. Requires `cname` to be set. + HttpsEnforced pulumi.BoolPtrInput + // Whether the GitHub Pages site is public. + Public pulumi.BoolPtrInput + // The repository name to configure GitHub Pages for. + Repository pulumi.StringInput + // The source branch and directory for the rendered Pages site. Required when `buildType` is `legacy`. See Source below for details. + Source RepositoryPagesSourcePtrInput +} + +func (RepositoryPagesArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryPagesArgs)(nil)).Elem() +} + +type RepositoryPagesInput interface { + pulumi.Input + + ToRepositoryPagesOutput() RepositoryPagesOutput + ToRepositoryPagesOutputWithContext(ctx context.Context) RepositoryPagesOutput +} + +func (*RepositoryPages) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryPages)(nil)).Elem() +} + +func (i *RepositoryPages) ToRepositoryPagesOutput() RepositoryPagesOutput { + return i.ToRepositoryPagesOutputWithContext(context.Background()) +} + +func (i *RepositoryPages) ToRepositoryPagesOutputWithContext(ctx context.Context) RepositoryPagesOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryPagesOutput) +} + +// RepositoryPagesArrayInput is an input type that accepts RepositoryPagesArray and RepositoryPagesArrayOutput values. +// You can construct a concrete instance of `RepositoryPagesArrayInput` via: +// +// RepositoryPagesArray{ RepositoryPagesArgs{...} } +type RepositoryPagesArrayInput interface { + pulumi.Input + + ToRepositoryPagesArrayOutput() RepositoryPagesArrayOutput + ToRepositoryPagesArrayOutputWithContext(context.Context) RepositoryPagesArrayOutput +} + +type RepositoryPagesArray []RepositoryPagesInput + +func (RepositoryPagesArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryPages)(nil)).Elem() +} + +func (i RepositoryPagesArray) ToRepositoryPagesArrayOutput() RepositoryPagesArrayOutput { + return i.ToRepositoryPagesArrayOutputWithContext(context.Background()) +} + +func (i RepositoryPagesArray) ToRepositoryPagesArrayOutputWithContext(ctx context.Context) RepositoryPagesArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryPagesArrayOutput) +} + +// RepositoryPagesMapInput is an input type that accepts RepositoryPagesMap and RepositoryPagesMapOutput values. +// You can construct a concrete instance of `RepositoryPagesMapInput` via: +// +// RepositoryPagesMap{ "key": RepositoryPagesArgs{...} } +type RepositoryPagesMapInput interface { + pulumi.Input + + ToRepositoryPagesMapOutput() RepositoryPagesMapOutput + ToRepositoryPagesMapOutputWithContext(context.Context) RepositoryPagesMapOutput +} + +type RepositoryPagesMap map[string]RepositoryPagesInput + +func (RepositoryPagesMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryPages)(nil)).Elem() +} + +func (i RepositoryPagesMap) ToRepositoryPagesMapOutput() RepositoryPagesMapOutput { + return i.ToRepositoryPagesMapOutputWithContext(context.Background()) +} + +func (i RepositoryPagesMap) ToRepositoryPagesMapOutputWithContext(ctx context.Context) RepositoryPagesMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryPagesMapOutput) +} + +type RepositoryPagesOutput struct{ *pulumi.OutputState } + +func (RepositoryPagesOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryPages)(nil)).Elem() +} + +func (o RepositoryPagesOutput) ToRepositoryPagesOutput() RepositoryPagesOutput { + return o +} + +func (o RepositoryPagesOutput) ToRepositoryPagesOutputWithContext(ctx context.Context) RepositoryPagesOutput { + return o +} + +// The API URL of the GitHub Pages resource. +func (o RepositoryPagesOutput) ApiUrl() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryPages) pulumi.StringOutput { return v.ApiUrl }).(pulumi.StringOutput) +} + +// The GitHub Pages site's build status (e.g., `building` or `built`). +func (o RepositoryPagesOutput) BuildStatus() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryPages) pulumi.StringOutput { return v.BuildStatus }).(pulumi.StringOutput) +} + +// The type of GitHub Pages site to build. Can be `legacy` or `workflow`. Defaults to `legacy`. +func (o RepositoryPagesOutput) BuildType() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryPages) pulumi.StringPtrOutput { return v.BuildType }).(pulumi.StringPtrOutput) +} + +// The custom domain for the repository. +func (o RepositoryPagesOutput) Cname() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryPages) pulumi.StringPtrOutput { return v.Cname }).(pulumi.StringPtrOutput) +} + +// Whether the rendered GitHub Pages site has a custom 404 page. +func (o RepositoryPagesOutput) Custom404() pulumi.BoolOutput { + return o.ApplyT(func(v *RepositoryPages) pulumi.BoolOutput { return v.Custom404 }).(pulumi.BoolOutput) +} + +// The absolute URL (with scheme) to the rendered GitHub Pages site. +func (o RepositoryPagesOutput) HtmlUrl() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryPages) pulumi.StringOutput { return v.HtmlUrl }).(pulumi.StringOutput) +} + +// Whether HTTPS is enforced for the GitHub Pages site. GitHub Pages sites serve over HTTPS by default; this setting only applies when a custom domain (`cname`) is configured. Requires `cname` to be set. +func (o RepositoryPagesOutput) HttpsEnforced() pulumi.BoolOutput { + return o.ApplyT(func(v *RepositoryPages) pulumi.BoolOutput { return v.HttpsEnforced }).(pulumi.BoolOutput) +} + +// Whether the GitHub Pages site is public. +func (o RepositoryPagesOutput) Public() pulumi.BoolOutput { + return o.ApplyT(func(v *RepositoryPages) pulumi.BoolOutput { return v.Public }).(pulumi.BoolOutput) +} + +// The repository name to configure GitHub Pages for. +func (o RepositoryPagesOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryPages) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// The ID of the repository. +func (o RepositoryPagesOutput) RepositoryId() pulumi.IntOutput { + return o.ApplyT(func(v *RepositoryPages) pulumi.IntOutput { return v.RepositoryId }).(pulumi.IntOutput) +} + +// The source branch and directory for the rendered Pages site. Required when `buildType` is `legacy`. See Source below for details. +func (o RepositoryPagesOutput) Source() RepositoryPagesSourcePtrOutput { + return o.ApplyT(func(v *RepositoryPages) RepositoryPagesSourcePtrOutput { return v.Source }).(RepositoryPagesSourcePtrOutput) +} + +type RepositoryPagesArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryPagesArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryPages)(nil)).Elem() +} + +func (o RepositoryPagesArrayOutput) ToRepositoryPagesArrayOutput() RepositoryPagesArrayOutput { + return o +} + +func (o RepositoryPagesArrayOutput) ToRepositoryPagesArrayOutputWithContext(ctx context.Context) RepositoryPagesArrayOutput { + return o +} + +func (o RepositoryPagesArrayOutput) Index(i pulumi.IntInput) RepositoryPagesOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryPages { + return vs[0].([]*RepositoryPages)[vs[1].(int)] + }).(RepositoryPagesOutput) +} + +type RepositoryPagesMapOutput struct{ *pulumi.OutputState } + +func (RepositoryPagesMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryPages)(nil)).Elem() +} + +func (o RepositoryPagesMapOutput) ToRepositoryPagesMapOutput() RepositoryPagesMapOutput { + return o +} + +func (o RepositoryPagesMapOutput) ToRepositoryPagesMapOutputWithContext(ctx context.Context) RepositoryPagesMapOutput { + return o +} + +func (o RepositoryPagesMapOutput) MapIndex(k pulumi.StringInput) RepositoryPagesOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryPages { + return vs[0].(map[string]*RepositoryPages)[vs[1].(string)] + }).(RepositoryPagesOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryPagesInput)(nil)).Elem(), &RepositoryPages{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryPagesArrayInput)(nil)).Elem(), RepositoryPagesArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryPagesMapInput)(nil)).Elem(), RepositoryPagesMap{}) + pulumi.RegisterOutputType(RepositoryPagesOutput{}) + pulumi.RegisterOutputType(RepositoryPagesArrayOutput{}) + pulumi.RegisterOutputType(RepositoryPagesMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryProject.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryProject.go new file mode 100644 index 000000000..5f8227c7d --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryProject.go @@ -0,0 +1,307 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// !> **Warning:** This resource no longer works as the [Projects (classic) REST API](https://docs.github.com/en/rest/projects/projects?apiVersion=2022-11-28) has been [removed](https://github.blog/changelog/2024-05-23-sunset-notice-projects-classic/) and as such has been deprecated. It will be removed in a future release. +// +// This resource allows you to create and manage projects for GitHub repository. +// +// ## Example Usage +// +// ```go +// 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("example"), +// Description: pulumi.String("My awesome codebase"), +// HasProjects: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryProject(ctx, "project", &github.RepositoryProjectArgs{ +// Name: pulumi.String("A Repository Project"), +// Repository: example.Name, +// Body: pulumi.String("This is a repository project."), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +type RepositoryProject struct { + pulumi.CustomResourceState + + // The body of the project. + Body pulumi.StringPtrOutput `pulumi:"body"` + Etag pulumi.StringOutput `pulumi:"etag"` + // The name of the project. + Name pulumi.StringOutput `pulumi:"name"` + // The repository of the project. + Repository pulumi.StringOutput `pulumi:"repository"` + // URL of the project + Url pulumi.StringOutput `pulumi:"url"` +} + +// NewRepositoryProject registers a new resource with the given unique name, arguments, and options. +func NewRepositoryProject(ctx *pulumi.Context, + name string, args *RepositoryProjectArgs, opts ...pulumi.ResourceOption) (*RepositoryProject, 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'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryProject + err := ctx.RegisterResource("github:index/repositoryProject:RepositoryProject", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryProject gets an existing RepositoryProject 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 GetRepositoryProject(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryProjectState, opts ...pulumi.ResourceOption) (*RepositoryProject, error) { + var resource RepositoryProject + err := ctx.ReadResource("github:index/repositoryProject:RepositoryProject", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryProject resources. +type repositoryProjectState struct { + // The body of the project. + Body *string `pulumi:"body"` + Etag *string `pulumi:"etag"` + // The name of the project. + Name *string `pulumi:"name"` + // The repository of the project. + Repository *string `pulumi:"repository"` + // URL of the project + Url *string `pulumi:"url"` +} + +type RepositoryProjectState struct { + // The body of the project. + Body pulumi.StringPtrInput + Etag pulumi.StringPtrInput + // The name of the project. + Name pulumi.StringPtrInput + // The repository of the project. + Repository pulumi.StringPtrInput + // URL of the project + Url pulumi.StringPtrInput +} + +func (RepositoryProjectState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryProjectState)(nil)).Elem() +} + +type repositoryProjectArgs struct { + // The body of the project. + Body *string `pulumi:"body"` + Etag *string `pulumi:"etag"` + // The name of the project. + Name *string `pulumi:"name"` + // The repository of the project. + Repository string `pulumi:"repository"` +} + +// The set of arguments for constructing a RepositoryProject resource. +type RepositoryProjectArgs struct { + // The body of the project. + Body pulumi.StringPtrInput + Etag pulumi.StringPtrInput + // The name of the project. + Name pulumi.StringPtrInput + // The repository of the project. + Repository pulumi.StringInput +} + +func (RepositoryProjectArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryProjectArgs)(nil)).Elem() +} + +type RepositoryProjectInput interface { + pulumi.Input + + ToRepositoryProjectOutput() RepositoryProjectOutput + ToRepositoryProjectOutputWithContext(ctx context.Context) RepositoryProjectOutput +} + +func (*RepositoryProject) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryProject)(nil)).Elem() +} + +func (i *RepositoryProject) ToRepositoryProjectOutput() RepositoryProjectOutput { + return i.ToRepositoryProjectOutputWithContext(context.Background()) +} + +func (i *RepositoryProject) ToRepositoryProjectOutputWithContext(ctx context.Context) RepositoryProjectOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryProjectOutput) +} + +// RepositoryProjectArrayInput is an input type that accepts RepositoryProjectArray and RepositoryProjectArrayOutput values. +// You can construct a concrete instance of `RepositoryProjectArrayInput` via: +// +// RepositoryProjectArray{ RepositoryProjectArgs{...} } +type RepositoryProjectArrayInput interface { + pulumi.Input + + ToRepositoryProjectArrayOutput() RepositoryProjectArrayOutput + ToRepositoryProjectArrayOutputWithContext(context.Context) RepositoryProjectArrayOutput +} + +type RepositoryProjectArray []RepositoryProjectInput + +func (RepositoryProjectArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryProject)(nil)).Elem() +} + +func (i RepositoryProjectArray) ToRepositoryProjectArrayOutput() RepositoryProjectArrayOutput { + return i.ToRepositoryProjectArrayOutputWithContext(context.Background()) +} + +func (i RepositoryProjectArray) ToRepositoryProjectArrayOutputWithContext(ctx context.Context) RepositoryProjectArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryProjectArrayOutput) +} + +// RepositoryProjectMapInput is an input type that accepts RepositoryProjectMap and RepositoryProjectMapOutput values. +// You can construct a concrete instance of `RepositoryProjectMapInput` via: +// +// RepositoryProjectMap{ "key": RepositoryProjectArgs{...} } +type RepositoryProjectMapInput interface { + pulumi.Input + + ToRepositoryProjectMapOutput() RepositoryProjectMapOutput + ToRepositoryProjectMapOutputWithContext(context.Context) RepositoryProjectMapOutput +} + +type RepositoryProjectMap map[string]RepositoryProjectInput + +func (RepositoryProjectMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryProject)(nil)).Elem() +} + +func (i RepositoryProjectMap) ToRepositoryProjectMapOutput() RepositoryProjectMapOutput { + return i.ToRepositoryProjectMapOutputWithContext(context.Background()) +} + +func (i RepositoryProjectMap) ToRepositoryProjectMapOutputWithContext(ctx context.Context) RepositoryProjectMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryProjectMapOutput) +} + +type RepositoryProjectOutput struct{ *pulumi.OutputState } + +func (RepositoryProjectOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryProject)(nil)).Elem() +} + +func (o RepositoryProjectOutput) ToRepositoryProjectOutput() RepositoryProjectOutput { + return o +} + +func (o RepositoryProjectOutput) ToRepositoryProjectOutputWithContext(ctx context.Context) RepositoryProjectOutput { + return o +} + +// The body of the project. +func (o RepositoryProjectOutput) Body() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryProject) pulumi.StringPtrOutput { return v.Body }).(pulumi.StringPtrOutput) +} + +func (o RepositoryProjectOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryProject) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// The name of the project. +func (o RepositoryProjectOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryProject) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// The repository of the project. +func (o RepositoryProjectOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryProject) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// URL of the project +func (o RepositoryProjectOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryProject) pulumi.StringOutput { return v.Url }).(pulumi.StringOutput) +} + +type RepositoryProjectArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryProjectArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryProject)(nil)).Elem() +} + +func (o RepositoryProjectArrayOutput) ToRepositoryProjectArrayOutput() RepositoryProjectArrayOutput { + return o +} + +func (o RepositoryProjectArrayOutput) ToRepositoryProjectArrayOutputWithContext(ctx context.Context) RepositoryProjectArrayOutput { + return o +} + +func (o RepositoryProjectArrayOutput) Index(i pulumi.IntInput) RepositoryProjectOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryProject { + return vs[0].([]*RepositoryProject)[vs[1].(int)] + }).(RepositoryProjectOutput) +} + +type RepositoryProjectMapOutput struct{ *pulumi.OutputState } + +func (RepositoryProjectMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryProject)(nil)).Elem() +} + +func (o RepositoryProjectMapOutput) ToRepositoryProjectMapOutput() RepositoryProjectMapOutput { + return o +} + +func (o RepositoryProjectMapOutput) ToRepositoryProjectMapOutputWithContext(ctx context.Context) RepositoryProjectMapOutput { + return o +} + +func (o RepositoryProjectMapOutput) MapIndex(k pulumi.StringInput) RepositoryProjectOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryProject { + return vs[0].(map[string]*RepositoryProject)[vs[1].(string)] + }).(RepositoryProjectOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryProjectInput)(nil)).Elem(), &RepositoryProject{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryProjectArrayInput)(nil)).Elem(), RepositoryProjectArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryProjectMapInput)(nil)).Elem(), RepositoryProjectMap{}) + pulumi.RegisterOutputType(RepositoryProjectOutput{}) + pulumi.RegisterOutputType(RepositoryProjectArrayOutput{}) + pulumi.RegisterOutputType(RepositoryProjectMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryPullRequest.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryPullRequest.go new file mode 100644 index 000000000..3e8763636 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryPullRequest.go @@ -0,0 +1,447 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage PullRequests for repositories within your GitHub organization or personal account. +// +// ## Example Usage +// +// ```go +// 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.NewRepositoryPullRequest(ctx, "example", &github.RepositoryPullRequestArgs{ +// BaseRepository: pulumi.String("example-repository"), +// BaseRef: pulumi.String("main"), +// HeadRef: pulumi.String("feature-branch"), +// Title: pulumi.String("My newest feature"), +// Body: pulumi.String("This will change everything"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +type RepositoryPullRequest struct { + pulumi.CustomResourceState + + // Name of the branch serving as the base of the Pull Request. + BaseRef pulumi.StringOutput `pulumi:"baseRef"` + // Name of the base repository to retrieve the Pull Requests from. + BaseRepository pulumi.StringOutput `pulumi:"baseRepository"` + // Head commit SHA of the Pull Request base. + BaseSha pulumi.StringOutput `pulumi:"baseSha"` + // Body of the Pull Request. + Body pulumi.StringPtrOutput `pulumi:"body"` + // Indicates Whether this Pull Request is a draft. + Draft pulumi.BoolOutput `pulumi:"draft"` + // Name of the branch serving as the head of the Pull Request. + HeadRef pulumi.StringOutput `pulumi:"headRef"` + // Head commit SHA of the Pull Request head. + HeadSha pulumi.StringOutput `pulumi:"headSha"` + // List of label names set on the Pull Request. + Labels pulumi.StringArrayOutput `pulumi:"labels"` + // Controls whether the base repository maintainers can modify the Pull Request. Default: false. + MaintainerCanModify pulumi.BoolPtrOutput `pulumi:"maintainerCanModify"` + // The number of the Pull Request within the repository. + Number pulumi.IntOutput `pulumi:"number"` + // Unix timestamp indicating the Pull Request creation time. + OpenedAt pulumi.IntOutput `pulumi:"openedAt"` + // GitHub login of the user who opened the Pull Request. + OpenedBy pulumi.StringOutput `pulumi:"openedBy"` + // Owner of the repository. If not provided, the provider's default owner is used. + Owner pulumi.StringPtrOutput `pulumi:"owner"` + // the current Pull Request state - can be "open", "closed" or "merged". + State pulumi.StringOutput `pulumi:"state"` + // The title of the Pull Request. + Title pulumi.StringOutput `pulumi:"title"` + // The timestamp of the last Pull Request update. + UpdatedAt pulumi.IntOutput `pulumi:"updatedAt"` +} + +// NewRepositoryPullRequest registers a new resource with the given unique name, arguments, and options. +func NewRepositoryPullRequest(ctx *pulumi.Context, + name string, args *RepositoryPullRequestArgs, opts ...pulumi.ResourceOption) (*RepositoryPullRequest, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.BaseRef == nil { + return nil, errors.New("invalid value for required argument 'BaseRef'") + } + if args.BaseRepository == nil { + return nil, errors.New("invalid value for required argument 'BaseRepository'") + } + if args.HeadRef == nil { + return nil, errors.New("invalid value for required argument 'HeadRef'") + } + if args.Title == nil { + return nil, errors.New("invalid value for required argument 'Title'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryPullRequest + err := ctx.RegisterResource("github:index/repositoryPullRequest:RepositoryPullRequest", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryPullRequest gets an existing RepositoryPullRequest 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 GetRepositoryPullRequest(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryPullRequestState, opts ...pulumi.ResourceOption) (*RepositoryPullRequest, error) { + var resource RepositoryPullRequest + err := ctx.ReadResource("github:index/repositoryPullRequest:RepositoryPullRequest", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryPullRequest resources. +type repositoryPullRequestState struct { + // Name of the branch serving as the base of the Pull Request. + BaseRef *string `pulumi:"baseRef"` + // Name of the base repository to retrieve the Pull Requests from. + BaseRepository *string `pulumi:"baseRepository"` + // Head commit SHA of the Pull Request base. + BaseSha *string `pulumi:"baseSha"` + // Body of the Pull Request. + Body *string `pulumi:"body"` + // Indicates Whether this Pull Request is a draft. + Draft *bool `pulumi:"draft"` + // Name of the branch serving as the head of the Pull Request. + HeadRef *string `pulumi:"headRef"` + // Head commit SHA of the Pull Request head. + HeadSha *string `pulumi:"headSha"` + // List of label names set on the Pull Request. + Labels []string `pulumi:"labels"` + // Controls whether the base repository maintainers can modify the Pull Request. Default: false. + MaintainerCanModify *bool `pulumi:"maintainerCanModify"` + // The number of the Pull Request within the repository. + Number *int `pulumi:"number"` + // Unix timestamp indicating the Pull Request creation time. + OpenedAt *int `pulumi:"openedAt"` + // GitHub login of the user who opened the Pull Request. + OpenedBy *string `pulumi:"openedBy"` + // Owner of the repository. If not provided, the provider's default owner is used. + Owner *string `pulumi:"owner"` + // the current Pull Request state - can be "open", "closed" or "merged". + State *string `pulumi:"state"` + // The title of the Pull Request. + Title *string `pulumi:"title"` + // The timestamp of the last Pull Request update. + UpdatedAt *int `pulumi:"updatedAt"` +} + +type RepositoryPullRequestState struct { + // Name of the branch serving as the base of the Pull Request. + BaseRef pulumi.StringPtrInput + // Name of the base repository to retrieve the Pull Requests from. + BaseRepository pulumi.StringPtrInput + // Head commit SHA of the Pull Request base. + BaseSha pulumi.StringPtrInput + // Body of the Pull Request. + Body pulumi.StringPtrInput + // Indicates Whether this Pull Request is a draft. + Draft pulumi.BoolPtrInput + // Name of the branch serving as the head of the Pull Request. + HeadRef pulumi.StringPtrInput + // Head commit SHA of the Pull Request head. + HeadSha pulumi.StringPtrInput + // List of label names set on the Pull Request. + Labels pulumi.StringArrayInput + // Controls whether the base repository maintainers can modify the Pull Request. Default: false. + MaintainerCanModify pulumi.BoolPtrInput + // The number of the Pull Request within the repository. + Number pulumi.IntPtrInput + // Unix timestamp indicating the Pull Request creation time. + OpenedAt pulumi.IntPtrInput + // GitHub login of the user who opened the Pull Request. + OpenedBy pulumi.StringPtrInput + // Owner of the repository. If not provided, the provider's default owner is used. + Owner pulumi.StringPtrInput + // the current Pull Request state - can be "open", "closed" or "merged". + State pulumi.StringPtrInput + // The title of the Pull Request. + Title pulumi.StringPtrInput + // The timestamp of the last Pull Request update. + UpdatedAt pulumi.IntPtrInput +} + +func (RepositoryPullRequestState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryPullRequestState)(nil)).Elem() +} + +type repositoryPullRequestArgs struct { + // Name of the branch serving as the base of the Pull Request. + BaseRef string `pulumi:"baseRef"` + // Name of the base repository to retrieve the Pull Requests from. + BaseRepository string `pulumi:"baseRepository"` + // Body of the Pull Request. + Body *string `pulumi:"body"` + // Name of the branch serving as the head of the Pull Request. + HeadRef string `pulumi:"headRef"` + // Controls whether the base repository maintainers can modify the Pull Request. Default: false. + MaintainerCanModify *bool `pulumi:"maintainerCanModify"` + // Owner of the repository. If not provided, the provider's default owner is used. + Owner *string `pulumi:"owner"` + // The title of the Pull Request. + Title string `pulumi:"title"` +} + +// The set of arguments for constructing a RepositoryPullRequest resource. +type RepositoryPullRequestArgs struct { + // Name of the branch serving as the base of the Pull Request. + BaseRef pulumi.StringInput + // Name of the base repository to retrieve the Pull Requests from. + BaseRepository pulumi.StringInput + // Body of the Pull Request. + Body pulumi.StringPtrInput + // Name of the branch serving as the head of the Pull Request. + HeadRef pulumi.StringInput + // Controls whether the base repository maintainers can modify the Pull Request. Default: false. + MaintainerCanModify pulumi.BoolPtrInput + // Owner of the repository. If not provided, the provider's default owner is used. + Owner pulumi.StringPtrInput + // The title of the Pull Request. + Title pulumi.StringInput +} + +func (RepositoryPullRequestArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryPullRequestArgs)(nil)).Elem() +} + +type RepositoryPullRequestInput interface { + pulumi.Input + + ToRepositoryPullRequestOutput() RepositoryPullRequestOutput + ToRepositoryPullRequestOutputWithContext(ctx context.Context) RepositoryPullRequestOutput +} + +func (*RepositoryPullRequest) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryPullRequest)(nil)).Elem() +} + +func (i *RepositoryPullRequest) ToRepositoryPullRequestOutput() RepositoryPullRequestOutput { + return i.ToRepositoryPullRequestOutputWithContext(context.Background()) +} + +func (i *RepositoryPullRequest) ToRepositoryPullRequestOutputWithContext(ctx context.Context) RepositoryPullRequestOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryPullRequestOutput) +} + +// RepositoryPullRequestArrayInput is an input type that accepts RepositoryPullRequestArray and RepositoryPullRequestArrayOutput values. +// You can construct a concrete instance of `RepositoryPullRequestArrayInput` via: +// +// RepositoryPullRequestArray{ RepositoryPullRequestArgs{...} } +type RepositoryPullRequestArrayInput interface { + pulumi.Input + + ToRepositoryPullRequestArrayOutput() RepositoryPullRequestArrayOutput + ToRepositoryPullRequestArrayOutputWithContext(context.Context) RepositoryPullRequestArrayOutput +} + +type RepositoryPullRequestArray []RepositoryPullRequestInput + +func (RepositoryPullRequestArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryPullRequest)(nil)).Elem() +} + +func (i RepositoryPullRequestArray) ToRepositoryPullRequestArrayOutput() RepositoryPullRequestArrayOutput { + return i.ToRepositoryPullRequestArrayOutputWithContext(context.Background()) +} + +func (i RepositoryPullRequestArray) ToRepositoryPullRequestArrayOutputWithContext(ctx context.Context) RepositoryPullRequestArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryPullRequestArrayOutput) +} + +// RepositoryPullRequestMapInput is an input type that accepts RepositoryPullRequestMap and RepositoryPullRequestMapOutput values. +// You can construct a concrete instance of `RepositoryPullRequestMapInput` via: +// +// RepositoryPullRequestMap{ "key": RepositoryPullRequestArgs{...} } +type RepositoryPullRequestMapInput interface { + pulumi.Input + + ToRepositoryPullRequestMapOutput() RepositoryPullRequestMapOutput + ToRepositoryPullRequestMapOutputWithContext(context.Context) RepositoryPullRequestMapOutput +} + +type RepositoryPullRequestMap map[string]RepositoryPullRequestInput + +func (RepositoryPullRequestMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryPullRequest)(nil)).Elem() +} + +func (i RepositoryPullRequestMap) ToRepositoryPullRequestMapOutput() RepositoryPullRequestMapOutput { + return i.ToRepositoryPullRequestMapOutputWithContext(context.Background()) +} + +func (i RepositoryPullRequestMap) ToRepositoryPullRequestMapOutputWithContext(ctx context.Context) RepositoryPullRequestMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryPullRequestMapOutput) +} + +type RepositoryPullRequestOutput struct{ *pulumi.OutputState } + +func (RepositoryPullRequestOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryPullRequest)(nil)).Elem() +} + +func (o RepositoryPullRequestOutput) ToRepositoryPullRequestOutput() RepositoryPullRequestOutput { + return o +} + +func (o RepositoryPullRequestOutput) ToRepositoryPullRequestOutputWithContext(ctx context.Context) RepositoryPullRequestOutput { + return o +} + +// Name of the branch serving as the base of the Pull Request. +func (o RepositoryPullRequestOutput) BaseRef() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryPullRequest) pulumi.StringOutput { return v.BaseRef }).(pulumi.StringOutput) +} + +// Name of the base repository to retrieve the Pull Requests from. +func (o RepositoryPullRequestOutput) BaseRepository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryPullRequest) pulumi.StringOutput { return v.BaseRepository }).(pulumi.StringOutput) +} + +// Head commit SHA of the Pull Request base. +func (o RepositoryPullRequestOutput) BaseSha() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryPullRequest) pulumi.StringOutput { return v.BaseSha }).(pulumi.StringOutput) +} + +// Body of the Pull Request. +func (o RepositoryPullRequestOutput) Body() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryPullRequest) pulumi.StringPtrOutput { return v.Body }).(pulumi.StringPtrOutput) +} + +// Indicates Whether this Pull Request is a draft. +func (o RepositoryPullRequestOutput) Draft() pulumi.BoolOutput { + return o.ApplyT(func(v *RepositoryPullRequest) pulumi.BoolOutput { return v.Draft }).(pulumi.BoolOutput) +} + +// Name of the branch serving as the head of the Pull Request. +func (o RepositoryPullRequestOutput) HeadRef() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryPullRequest) pulumi.StringOutput { return v.HeadRef }).(pulumi.StringOutput) +} + +// Head commit SHA of the Pull Request head. +func (o RepositoryPullRequestOutput) HeadSha() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryPullRequest) pulumi.StringOutput { return v.HeadSha }).(pulumi.StringOutput) +} + +// List of label names set on the Pull Request. +func (o RepositoryPullRequestOutput) Labels() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RepositoryPullRequest) pulumi.StringArrayOutput { return v.Labels }).(pulumi.StringArrayOutput) +} + +// Controls whether the base repository maintainers can modify the Pull Request. Default: false. +func (o RepositoryPullRequestOutput) MaintainerCanModify() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryPullRequest) pulumi.BoolPtrOutput { return v.MaintainerCanModify }).(pulumi.BoolPtrOutput) +} + +// The number of the Pull Request within the repository. +func (o RepositoryPullRequestOutput) Number() pulumi.IntOutput { + return o.ApplyT(func(v *RepositoryPullRequest) pulumi.IntOutput { return v.Number }).(pulumi.IntOutput) +} + +// Unix timestamp indicating the Pull Request creation time. +func (o RepositoryPullRequestOutput) OpenedAt() pulumi.IntOutput { + return o.ApplyT(func(v *RepositoryPullRequest) pulumi.IntOutput { return v.OpenedAt }).(pulumi.IntOutput) +} + +// GitHub login of the user who opened the Pull Request. +func (o RepositoryPullRequestOutput) OpenedBy() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryPullRequest) pulumi.StringOutput { return v.OpenedBy }).(pulumi.StringOutput) +} + +// Owner of the repository. If not provided, the provider's default owner is used. +func (o RepositoryPullRequestOutput) Owner() pulumi.StringPtrOutput { + return o.ApplyT(func(v *RepositoryPullRequest) pulumi.StringPtrOutput { return v.Owner }).(pulumi.StringPtrOutput) +} + +// the current Pull Request state - can be "open", "closed" or "merged". +func (o RepositoryPullRequestOutput) State() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryPullRequest) pulumi.StringOutput { return v.State }).(pulumi.StringOutput) +} + +// The title of the Pull Request. +func (o RepositoryPullRequestOutput) Title() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryPullRequest) pulumi.StringOutput { return v.Title }).(pulumi.StringOutput) +} + +// The timestamp of the last Pull Request update. +func (o RepositoryPullRequestOutput) UpdatedAt() pulumi.IntOutput { + return o.ApplyT(func(v *RepositoryPullRequest) pulumi.IntOutput { return v.UpdatedAt }).(pulumi.IntOutput) +} + +type RepositoryPullRequestArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryPullRequestArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryPullRequest)(nil)).Elem() +} + +func (o RepositoryPullRequestArrayOutput) ToRepositoryPullRequestArrayOutput() RepositoryPullRequestArrayOutput { + return o +} + +func (o RepositoryPullRequestArrayOutput) ToRepositoryPullRequestArrayOutputWithContext(ctx context.Context) RepositoryPullRequestArrayOutput { + return o +} + +func (o RepositoryPullRequestArrayOutput) Index(i pulumi.IntInput) RepositoryPullRequestOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryPullRequest { + return vs[0].([]*RepositoryPullRequest)[vs[1].(int)] + }).(RepositoryPullRequestOutput) +} + +type RepositoryPullRequestMapOutput struct{ *pulumi.OutputState } + +func (RepositoryPullRequestMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryPullRequest)(nil)).Elem() +} + +func (o RepositoryPullRequestMapOutput) ToRepositoryPullRequestMapOutput() RepositoryPullRequestMapOutput { + return o +} + +func (o RepositoryPullRequestMapOutput) ToRepositoryPullRequestMapOutputWithContext(ctx context.Context) RepositoryPullRequestMapOutput { + return o +} + +func (o RepositoryPullRequestMapOutput) MapIndex(k pulumi.StringInput) RepositoryPullRequestOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryPullRequest { + return vs[0].(map[string]*RepositoryPullRequest)[vs[1].(string)] + }).(RepositoryPullRequestOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryPullRequestInput)(nil)).Elem(), &RepositoryPullRequest{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryPullRequestArrayInput)(nil)).Elem(), RepositoryPullRequestArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryPullRequestMapInput)(nil)).Elem(), RepositoryPullRequestMap{}) + pulumi.RegisterOutputType(RepositoryPullRequestOutput{}) + pulumi.RegisterOutputType(RepositoryPullRequestArrayOutput{}) + pulumi.RegisterOutputType(RepositoryPullRequestMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryRuleset.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryRuleset.go new file mode 100644 index 000000000..766256dcd --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryRuleset.go @@ -0,0 +1,462 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Creates a GitHub repository ruleset. +// +// This resource allows you to create and manage rulesets on the repository level. When applied, a new ruleset will be created. When destroyed, that ruleset will be removed. +// +// ## Example Usage +// +// ```go +// 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("example"), +// Description: pulumi.String("Example repository"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryRuleset(ctx, "example", &github.RepositoryRulesetArgs{ +// Name: pulumi.String("example"), +// Repository: example.Name, +// Target: pulumi.String("branch"), +// Enforcement: pulumi.String("active"), +// Conditions: &github.RepositoryRulesetConditionsArgs{ +// RefName: &github.RepositoryRulesetConditionsRefNameArgs{ +// Includes: pulumi.StringArray{ +// pulumi.String("~ALL"), +// }, +// Excludes: pulumi.StringArray{}, +// }, +// }, +// BypassActors: github.RepositoryRulesetBypassActorArray{ +// &github.RepositoryRulesetBypassActorArgs{ +// ActorId: pulumi.Int(13473), +// ActorType: pulumi.String("Integration"), +// BypassMode: pulumi.String("always"), +// }, +// }, +// Rules: &github.RepositoryRulesetRulesArgs{ +// Creation: pulumi.Bool(true), +// Update: pulumi.Bool(true), +// Deletion: pulumi.Bool(true), +// RequiredLinearHistory: pulumi.Bool(true), +// RequiredSignatures: pulumi.Bool(true), +// RequiredDeployments: &github.RepositoryRulesetRulesRequiredDeploymentsArgs{ +// RequiredDeploymentEnvironments: pulumi.StringArray{ +// pulumi.String("test"), +// }, +// }, +// RequiredCodeScanning: &github.RepositoryRulesetRulesRequiredCodeScanningArgs{ +// RequiredCodeScanningTools: github.RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArray{ +// &github.RepositoryRulesetRulesRequiredCodeScanningRequiredCodeScanningToolArgs{ +// AlertsThreshold: pulumi.String("errors"), +// SecurityAlertsThreshold: pulumi.String("high_or_higher"), +// Tool: pulumi.String("CodeQL"), +// }, +// }, +// }, +// }, +// }) +// if err != nil { +// return err +// } +// // Example with push ruleset +// _, err = github.NewRepositoryRuleset(ctx, "example_push", &github.RepositoryRulesetArgs{ +// Name: pulumi.String("example_push"), +// Repository: example.Name, +// Target: pulumi.String("push"), +// Enforcement: pulumi.String("active"), +// Rules: &github.RepositoryRulesetRulesArgs{ +// FilePathRestriction: &github.RepositoryRulesetRulesFilePathRestrictionArgs{ +// RestrictedFilePaths: pulumi.StringArray{ +// pulumi.String(".github/workflows/*"), +// pulumi.String("*.env"), +// }, +// }, +// MaxFileSize: &github.RepositoryRulesetRulesMaxFileSizeArgs{ +// MaxFileSize: pulumi.Int(100), +// }, +// MaxFilePathLength: &github.RepositoryRulesetRulesMaxFilePathLengthArgs{ +// MaxFilePathLength: pulumi.Int(255), +// }, +// FileExtensionRestriction: &github.RepositoryRulesetRulesFileExtensionRestrictionArgs{ +// RestrictedFileExtensions: pulumi.StringArray{ +// pulumi.String("*.exe"), +// pulumi.String("*.dll"), +// pulumi.String("*.so"), +// }, +// }, +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Repository Rulesets can be imported using the GitHub repository name and ruleset ID e.g. +// +// `$ terraform import github_repository_ruleset.example example:12345` +type RepositoryRuleset struct { + pulumi.CustomResourceState + + // (Block List) The actors that can bypass the rules in this ruleset. (see below for nested schema) + BypassActors RepositoryRulesetBypassActorArrayOutput `pulumi:"bypassActors"` + // (Block List, Max: 1) Parameters for a repository ruleset condition. For `branch` and `tag` targets, `refName` is required. For `push` targets, `refName` must NOT be set - conditions are optional for push targets. (see below for nested schema) + Conditions RepositoryRulesetConditionsPtrOutput `pulumi:"conditions"` + // (String) Possible values for Enforcement are `disabled`, `active`, `evaluate`. Note: `evaluate` is currently only supported for owners of type `organization`. + Enforcement pulumi.StringOutput `pulumi:"enforcement"` + // (String) + Etag pulumi.StringOutput `pulumi:"etag"` + // (String) The name of the ruleset. + Name pulumi.StringOutput `pulumi:"name"` + // (String) GraphQL global node id for use with v4 API. + NodeId pulumi.StringOutput `pulumi:"nodeId"` + // (String) Name of the repository to apply ruleset to. + Repository pulumi.StringOutput `pulumi:"repository"` + // (Block List, Min: 1, Max: 1) Rules within the ruleset. (see below for nested schema) + Rules RepositoryRulesetRulesOutput `pulumi:"rules"` + // (Number) GitHub ID for the ruleset. + RulesetId pulumi.IntOutput `pulumi:"rulesetId"` + // (String) Possible values are `branch`, `tag` and `push`. + Target pulumi.StringOutput `pulumi:"target"` +} + +// NewRepositoryRuleset registers a new resource with the given unique name, arguments, and options. +func NewRepositoryRuleset(ctx *pulumi.Context, + name string, args *RepositoryRulesetArgs, opts ...pulumi.ResourceOption) (*RepositoryRuleset, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Enforcement == nil { + return nil, errors.New("invalid value for required argument 'Enforcement'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + if args.Rules == nil { + return nil, errors.New("invalid value for required argument 'Rules'") + } + if args.Target == nil { + return nil, errors.New("invalid value for required argument 'Target'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryRuleset + err := ctx.RegisterResource("github:index/repositoryRuleset:RepositoryRuleset", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryRuleset gets an existing RepositoryRuleset 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 GetRepositoryRuleset(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryRulesetState, opts ...pulumi.ResourceOption) (*RepositoryRuleset, error) { + var resource RepositoryRuleset + err := ctx.ReadResource("github:index/repositoryRuleset:RepositoryRuleset", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryRuleset resources. +type repositoryRulesetState struct { + // (Block List) The actors that can bypass the rules in this ruleset. (see below for nested schema) + BypassActors []RepositoryRulesetBypassActor `pulumi:"bypassActors"` + // (Block List, Max: 1) Parameters for a repository ruleset condition. For `branch` and `tag` targets, `refName` is required. For `push` targets, `refName` must NOT be set - conditions are optional for push targets. (see below for nested schema) + Conditions *RepositoryRulesetConditions `pulumi:"conditions"` + // (String) Possible values for Enforcement are `disabled`, `active`, `evaluate`. Note: `evaluate` is currently only supported for owners of type `organization`. + Enforcement *string `pulumi:"enforcement"` + // (String) + Etag *string `pulumi:"etag"` + // (String) The name of the ruleset. + Name *string `pulumi:"name"` + // (String) GraphQL global node id for use with v4 API. + NodeId *string `pulumi:"nodeId"` + // (String) Name of the repository to apply ruleset to. + Repository *string `pulumi:"repository"` + // (Block List, Min: 1, Max: 1) Rules within the ruleset. (see below for nested schema) + Rules *RepositoryRulesetRules `pulumi:"rules"` + // (Number) GitHub ID for the ruleset. + RulesetId *int `pulumi:"rulesetId"` + // (String) Possible values are `branch`, `tag` and `push`. + Target *string `pulumi:"target"` +} + +type RepositoryRulesetState struct { + // (Block List) The actors that can bypass the rules in this ruleset. (see below for nested schema) + BypassActors RepositoryRulesetBypassActorArrayInput + // (Block List, Max: 1) Parameters for a repository ruleset condition. For `branch` and `tag` targets, `refName` is required. For `push` targets, `refName` must NOT be set - conditions are optional for push targets. (see below for nested schema) + Conditions RepositoryRulesetConditionsPtrInput + // (String) Possible values for Enforcement are `disabled`, `active`, `evaluate`. Note: `evaluate` is currently only supported for owners of type `organization`. + Enforcement pulumi.StringPtrInput + // (String) + Etag pulumi.StringPtrInput + // (String) The name of the ruleset. + Name pulumi.StringPtrInput + // (String) GraphQL global node id for use with v4 API. + NodeId pulumi.StringPtrInput + // (String) Name of the repository to apply ruleset to. + Repository pulumi.StringPtrInput + // (Block List, Min: 1, Max: 1) Rules within the ruleset. (see below for nested schema) + Rules RepositoryRulesetRulesPtrInput + // (Number) GitHub ID for the ruleset. + RulesetId pulumi.IntPtrInput + // (String) Possible values are `branch`, `tag` and `push`. + Target pulumi.StringPtrInput +} + +func (RepositoryRulesetState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryRulesetState)(nil)).Elem() +} + +type repositoryRulesetArgs struct { + // (Block List) The actors that can bypass the rules in this ruleset. (see below for nested schema) + BypassActors []RepositoryRulesetBypassActor `pulumi:"bypassActors"` + // (Block List, Max: 1) Parameters for a repository ruleset condition. For `branch` and `tag` targets, `refName` is required. For `push` targets, `refName` must NOT be set - conditions are optional for push targets. (see below for nested schema) + Conditions *RepositoryRulesetConditions `pulumi:"conditions"` + // (String) Possible values for Enforcement are `disabled`, `active`, `evaluate`. Note: `evaluate` is currently only supported for owners of type `organization`. + Enforcement string `pulumi:"enforcement"` + // (String) The name of the ruleset. + Name *string `pulumi:"name"` + // (String) Name of the repository to apply ruleset to. + Repository string `pulumi:"repository"` + // (Block List, Min: 1, Max: 1) Rules within the ruleset. (see below for nested schema) + Rules RepositoryRulesetRules `pulumi:"rules"` + // (String) Possible values are `branch`, `tag` and `push`. + Target string `pulumi:"target"` +} + +// The set of arguments for constructing a RepositoryRuleset resource. +type RepositoryRulesetArgs struct { + // (Block List) The actors that can bypass the rules in this ruleset. (see below for nested schema) + BypassActors RepositoryRulesetBypassActorArrayInput + // (Block List, Max: 1) Parameters for a repository ruleset condition. For `branch` and `tag` targets, `refName` is required. For `push` targets, `refName` must NOT be set - conditions are optional for push targets. (see below for nested schema) + Conditions RepositoryRulesetConditionsPtrInput + // (String) Possible values for Enforcement are `disabled`, `active`, `evaluate`. Note: `evaluate` is currently only supported for owners of type `organization`. + Enforcement pulumi.StringInput + // (String) The name of the ruleset. + Name pulumi.StringPtrInput + // (String) Name of the repository to apply ruleset to. + Repository pulumi.StringInput + // (Block List, Min: 1, Max: 1) Rules within the ruleset. (see below for nested schema) + Rules RepositoryRulesetRulesInput + // (String) Possible values are `branch`, `tag` and `push`. + Target pulumi.StringInput +} + +func (RepositoryRulesetArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryRulesetArgs)(nil)).Elem() +} + +type RepositoryRulesetInput interface { + pulumi.Input + + ToRepositoryRulesetOutput() RepositoryRulesetOutput + ToRepositoryRulesetOutputWithContext(ctx context.Context) RepositoryRulesetOutput +} + +func (*RepositoryRuleset) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRuleset)(nil)).Elem() +} + +func (i *RepositoryRuleset) ToRepositoryRulesetOutput() RepositoryRulesetOutput { + return i.ToRepositoryRulesetOutputWithContext(context.Background()) +} + +func (i *RepositoryRuleset) ToRepositoryRulesetOutputWithContext(ctx context.Context) RepositoryRulesetOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetOutput) +} + +// RepositoryRulesetArrayInput is an input type that accepts RepositoryRulesetArray and RepositoryRulesetArrayOutput values. +// You can construct a concrete instance of `RepositoryRulesetArrayInput` via: +// +// RepositoryRulesetArray{ RepositoryRulesetArgs{...} } +type RepositoryRulesetArrayInput interface { + pulumi.Input + + ToRepositoryRulesetArrayOutput() RepositoryRulesetArrayOutput + ToRepositoryRulesetArrayOutputWithContext(context.Context) RepositoryRulesetArrayOutput +} + +type RepositoryRulesetArray []RepositoryRulesetInput + +func (RepositoryRulesetArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryRuleset)(nil)).Elem() +} + +func (i RepositoryRulesetArray) ToRepositoryRulesetArrayOutput() RepositoryRulesetArrayOutput { + return i.ToRepositoryRulesetArrayOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetArray) ToRepositoryRulesetArrayOutputWithContext(ctx context.Context) RepositoryRulesetArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetArrayOutput) +} + +// RepositoryRulesetMapInput is an input type that accepts RepositoryRulesetMap and RepositoryRulesetMapOutput values. +// You can construct a concrete instance of `RepositoryRulesetMapInput` via: +// +// RepositoryRulesetMap{ "key": RepositoryRulesetArgs{...} } +type RepositoryRulesetMapInput interface { + pulumi.Input + + ToRepositoryRulesetMapOutput() RepositoryRulesetMapOutput + ToRepositoryRulesetMapOutputWithContext(context.Context) RepositoryRulesetMapOutput +} + +type RepositoryRulesetMap map[string]RepositoryRulesetInput + +func (RepositoryRulesetMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryRuleset)(nil)).Elem() +} + +func (i RepositoryRulesetMap) ToRepositoryRulesetMapOutput() RepositoryRulesetMapOutput { + return i.ToRepositoryRulesetMapOutputWithContext(context.Background()) +} + +func (i RepositoryRulesetMap) ToRepositoryRulesetMapOutputWithContext(ctx context.Context) RepositoryRulesetMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryRulesetMapOutput) +} + +type RepositoryRulesetOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryRuleset)(nil)).Elem() +} + +func (o RepositoryRulesetOutput) ToRepositoryRulesetOutput() RepositoryRulesetOutput { + return o +} + +func (o RepositoryRulesetOutput) ToRepositoryRulesetOutputWithContext(ctx context.Context) RepositoryRulesetOutput { + return o +} + +// (Block List) The actors that can bypass the rules in this ruleset. (see below for nested schema) +func (o RepositoryRulesetOutput) BypassActors() RepositoryRulesetBypassActorArrayOutput { + return o.ApplyT(func(v *RepositoryRuleset) RepositoryRulesetBypassActorArrayOutput { return v.BypassActors }).(RepositoryRulesetBypassActorArrayOutput) +} + +// (Block List, Max: 1) Parameters for a repository ruleset condition. For `branch` and `tag` targets, `refName` is required. For `push` targets, `refName` must NOT be set - conditions are optional for push targets. (see below for nested schema) +func (o RepositoryRulesetOutput) Conditions() RepositoryRulesetConditionsPtrOutput { + return o.ApplyT(func(v *RepositoryRuleset) RepositoryRulesetConditionsPtrOutput { return v.Conditions }).(RepositoryRulesetConditionsPtrOutput) +} + +// (String) Possible values for Enforcement are `disabled`, `active`, `evaluate`. Note: `evaluate` is currently only supported for owners of type `organization`. +func (o RepositoryRulesetOutput) Enforcement() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryRuleset) pulumi.StringOutput { return v.Enforcement }).(pulumi.StringOutput) +} + +// (String) +func (o RepositoryRulesetOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryRuleset) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// (String) The name of the ruleset. +func (o RepositoryRulesetOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryRuleset) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// (String) GraphQL global node id for use with v4 API. +func (o RepositoryRulesetOutput) NodeId() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryRuleset) pulumi.StringOutput { return v.NodeId }).(pulumi.StringOutput) +} + +// (String) Name of the repository to apply ruleset to. +func (o RepositoryRulesetOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryRuleset) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// (Block List, Min: 1, Max: 1) Rules within the ruleset. (see below for nested schema) +func (o RepositoryRulesetOutput) Rules() RepositoryRulesetRulesOutput { + return o.ApplyT(func(v *RepositoryRuleset) RepositoryRulesetRulesOutput { return v.Rules }).(RepositoryRulesetRulesOutput) +} + +// (Number) GitHub ID for the ruleset. +func (o RepositoryRulesetOutput) RulesetId() pulumi.IntOutput { + return o.ApplyT(func(v *RepositoryRuleset) pulumi.IntOutput { return v.RulesetId }).(pulumi.IntOutput) +} + +// (String) Possible values are `branch`, `tag` and `push`. +func (o RepositoryRulesetOutput) Target() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryRuleset) pulumi.StringOutput { return v.Target }).(pulumi.StringOutput) +} + +type RepositoryRulesetArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryRuleset)(nil)).Elem() +} + +func (o RepositoryRulesetArrayOutput) ToRepositoryRulesetArrayOutput() RepositoryRulesetArrayOutput { + return o +} + +func (o RepositoryRulesetArrayOutput) ToRepositoryRulesetArrayOutputWithContext(ctx context.Context) RepositoryRulesetArrayOutput { + return o +} + +func (o RepositoryRulesetArrayOutput) Index(i pulumi.IntInput) RepositoryRulesetOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryRuleset { + return vs[0].([]*RepositoryRuleset)[vs[1].(int)] + }).(RepositoryRulesetOutput) +} + +type RepositoryRulesetMapOutput struct{ *pulumi.OutputState } + +func (RepositoryRulesetMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryRuleset)(nil)).Elem() +} + +func (o RepositoryRulesetMapOutput) ToRepositoryRulesetMapOutput() RepositoryRulesetMapOutput { + return o +} + +func (o RepositoryRulesetMapOutput) ToRepositoryRulesetMapOutputWithContext(ctx context.Context) RepositoryRulesetMapOutput { + return o +} + +func (o RepositoryRulesetMapOutput) MapIndex(k pulumi.StringInput) RepositoryRulesetOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryRuleset { + return vs[0].(map[string]*RepositoryRuleset)[vs[1].(string)] + }).(RepositoryRulesetOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetInput)(nil)).Elem(), &RepositoryRuleset{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetArrayInput)(nil)).Elem(), RepositoryRulesetArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryRulesetMapInput)(nil)).Elem(), RepositoryRulesetMap{}) + pulumi.RegisterOutputType(RepositoryRulesetOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetArrayOutput{}) + pulumi.RegisterOutputType(RepositoryRulesetMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryTopics.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryTopics.go new file mode 100644 index 000000000..3926278fc --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryTopics.go @@ -0,0 +1,284 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage topics for repositories within your GitHub organization or personal account. +// +// > Note: This resource is not compatible with the `topic` attribute of the `Repository` Use either “RepositoryTopics“ +// or “topic“ in “Repository“. `RepositoryTopics` is only meant to be used if the repository itself is not handled via terraform, for example if it's only read as a datasource (see issue #1845). +// +// ## Example Usage +// +// ```go +// 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.GetRepository(ctx, &github.LookupRepositoryArgs{ +// Name: pulumi.StringRef("test"), +// }, nil) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryTopics(ctx, "test", &github.RepositoryTopicsArgs{ +// Repository: pulumi.Any(testGithubRepository.Name), +// Topics: pulumi.StringArray{ +// pulumi.String("topic-1"), +// pulumi.String("topic-2"), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// Repository topics can be imported using the `name` of the repository. +// +// ```sh +// $ pulumi import github:index/repositoryTopics:RepositoryTopics terraform terraform +// ``` +type RepositoryTopics struct { + pulumi.CustomResourceState + + // The repository name. + Repository pulumi.StringOutput `pulumi:"repository"` + // A list of topics to add to the repository. + Topics pulumi.StringArrayOutput `pulumi:"topics"` +} + +// NewRepositoryTopics registers a new resource with the given unique name, arguments, and options. +func NewRepositoryTopics(ctx *pulumi.Context, + name string, args *RepositoryTopicsArgs, opts ...pulumi.ResourceOption) (*RepositoryTopics, 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.Topics == nil { + return nil, errors.New("invalid value for required argument 'Topics'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryTopics + err := ctx.RegisterResource("github:index/repositoryTopics:RepositoryTopics", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryTopics gets an existing RepositoryTopics 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 GetRepositoryTopics(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryTopicsState, opts ...pulumi.ResourceOption) (*RepositoryTopics, error) { + var resource RepositoryTopics + err := ctx.ReadResource("github:index/repositoryTopics:RepositoryTopics", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryTopics resources. +type repositoryTopicsState struct { + // The repository name. + Repository *string `pulumi:"repository"` + // A list of topics to add to the repository. + Topics []string `pulumi:"topics"` +} + +type RepositoryTopicsState struct { + // The repository name. + Repository pulumi.StringPtrInput + // A list of topics to add to the repository. + Topics pulumi.StringArrayInput +} + +func (RepositoryTopicsState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryTopicsState)(nil)).Elem() +} + +type repositoryTopicsArgs struct { + // The repository name. + Repository string `pulumi:"repository"` + // A list of topics to add to the repository. + Topics []string `pulumi:"topics"` +} + +// The set of arguments for constructing a RepositoryTopics resource. +type RepositoryTopicsArgs struct { + // The repository name. + Repository pulumi.StringInput + // A list of topics to add to the repository. + Topics pulumi.StringArrayInput +} + +func (RepositoryTopicsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryTopicsArgs)(nil)).Elem() +} + +type RepositoryTopicsInput interface { + pulumi.Input + + ToRepositoryTopicsOutput() RepositoryTopicsOutput + ToRepositoryTopicsOutputWithContext(ctx context.Context) RepositoryTopicsOutput +} + +func (*RepositoryTopics) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryTopics)(nil)).Elem() +} + +func (i *RepositoryTopics) ToRepositoryTopicsOutput() RepositoryTopicsOutput { + return i.ToRepositoryTopicsOutputWithContext(context.Background()) +} + +func (i *RepositoryTopics) ToRepositoryTopicsOutputWithContext(ctx context.Context) RepositoryTopicsOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryTopicsOutput) +} + +// RepositoryTopicsArrayInput is an input type that accepts RepositoryTopicsArray and RepositoryTopicsArrayOutput values. +// You can construct a concrete instance of `RepositoryTopicsArrayInput` via: +// +// RepositoryTopicsArray{ RepositoryTopicsArgs{...} } +type RepositoryTopicsArrayInput interface { + pulumi.Input + + ToRepositoryTopicsArrayOutput() RepositoryTopicsArrayOutput + ToRepositoryTopicsArrayOutputWithContext(context.Context) RepositoryTopicsArrayOutput +} + +type RepositoryTopicsArray []RepositoryTopicsInput + +func (RepositoryTopicsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryTopics)(nil)).Elem() +} + +func (i RepositoryTopicsArray) ToRepositoryTopicsArrayOutput() RepositoryTopicsArrayOutput { + return i.ToRepositoryTopicsArrayOutputWithContext(context.Background()) +} + +func (i RepositoryTopicsArray) ToRepositoryTopicsArrayOutputWithContext(ctx context.Context) RepositoryTopicsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryTopicsArrayOutput) +} + +// RepositoryTopicsMapInput is an input type that accepts RepositoryTopicsMap and RepositoryTopicsMapOutput values. +// You can construct a concrete instance of `RepositoryTopicsMapInput` via: +// +// RepositoryTopicsMap{ "key": RepositoryTopicsArgs{...} } +type RepositoryTopicsMapInput interface { + pulumi.Input + + ToRepositoryTopicsMapOutput() RepositoryTopicsMapOutput + ToRepositoryTopicsMapOutputWithContext(context.Context) RepositoryTopicsMapOutput +} + +type RepositoryTopicsMap map[string]RepositoryTopicsInput + +func (RepositoryTopicsMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryTopics)(nil)).Elem() +} + +func (i RepositoryTopicsMap) ToRepositoryTopicsMapOutput() RepositoryTopicsMapOutput { + return i.ToRepositoryTopicsMapOutputWithContext(context.Background()) +} + +func (i RepositoryTopicsMap) ToRepositoryTopicsMapOutputWithContext(ctx context.Context) RepositoryTopicsMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryTopicsMapOutput) +} + +type RepositoryTopicsOutput struct{ *pulumi.OutputState } + +func (RepositoryTopicsOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryTopics)(nil)).Elem() +} + +func (o RepositoryTopicsOutput) ToRepositoryTopicsOutput() RepositoryTopicsOutput { + return o +} + +func (o RepositoryTopicsOutput) ToRepositoryTopicsOutputWithContext(ctx context.Context) RepositoryTopicsOutput { + return o +} + +// The repository name. +func (o RepositoryTopicsOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryTopics) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// A list of topics to add to the repository. +func (o RepositoryTopicsOutput) Topics() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RepositoryTopics) pulumi.StringArrayOutput { return v.Topics }).(pulumi.StringArrayOutput) +} + +type RepositoryTopicsArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryTopicsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryTopics)(nil)).Elem() +} + +func (o RepositoryTopicsArrayOutput) ToRepositoryTopicsArrayOutput() RepositoryTopicsArrayOutput { + return o +} + +func (o RepositoryTopicsArrayOutput) ToRepositoryTopicsArrayOutputWithContext(ctx context.Context) RepositoryTopicsArrayOutput { + return o +} + +func (o RepositoryTopicsArrayOutput) Index(i pulumi.IntInput) RepositoryTopicsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryTopics { + return vs[0].([]*RepositoryTopics)[vs[1].(int)] + }).(RepositoryTopicsOutput) +} + +type RepositoryTopicsMapOutput struct{ *pulumi.OutputState } + +func (RepositoryTopicsMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryTopics)(nil)).Elem() +} + +func (o RepositoryTopicsMapOutput) ToRepositoryTopicsMapOutput() RepositoryTopicsMapOutput { + return o +} + +func (o RepositoryTopicsMapOutput) ToRepositoryTopicsMapOutputWithContext(ctx context.Context) RepositoryTopicsMapOutput { + return o +} + +func (o RepositoryTopicsMapOutput) MapIndex(k pulumi.StringInput) RepositoryTopicsOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryTopics { + return vs[0].(map[string]*RepositoryTopics)[vs[1].(string)] + }).(RepositoryTopicsOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryTopicsInput)(nil)).Elem(), &RepositoryTopics{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryTopicsArrayInput)(nil)).Elem(), RepositoryTopicsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryTopicsMapInput)(nil)).Elem(), RepositoryTopicsMap{}) + pulumi.RegisterOutputType(RepositoryTopicsOutput{}) + pulumi.RegisterOutputType(RepositoryTopicsArrayOutput{}) + pulumi.RegisterOutputType(RepositoryTopicsMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryVulnerabilityAlerts.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryVulnerabilityAlerts.go new file mode 100644 index 000000000..5b92ccc02 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryVulnerabilityAlerts.go @@ -0,0 +1,290 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to manage vulnerability alerts for a GitHub repository. See the +// [documentation](https://docs.github.com/en/code-security/dependabot/dependabot-alerts/about-dependabot-alerts) +// for details of usage and how this will impact your repository. +// +// ## Example Usage +// +// ```go +// 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-repo"), +// Description: pulumi.String("GitHub repo managed by Terraform"), +// Visibility: pulumi.String("private"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryVulnerabilityAlerts(ctx, "example", &github.RepositoryVulnerabilityAlertsArgs{ +// Repository: example.Name, +// Enabled: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// Repository vulnerability alerts can be imported using the `repositoryName`: +// +// ```sh +// $ pulumi import github:index/repositoryVulnerabilityAlerts:RepositoryVulnerabilityAlerts example my-repo +// ``` +type RepositoryVulnerabilityAlerts struct { + pulumi.CustomResourceState + + // Whether vulnerability alerts are enabled for the repository. Defaults to `true`. + Enabled pulumi.BoolPtrOutput `pulumi:"enabled"` + // The name of the repository to configure vulnerability alerts for. + Repository pulumi.StringOutput `pulumi:"repository"` + // The ID of the repository. + RepositoryId pulumi.IntOutput `pulumi:"repositoryId"` +} + +// NewRepositoryVulnerabilityAlerts registers a new resource with the given unique name, arguments, and options. +func NewRepositoryVulnerabilityAlerts(ctx *pulumi.Context, + name string, args *RepositoryVulnerabilityAlertsArgs, opts ...pulumi.ResourceOption) (*RepositoryVulnerabilityAlerts, 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'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryVulnerabilityAlerts + err := ctx.RegisterResource("github:index/repositoryVulnerabilityAlerts:RepositoryVulnerabilityAlerts", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryVulnerabilityAlerts gets an existing RepositoryVulnerabilityAlerts 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 GetRepositoryVulnerabilityAlerts(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryVulnerabilityAlertsState, opts ...pulumi.ResourceOption) (*RepositoryVulnerabilityAlerts, error) { + var resource RepositoryVulnerabilityAlerts + err := ctx.ReadResource("github:index/repositoryVulnerabilityAlerts:RepositoryVulnerabilityAlerts", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryVulnerabilityAlerts resources. +type repositoryVulnerabilityAlertsState struct { + // Whether vulnerability alerts are enabled for the repository. Defaults to `true`. + Enabled *bool `pulumi:"enabled"` + // The name of the repository to configure vulnerability alerts for. + Repository *string `pulumi:"repository"` + // The ID of the repository. + RepositoryId *int `pulumi:"repositoryId"` +} + +type RepositoryVulnerabilityAlertsState struct { + // Whether vulnerability alerts are enabled for the repository. Defaults to `true`. + Enabled pulumi.BoolPtrInput + // The name of the repository to configure vulnerability alerts for. + Repository pulumi.StringPtrInput + // The ID of the repository. + RepositoryId pulumi.IntPtrInput +} + +func (RepositoryVulnerabilityAlertsState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryVulnerabilityAlertsState)(nil)).Elem() +} + +type repositoryVulnerabilityAlertsArgs struct { + // Whether vulnerability alerts are enabled for the repository. Defaults to `true`. + Enabled *bool `pulumi:"enabled"` + // The name of the repository to configure vulnerability alerts for. + Repository string `pulumi:"repository"` +} + +// The set of arguments for constructing a RepositoryVulnerabilityAlerts resource. +type RepositoryVulnerabilityAlertsArgs struct { + // Whether vulnerability alerts are enabled for the repository. Defaults to `true`. + Enabled pulumi.BoolPtrInput + // The name of the repository to configure vulnerability alerts for. + Repository pulumi.StringInput +} + +func (RepositoryVulnerabilityAlertsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryVulnerabilityAlertsArgs)(nil)).Elem() +} + +type RepositoryVulnerabilityAlertsInput interface { + pulumi.Input + + ToRepositoryVulnerabilityAlertsOutput() RepositoryVulnerabilityAlertsOutput + ToRepositoryVulnerabilityAlertsOutputWithContext(ctx context.Context) RepositoryVulnerabilityAlertsOutput +} + +func (*RepositoryVulnerabilityAlerts) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryVulnerabilityAlerts)(nil)).Elem() +} + +func (i *RepositoryVulnerabilityAlerts) ToRepositoryVulnerabilityAlertsOutput() RepositoryVulnerabilityAlertsOutput { + return i.ToRepositoryVulnerabilityAlertsOutputWithContext(context.Background()) +} + +func (i *RepositoryVulnerabilityAlerts) ToRepositoryVulnerabilityAlertsOutputWithContext(ctx context.Context) RepositoryVulnerabilityAlertsOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryVulnerabilityAlertsOutput) +} + +// RepositoryVulnerabilityAlertsArrayInput is an input type that accepts RepositoryVulnerabilityAlertsArray and RepositoryVulnerabilityAlertsArrayOutput values. +// You can construct a concrete instance of `RepositoryVulnerabilityAlertsArrayInput` via: +// +// RepositoryVulnerabilityAlertsArray{ RepositoryVulnerabilityAlertsArgs{...} } +type RepositoryVulnerabilityAlertsArrayInput interface { + pulumi.Input + + ToRepositoryVulnerabilityAlertsArrayOutput() RepositoryVulnerabilityAlertsArrayOutput + ToRepositoryVulnerabilityAlertsArrayOutputWithContext(context.Context) RepositoryVulnerabilityAlertsArrayOutput +} + +type RepositoryVulnerabilityAlertsArray []RepositoryVulnerabilityAlertsInput + +func (RepositoryVulnerabilityAlertsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryVulnerabilityAlerts)(nil)).Elem() +} + +func (i RepositoryVulnerabilityAlertsArray) ToRepositoryVulnerabilityAlertsArrayOutput() RepositoryVulnerabilityAlertsArrayOutput { + return i.ToRepositoryVulnerabilityAlertsArrayOutputWithContext(context.Background()) +} + +func (i RepositoryVulnerabilityAlertsArray) ToRepositoryVulnerabilityAlertsArrayOutputWithContext(ctx context.Context) RepositoryVulnerabilityAlertsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryVulnerabilityAlertsArrayOutput) +} + +// RepositoryVulnerabilityAlertsMapInput is an input type that accepts RepositoryVulnerabilityAlertsMap and RepositoryVulnerabilityAlertsMapOutput values. +// You can construct a concrete instance of `RepositoryVulnerabilityAlertsMapInput` via: +// +// RepositoryVulnerabilityAlertsMap{ "key": RepositoryVulnerabilityAlertsArgs{...} } +type RepositoryVulnerabilityAlertsMapInput interface { + pulumi.Input + + ToRepositoryVulnerabilityAlertsMapOutput() RepositoryVulnerabilityAlertsMapOutput + ToRepositoryVulnerabilityAlertsMapOutputWithContext(context.Context) RepositoryVulnerabilityAlertsMapOutput +} + +type RepositoryVulnerabilityAlertsMap map[string]RepositoryVulnerabilityAlertsInput + +func (RepositoryVulnerabilityAlertsMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryVulnerabilityAlerts)(nil)).Elem() +} + +func (i RepositoryVulnerabilityAlertsMap) ToRepositoryVulnerabilityAlertsMapOutput() RepositoryVulnerabilityAlertsMapOutput { + return i.ToRepositoryVulnerabilityAlertsMapOutputWithContext(context.Background()) +} + +func (i RepositoryVulnerabilityAlertsMap) ToRepositoryVulnerabilityAlertsMapOutputWithContext(ctx context.Context) RepositoryVulnerabilityAlertsMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryVulnerabilityAlertsMapOutput) +} + +type RepositoryVulnerabilityAlertsOutput struct{ *pulumi.OutputState } + +func (RepositoryVulnerabilityAlertsOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryVulnerabilityAlerts)(nil)).Elem() +} + +func (o RepositoryVulnerabilityAlertsOutput) ToRepositoryVulnerabilityAlertsOutput() RepositoryVulnerabilityAlertsOutput { + return o +} + +func (o RepositoryVulnerabilityAlertsOutput) ToRepositoryVulnerabilityAlertsOutputWithContext(ctx context.Context) RepositoryVulnerabilityAlertsOutput { + return o +} + +// Whether vulnerability alerts are enabled for the repository. Defaults to `true`. +func (o RepositoryVulnerabilityAlertsOutput) Enabled() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryVulnerabilityAlerts) pulumi.BoolPtrOutput { return v.Enabled }).(pulumi.BoolPtrOutput) +} + +// The name of the repository to configure vulnerability alerts for. +func (o RepositoryVulnerabilityAlertsOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryVulnerabilityAlerts) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// The ID of the repository. +func (o RepositoryVulnerabilityAlertsOutput) RepositoryId() pulumi.IntOutput { + return o.ApplyT(func(v *RepositoryVulnerabilityAlerts) pulumi.IntOutput { return v.RepositoryId }).(pulumi.IntOutput) +} + +type RepositoryVulnerabilityAlertsArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryVulnerabilityAlertsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryVulnerabilityAlerts)(nil)).Elem() +} + +func (o RepositoryVulnerabilityAlertsArrayOutput) ToRepositoryVulnerabilityAlertsArrayOutput() RepositoryVulnerabilityAlertsArrayOutput { + return o +} + +func (o RepositoryVulnerabilityAlertsArrayOutput) ToRepositoryVulnerabilityAlertsArrayOutputWithContext(ctx context.Context) RepositoryVulnerabilityAlertsArrayOutput { + return o +} + +func (o RepositoryVulnerabilityAlertsArrayOutput) Index(i pulumi.IntInput) RepositoryVulnerabilityAlertsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryVulnerabilityAlerts { + return vs[0].([]*RepositoryVulnerabilityAlerts)[vs[1].(int)] + }).(RepositoryVulnerabilityAlertsOutput) +} + +type RepositoryVulnerabilityAlertsMapOutput struct{ *pulumi.OutputState } + +func (RepositoryVulnerabilityAlertsMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryVulnerabilityAlerts)(nil)).Elem() +} + +func (o RepositoryVulnerabilityAlertsMapOutput) ToRepositoryVulnerabilityAlertsMapOutput() RepositoryVulnerabilityAlertsMapOutput { + return o +} + +func (o RepositoryVulnerabilityAlertsMapOutput) ToRepositoryVulnerabilityAlertsMapOutputWithContext(ctx context.Context) RepositoryVulnerabilityAlertsMapOutput { + return o +} + +func (o RepositoryVulnerabilityAlertsMapOutput) MapIndex(k pulumi.StringInput) RepositoryVulnerabilityAlertsOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryVulnerabilityAlerts { + return vs[0].(map[string]*RepositoryVulnerabilityAlerts)[vs[1].(string)] + }).(RepositoryVulnerabilityAlertsOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryVulnerabilityAlertsInput)(nil)).Elem(), &RepositoryVulnerabilityAlerts{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryVulnerabilityAlertsArrayInput)(nil)).Elem(), RepositoryVulnerabilityAlertsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryVulnerabilityAlertsMapInput)(nil)).Elem(), RepositoryVulnerabilityAlertsMap{}) + pulumi.RegisterOutputType(RepositoryVulnerabilityAlertsOutput{}) + pulumi.RegisterOutputType(RepositoryVulnerabilityAlertsArrayOutput{}) + pulumi.RegisterOutputType(RepositoryVulnerabilityAlertsMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryWebhook.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryWebhook.go new file mode 100644 index 000000000..50ea49c9a --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/repositoryWebhook.go @@ -0,0 +1,347 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage webhooks for repositories within your +// GitHub organization or personal account. +// +// > **Note on Archived Repositories**: When a repository is archived, GitHub makes it read-only, preventing webhook modifications. If you attempt to destroy resources associated with archived repositories, the provider will gracefully handle the operation by logging an informational message and removing the resource from Terraform state without attempting to modify the archived repository. +// +// ## Example Usage +// +// ```go +// 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 { +// repo, err := github.NewRepository(ctx, "repo", &github.RepositoryArgs{ +// Name: pulumi.String("foo"), +// Description: pulumi.String("Terraform acceptance tests"), +// HomepageUrl: pulumi.String("http://example.com/"), +// Visibility: pulumi.String("public"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewRepositoryWebhook(ctx, "foo", &github.RepositoryWebhookArgs{ +// Repository: repo.Name, +// Configuration: &github.RepositoryWebhookConfigurationArgs{ +// Url: pulumi.String("https://google.de/"), +// ContentType: pulumi.String("form"), +// InsecureSsl: pulumi.Bool(false), +// }, +// Active: pulumi.Bool(false), +// Events: pulumi.StringArray{ +// pulumi.String("issues"), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// Repository webhooks can be imported using the `name` of the repository, combined with the `id` of the webhook, separated by a `/` character. +// The `id` of the webhook can be found in the URL of the webhook. For example: `"https://github.com/foo-org/foo-repo/settings/hooks/14711452"`. +// +// Importing uses the name of the repository, as well as the ID of the webhook, e.g. +// +// ```sh +// $ pulumi import github:index/repositoryWebhook:RepositoryWebhook terraform terraform/11235813 +// ``` +// +// If secret is populated in the webhook's configuration, the value will be imported as "********". +type RepositoryWebhook struct { + pulumi.CustomResourceState + + // Indicate if the webhook should receive events. Defaults to `true`. + Active pulumi.BoolPtrOutput `pulumi:"active"` + // Configuration block for the webhook. Detailed below. + Configuration RepositoryWebhookConfigurationPtrOutput `pulumi:"configuration"` + Etag pulumi.StringOutput `pulumi:"etag"` + // A list of events which should trigger the webhook. See a list of [available events](https://developer.github.com/v3/activity/events/types/). + Events pulumi.StringArrayOutput `pulumi:"events"` + // The repository of the webhook. + Repository pulumi.StringOutput `pulumi:"repository"` + // URL of the webhook. This is a sensitive attribute because it may include basic auth credentials. + Url pulumi.StringOutput `pulumi:"url"` +} + +// NewRepositoryWebhook registers a new resource with the given unique name, arguments, and options. +func NewRepositoryWebhook(ctx *pulumi.Context, + name string, args *RepositoryWebhookArgs, opts ...pulumi.ResourceOption) (*RepositoryWebhook, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Events == nil { + return nil, errors.New("invalid value for required argument 'Events'") + } + if args.Repository == nil { + return nil, errors.New("invalid value for required argument 'Repository'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource RepositoryWebhook + err := ctx.RegisterResource("github:index/repositoryWebhook:RepositoryWebhook", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetRepositoryWebhook gets an existing RepositoryWebhook 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 GetRepositoryWebhook(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *RepositoryWebhookState, opts ...pulumi.ResourceOption) (*RepositoryWebhook, error) { + var resource RepositoryWebhook + err := ctx.ReadResource("github:index/repositoryWebhook:RepositoryWebhook", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering RepositoryWebhook resources. +type repositoryWebhookState struct { + // Indicate if the webhook should receive events. Defaults to `true`. + Active *bool `pulumi:"active"` + // Configuration block for the webhook. Detailed below. + Configuration *RepositoryWebhookConfiguration `pulumi:"configuration"` + Etag *string `pulumi:"etag"` + // A list of events which should trigger the webhook. See a list of [available events](https://developer.github.com/v3/activity/events/types/). + Events []string `pulumi:"events"` + // The repository of the webhook. + Repository *string `pulumi:"repository"` + // URL of the webhook. This is a sensitive attribute because it may include basic auth credentials. + Url *string `pulumi:"url"` +} + +type RepositoryWebhookState struct { + // Indicate if the webhook should receive events. Defaults to `true`. + Active pulumi.BoolPtrInput + // Configuration block for the webhook. Detailed below. + Configuration RepositoryWebhookConfigurationPtrInput + Etag pulumi.StringPtrInput + // A list of events which should trigger the webhook. See a list of [available events](https://developer.github.com/v3/activity/events/types/). + Events pulumi.StringArrayInput + // The repository of the webhook. + Repository pulumi.StringPtrInput + // URL of the webhook. This is a sensitive attribute because it may include basic auth credentials. + Url pulumi.StringPtrInput +} + +func (RepositoryWebhookState) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryWebhookState)(nil)).Elem() +} + +type repositoryWebhookArgs struct { + // Indicate if the webhook should receive events. Defaults to `true`. + Active *bool `pulumi:"active"` + // Configuration block for the webhook. Detailed below. + Configuration *RepositoryWebhookConfiguration `pulumi:"configuration"` + Etag *string `pulumi:"etag"` + // A list of events which should trigger the webhook. See a list of [available events](https://developer.github.com/v3/activity/events/types/). + Events []string `pulumi:"events"` + // The repository of the webhook. + Repository string `pulumi:"repository"` +} + +// The set of arguments for constructing a RepositoryWebhook resource. +type RepositoryWebhookArgs struct { + // Indicate if the webhook should receive events. Defaults to `true`. + Active pulumi.BoolPtrInput + // Configuration block for the webhook. Detailed below. + Configuration RepositoryWebhookConfigurationPtrInput + Etag pulumi.StringPtrInput + // A list of events which should trigger the webhook. See a list of [available events](https://developer.github.com/v3/activity/events/types/). + Events pulumi.StringArrayInput + // The repository of the webhook. + Repository pulumi.StringInput +} + +func (RepositoryWebhookArgs) ElementType() reflect.Type { + return reflect.TypeOf((*repositoryWebhookArgs)(nil)).Elem() +} + +type RepositoryWebhookInput interface { + pulumi.Input + + ToRepositoryWebhookOutput() RepositoryWebhookOutput + ToRepositoryWebhookOutputWithContext(ctx context.Context) RepositoryWebhookOutput +} + +func (*RepositoryWebhook) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryWebhook)(nil)).Elem() +} + +func (i *RepositoryWebhook) ToRepositoryWebhookOutput() RepositoryWebhookOutput { + return i.ToRepositoryWebhookOutputWithContext(context.Background()) +} + +func (i *RepositoryWebhook) ToRepositoryWebhookOutputWithContext(ctx context.Context) RepositoryWebhookOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryWebhookOutput) +} + +// RepositoryWebhookArrayInput is an input type that accepts RepositoryWebhookArray and RepositoryWebhookArrayOutput values. +// You can construct a concrete instance of `RepositoryWebhookArrayInput` via: +// +// RepositoryWebhookArray{ RepositoryWebhookArgs{...} } +type RepositoryWebhookArrayInput interface { + pulumi.Input + + ToRepositoryWebhookArrayOutput() RepositoryWebhookArrayOutput + ToRepositoryWebhookArrayOutputWithContext(context.Context) RepositoryWebhookArrayOutput +} + +type RepositoryWebhookArray []RepositoryWebhookInput + +func (RepositoryWebhookArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryWebhook)(nil)).Elem() +} + +func (i RepositoryWebhookArray) ToRepositoryWebhookArrayOutput() RepositoryWebhookArrayOutput { + return i.ToRepositoryWebhookArrayOutputWithContext(context.Background()) +} + +func (i RepositoryWebhookArray) ToRepositoryWebhookArrayOutputWithContext(ctx context.Context) RepositoryWebhookArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryWebhookArrayOutput) +} + +// RepositoryWebhookMapInput is an input type that accepts RepositoryWebhookMap and RepositoryWebhookMapOutput values. +// You can construct a concrete instance of `RepositoryWebhookMapInput` via: +// +// RepositoryWebhookMap{ "key": RepositoryWebhookArgs{...} } +type RepositoryWebhookMapInput interface { + pulumi.Input + + ToRepositoryWebhookMapOutput() RepositoryWebhookMapOutput + ToRepositoryWebhookMapOutputWithContext(context.Context) RepositoryWebhookMapOutput +} + +type RepositoryWebhookMap map[string]RepositoryWebhookInput + +func (RepositoryWebhookMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryWebhook)(nil)).Elem() +} + +func (i RepositoryWebhookMap) ToRepositoryWebhookMapOutput() RepositoryWebhookMapOutput { + return i.ToRepositoryWebhookMapOutputWithContext(context.Background()) +} + +func (i RepositoryWebhookMap) ToRepositoryWebhookMapOutputWithContext(ctx context.Context) RepositoryWebhookMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(RepositoryWebhookMapOutput) +} + +type RepositoryWebhookOutput struct{ *pulumi.OutputState } + +func (RepositoryWebhookOutput) ElementType() reflect.Type { + return reflect.TypeOf((**RepositoryWebhook)(nil)).Elem() +} + +func (o RepositoryWebhookOutput) ToRepositoryWebhookOutput() RepositoryWebhookOutput { + return o +} + +func (o RepositoryWebhookOutput) ToRepositoryWebhookOutputWithContext(ctx context.Context) RepositoryWebhookOutput { + return o +} + +// Indicate if the webhook should receive events. Defaults to `true`. +func (o RepositoryWebhookOutput) Active() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *RepositoryWebhook) pulumi.BoolPtrOutput { return v.Active }).(pulumi.BoolPtrOutput) +} + +// Configuration block for the webhook. Detailed below. +func (o RepositoryWebhookOutput) Configuration() RepositoryWebhookConfigurationPtrOutput { + return o.ApplyT(func(v *RepositoryWebhook) RepositoryWebhookConfigurationPtrOutput { return v.Configuration }).(RepositoryWebhookConfigurationPtrOutput) +} + +func (o RepositoryWebhookOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryWebhook) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// A list of events which should trigger the webhook. See a list of [available events](https://developer.github.com/v3/activity/events/types/). +func (o RepositoryWebhookOutput) Events() pulumi.StringArrayOutput { + return o.ApplyT(func(v *RepositoryWebhook) pulumi.StringArrayOutput { return v.Events }).(pulumi.StringArrayOutput) +} + +// The repository of the webhook. +func (o RepositoryWebhookOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryWebhook) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// URL of the webhook. This is a sensitive attribute because it may include basic auth credentials. +func (o RepositoryWebhookOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v *RepositoryWebhook) pulumi.StringOutput { return v.Url }).(pulumi.StringOutput) +} + +type RepositoryWebhookArrayOutput struct{ *pulumi.OutputState } + +func (RepositoryWebhookArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*RepositoryWebhook)(nil)).Elem() +} + +func (o RepositoryWebhookArrayOutput) ToRepositoryWebhookArrayOutput() RepositoryWebhookArrayOutput { + return o +} + +func (o RepositoryWebhookArrayOutput) ToRepositoryWebhookArrayOutputWithContext(ctx context.Context) RepositoryWebhookArrayOutput { + return o +} + +func (o RepositoryWebhookArrayOutput) Index(i pulumi.IntInput) RepositoryWebhookOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *RepositoryWebhook { + return vs[0].([]*RepositoryWebhook)[vs[1].(int)] + }).(RepositoryWebhookOutput) +} + +type RepositoryWebhookMapOutput struct{ *pulumi.OutputState } + +func (RepositoryWebhookMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*RepositoryWebhook)(nil)).Elem() +} + +func (o RepositoryWebhookMapOutput) ToRepositoryWebhookMapOutput() RepositoryWebhookMapOutput { + return o +} + +func (o RepositoryWebhookMapOutput) ToRepositoryWebhookMapOutputWithContext(ctx context.Context) RepositoryWebhookMapOutput { + return o +} + +func (o RepositoryWebhookMapOutput) MapIndex(k pulumi.StringInput) RepositoryWebhookOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *RepositoryWebhook { + return vs[0].(map[string]*RepositoryWebhook)[vs[1].(string)] + }).(RepositoryWebhookOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryWebhookInput)(nil)).Elem(), &RepositoryWebhook{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryWebhookArrayInput)(nil)).Elem(), RepositoryWebhookArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*RepositoryWebhookMapInput)(nil)).Elem(), RepositoryWebhookMap{}) + pulumi.RegisterOutputType(RepositoryWebhookOutput{}) + pulumi.RegisterOutputType(RepositoryWebhookArrayOutput{}) + pulumi.RegisterOutputType(RepositoryWebhookMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/team.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/team.go new file mode 100644 index 000000000..3f63bc052 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/team.go @@ -0,0 +1,432 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Provides a GitHub team resource. +// +// This resource allows you to add/remove teams from your organization. When applied, +// a new team will be created. When destroyed, that team will be removed. +// +// ## Example Usage +// +// ```go +// 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 team to the organization +// _, err := github.NewTeam(ctx, "some_team", &github.TeamArgs{ +// Name: pulumi.String("some-team"), +// Description: pulumi.String("Some cool team"), +// Privacy: pulumi.String("closed"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Teams can be imported using the GitHub team ID or name e.g. +// +// ```sh +// $ pulumi import github:index/team:Team core 1234567 +// $ pulumi import github:index/team:Team core Administrators +// ``` +type Team struct { + pulumi.CustomResourceState + + // (Optional) Adds a default maintainer to the team. Defaults to `false` and adds the creating user to the team when `true`. + // + // Deprecated: Use TeamMembership or TeamMembers resource to manage team memberships explicitly. + CreateDefaultMaintainer pulumi.BoolPtrOutput `pulumi:"createDefaultMaintainer"` + // A description of the team. + Description pulumi.StringPtrOutput `pulumi:"description"` + Etag pulumi.StringOutput `pulumi:"etag"` + // The LDAP Distinguished Name of the group where membership will be synchronized. Only available in GitHub Enterprise Server. + LdapDn pulumi.StringPtrOutput `pulumi:"ldapDn"` + MembersCount pulumi.IntOutput `pulumi:"membersCount"` + // The name of the team. + Name pulumi.StringOutput `pulumi:"name"` + // The Node ID of the created team. + NodeId pulumi.StringOutput `pulumi:"nodeId"` + // The notification setting for the team. Must be one of `notificationsEnabled` _(default)_ or `notificationsDisabled`. + NotificationSetting pulumi.StringPtrOutput `pulumi:"notificationSetting"` + // The ID or slug of the parent team, if this is a nested team. + ParentTeamId pulumi.StringPtrOutput `pulumi:"parentTeamId"` + // The id of the parent team read in Github. + ParentTeamReadId pulumi.StringOutput `pulumi:"parentTeamReadId"` + // The id of the parent team read in Github. + ParentTeamReadSlug pulumi.StringOutput `pulumi:"parentTeamReadSlug"` + // The level of privacy for the team. Must be one of `secret` _(default)_ or `closed`. + Privacy pulumi.StringPtrOutput `pulumi:"privacy"` + // The slug of the created team, which may or may not differ from `name`, + // depending on whether `name` contains "URL-unsafe" characters. + // Useful when referencing the team in [`BranchProtection`](https://www.terraform.io/docs/providers/github/r/branch_protection.html). + Slug pulumi.StringOutput `pulumi:"slug"` +} + +// NewTeam registers a new resource with the given unique name, arguments, and options. +func NewTeam(ctx *pulumi.Context, + name string, args *TeamArgs, opts ...pulumi.ResourceOption) (*Team, error) { + if args == nil { + args = &TeamArgs{} + } + + opts = internal.PkgResourceDefaultOpts(opts) + var resource Team + err := ctx.RegisterResource("github:index/team:Team", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetTeam gets an existing Team 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 GetTeam(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *TeamState, opts ...pulumi.ResourceOption) (*Team, error) { + var resource Team + err := ctx.ReadResource("github:index/team:Team", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering Team resources. +type teamState struct { + // (Optional) Adds a default maintainer to the team. Defaults to `false` and adds the creating user to the team when `true`. + // + // Deprecated: Use TeamMembership or TeamMembers resource to manage team memberships explicitly. + CreateDefaultMaintainer *bool `pulumi:"createDefaultMaintainer"` + // A description of the team. + Description *string `pulumi:"description"` + Etag *string `pulumi:"etag"` + // The LDAP Distinguished Name of the group where membership will be synchronized. Only available in GitHub Enterprise Server. + LdapDn *string `pulumi:"ldapDn"` + MembersCount *int `pulumi:"membersCount"` + // The name of the team. + Name *string `pulumi:"name"` + // The Node ID of the created team. + NodeId *string `pulumi:"nodeId"` + // The notification setting for the team. Must be one of `notificationsEnabled` _(default)_ or `notificationsDisabled`. + NotificationSetting *string `pulumi:"notificationSetting"` + // The ID or slug of the parent team, if this is a nested team. + ParentTeamId *string `pulumi:"parentTeamId"` + // The id of the parent team read in Github. + ParentTeamReadId *string `pulumi:"parentTeamReadId"` + // The id of the parent team read in Github. + ParentTeamReadSlug *string `pulumi:"parentTeamReadSlug"` + // The level of privacy for the team. Must be one of `secret` _(default)_ or `closed`. + Privacy *string `pulumi:"privacy"` + // The slug of the created team, which may or may not differ from `name`, + // depending on whether `name` contains "URL-unsafe" characters. + // Useful when referencing the team in [`BranchProtection`](https://www.terraform.io/docs/providers/github/r/branch_protection.html). + Slug *string `pulumi:"slug"` +} + +type TeamState struct { + // (Optional) Adds a default maintainer to the team. Defaults to `false` and adds the creating user to the team when `true`. + // + // Deprecated: Use TeamMembership or TeamMembers resource to manage team memberships explicitly. + CreateDefaultMaintainer pulumi.BoolPtrInput + // A description of the team. + Description pulumi.StringPtrInput + Etag pulumi.StringPtrInput + // The LDAP Distinguished Name of the group where membership will be synchronized. Only available in GitHub Enterprise Server. + LdapDn pulumi.StringPtrInput + MembersCount pulumi.IntPtrInput + // The name of the team. + Name pulumi.StringPtrInput + // The Node ID of the created team. + NodeId pulumi.StringPtrInput + // The notification setting for the team. Must be one of `notificationsEnabled` _(default)_ or `notificationsDisabled`. + NotificationSetting pulumi.StringPtrInput + // The ID or slug of the parent team, if this is a nested team. + ParentTeamId pulumi.StringPtrInput + // The id of the parent team read in Github. + ParentTeamReadId pulumi.StringPtrInput + // The id of the parent team read in Github. + ParentTeamReadSlug pulumi.StringPtrInput + // The level of privacy for the team. Must be one of `secret` _(default)_ or `closed`. + Privacy pulumi.StringPtrInput + // The slug of the created team, which may or may not differ from `name`, + // depending on whether `name` contains "URL-unsafe" characters. + // Useful when referencing the team in [`BranchProtection`](https://www.terraform.io/docs/providers/github/r/branch_protection.html). + Slug pulumi.StringPtrInput +} + +func (TeamState) ElementType() reflect.Type { + return reflect.TypeOf((*teamState)(nil)).Elem() +} + +type teamArgs struct { + // (Optional) Adds a default maintainer to the team. Defaults to `false` and adds the creating user to the team when `true`. + // + // Deprecated: Use TeamMembership or TeamMembers resource to manage team memberships explicitly. + CreateDefaultMaintainer *bool `pulumi:"createDefaultMaintainer"` + // A description of the team. + Description *string `pulumi:"description"` + // The LDAP Distinguished Name of the group where membership will be synchronized. Only available in GitHub Enterprise Server. + LdapDn *string `pulumi:"ldapDn"` + // The name of the team. + Name *string `pulumi:"name"` + // The notification setting for the team. Must be one of `notificationsEnabled` _(default)_ or `notificationsDisabled`. + NotificationSetting *string `pulumi:"notificationSetting"` + // The ID or slug of the parent team, if this is a nested team. + ParentTeamId *string `pulumi:"parentTeamId"` + // The id of the parent team read in Github. + ParentTeamReadId *string `pulumi:"parentTeamReadId"` + // The id of the parent team read in Github. + ParentTeamReadSlug *string `pulumi:"parentTeamReadSlug"` + // The level of privacy for the team. Must be one of `secret` _(default)_ or `closed`. + Privacy *string `pulumi:"privacy"` +} + +// The set of arguments for constructing a Team resource. +type TeamArgs struct { + // (Optional) Adds a default maintainer to the team. Defaults to `false` and adds the creating user to the team when `true`. + // + // Deprecated: Use TeamMembership or TeamMembers resource to manage team memberships explicitly. + CreateDefaultMaintainer pulumi.BoolPtrInput + // A description of the team. + Description pulumi.StringPtrInput + // The LDAP Distinguished Name of the group where membership will be synchronized. Only available in GitHub Enterprise Server. + LdapDn pulumi.StringPtrInput + // The name of the team. + Name pulumi.StringPtrInput + // The notification setting for the team. Must be one of `notificationsEnabled` _(default)_ or `notificationsDisabled`. + NotificationSetting pulumi.StringPtrInput + // The ID or slug of the parent team, if this is a nested team. + ParentTeamId pulumi.StringPtrInput + // The id of the parent team read in Github. + ParentTeamReadId pulumi.StringPtrInput + // The id of the parent team read in Github. + ParentTeamReadSlug pulumi.StringPtrInput + // The level of privacy for the team. Must be one of `secret` _(default)_ or `closed`. + Privacy pulumi.StringPtrInput +} + +func (TeamArgs) ElementType() reflect.Type { + return reflect.TypeOf((*teamArgs)(nil)).Elem() +} + +type TeamInput interface { + pulumi.Input + + ToTeamOutput() TeamOutput + ToTeamOutputWithContext(ctx context.Context) TeamOutput +} + +func (*Team) ElementType() reflect.Type { + return reflect.TypeOf((**Team)(nil)).Elem() +} + +func (i *Team) ToTeamOutput() TeamOutput { + return i.ToTeamOutputWithContext(context.Background()) +} + +func (i *Team) ToTeamOutputWithContext(ctx context.Context) TeamOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamOutput) +} + +// TeamArrayInput is an input type that accepts TeamArray and TeamArrayOutput values. +// You can construct a concrete instance of `TeamArrayInput` via: +// +// TeamArray{ TeamArgs{...} } +type TeamArrayInput interface { + pulumi.Input + + ToTeamArrayOutput() TeamArrayOutput + ToTeamArrayOutputWithContext(context.Context) TeamArrayOutput +} + +type TeamArray []TeamInput + +func (TeamArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Team)(nil)).Elem() +} + +func (i TeamArray) ToTeamArrayOutput() TeamArrayOutput { + return i.ToTeamArrayOutputWithContext(context.Background()) +} + +func (i TeamArray) ToTeamArrayOutputWithContext(ctx context.Context) TeamArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamArrayOutput) +} + +// TeamMapInput is an input type that accepts TeamMap and TeamMapOutput values. +// You can construct a concrete instance of `TeamMapInput` via: +// +// TeamMap{ "key": TeamArgs{...} } +type TeamMapInput interface { + pulumi.Input + + ToTeamMapOutput() TeamMapOutput + ToTeamMapOutputWithContext(context.Context) TeamMapOutput +} + +type TeamMap map[string]TeamInput + +func (TeamMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Team)(nil)).Elem() +} + +func (i TeamMap) ToTeamMapOutput() TeamMapOutput { + return i.ToTeamMapOutputWithContext(context.Background()) +} + +func (i TeamMap) ToTeamMapOutputWithContext(ctx context.Context) TeamMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamMapOutput) +} + +type TeamOutput struct{ *pulumi.OutputState } + +func (TeamOutput) ElementType() reflect.Type { + return reflect.TypeOf((**Team)(nil)).Elem() +} + +func (o TeamOutput) ToTeamOutput() TeamOutput { + return o +} + +func (o TeamOutput) ToTeamOutputWithContext(ctx context.Context) TeamOutput { + return o +} + +// (Optional) Adds a default maintainer to the team. Defaults to `false` and adds the creating user to the team when `true`. +// +// Deprecated: Use TeamMembership or TeamMembers resource to manage team memberships explicitly. +func (o TeamOutput) CreateDefaultMaintainer() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *Team) pulumi.BoolPtrOutput { return v.CreateDefaultMaintainer }).(pulumi.BoolPtrOutput) +} + +// A description of the team. +func (o TeamOutput) Description() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Team) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput) +} + +func (o TeamOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *Team) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// The LDAP Distinguished Name of the group where membership will be synchronized. Only available in GitHub Enterprise Server. +func (o TeamOutput) LdapDn() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Team) pulumi.StringPtrOutput { return v.LdapDn }).(pulumi.StringPtrOutput) +} + +func (o TeamOutput) MembersCount() pulumi.IntOutput { + return o.ApplyT(func(v *Team) pulumi.IntOutput { return v.MembersCount }).(pulumi.IntOutput) +} + +// The name of the team. +func (o TeamOutput) Name() pulumi.StringOutput { + return o.ApplyT(func(v *Team) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput) +} + +// The Node ID of the created team. +func (o TeamOutput) NodeId() pulumi.StringOutput { + return o.ApplyT(func(v *Team) pulumi.StringOutput { return v.NodeId }).(pulumi.StringOutput) +} + +// The notification setting for the team. Must be one of `notificationsEnabled` _(default)_ or `notificationsDisabled`. +func (o TeamOutput) NotificationSetting() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Team) pulumi.StringPtrOutput { return v.NotificationSetting }).(pulumi.StringPtrOutput) +} + +// The ID or slug of the parent team, if this is a nested team. +func (o TeamOutput) ParentTeamId() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Team) pulumi.StringPtrOutput { return v.ParentTeamId }).(pulumi.StringPtrOutput) +} + +// The id of the parent team read in Github. +func (o TeamOutput) ParentTeamReadId() pulumi.StringOutput { + return o.ApplyT(func(v *Team) pulumi.StringOutput { return v.ParentTeamReadId }).(pulumi.StringOutput) +} + +// The id of the parent team read in Github. +func (o TeamOutput) ParentTeamReadSlug() pulumi.StringOutput { + return o.ApplyT(func(v *Team) pulumi.StringOutput { return v.ParentTeamReadSlug }).(pulumi.StringOutput) +} + +// The level of privacy for the team. Must be one of `secret` _(default)_ or `closed`. +func (o TeamOutput) Privacy() pulumi.StringPtrOutput { + return o.ApplyT(func(v *Team) pulumi.StringPtrOutput { return v.Privacy }).(pulumi.StringPtrOutput) +} + +// The slug of the created team, which may or may not differ from `name`, +// depending on whether `name` contains "URL-unsafe" characters. +// Useful when referencing the team in [`BranchProtection`](https://www.terraform.io/docs/providers/github/r/branch_protection.html). +func (o TeamOutput) Slug() pulumi.StringOutput { + return o.ApplyT(func(v *Team) pulumi.StringOutput { return v.Slug }).(pulumi.StringOutput) +} + +type TeamArrayOutput struct{ *pulumi.OutputState } + +func (TeamArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*Team)(nil)).Elem() +} + +func (o TeamArrayOutput) ToTeamArrayOutput() TeamArrayOutput { + return o +} + +func (o TeamArrayOutput) ToTeamArrayOutputWithContext(ctx context.Context) TeamArrayOutput { + return o +} + +func (o TeamArrayOutput) Index(i pulumi.IntInput) TeamOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Team { + return vs[0].([]*Team)[vs[1].(int)] + }).(TeamOutput) +} + +type TeamMapOutput struct{ *pulumi.OutputState } + +func (TeamMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*Team)(nil)).Elem() +} + +func (o TeamMapOutput) ToTeamMapOutput() TeamMapOutput { + return o +} + +func (o TeamMapOutput) ToTeamMapOutputWithContext(ctx context.Context) TeamMapOutput { + return o +} + +func (o TeamMapOutput) MapIndex(k pulumi.StringInput) TeamOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Team { + return vs[0].(map[string]*Team)[vs[1].(string)] + }).(TeamOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*TeamInput)(nil)).Elem(), &Team{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamArrayInput)(nil)).Elem(), TeamArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamMapInput)(nil)).Elem(), TeamMap{}) + pulumi.RegisterOutputType(TeamOutput{}) + pulumi.RegisterOutputType(TeamArrayOutput{}) + pulumi.RegisterOutputType(TeamMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/teamMembers.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/teamMembers.go new file mode 100644 index 000000000..e59d76843 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/teamMembers.go @@ -0,0 +1,330 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Provides a GitHub team members resource. +// +// This resource allows you to manage members of teams in your organization. It sets the requested team members for the team and removes all users not managed by Terraform. +// +// When applied, if the user hasn't accepted their invitation to the organization, they won't be part of the team until they do. +// +// When destroyed, all users will be removed from the team. +// +// > **Note** This resource is not compatible with `TeamMembership`. Use either `TeamMembers` or `TeamMembership`. +// +// > **Note** You can accidentally lock yourself out of your team using this resource. Deleting a `TeamMembers` resource removes access from anyone without organization-level access to the team. Proceed with caution. It should generally only be used with teams fully managed by Terraform. +// +// > **Note** Attempting to set a user who is an organization owner to "member" will result in the user being granted "maintainer" instead; this can result in a perpetual `terraform plan` diff that changes their status back to "member". +// +// ## Example Usage +// +// ```go +// 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 +// } +// _, err = github.NewMembership(ctx, "membership_for_another_user", &github.MembershipArgs{ +// Username: pulumi.String("AnotherUser"), +// 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.NewTeamMembers(ctx, "some_team_members", &github.TeamMembersArgs{ +// TeamId: someTeam.ID(), +// Members: github.TeamMembersMemberArray{ +// &github.TeamMembersMemberArgs{ +// Username: pulumi.String("SomeUser"), +// Role: pulumi.String("maintainer"), +// }, +// &github.TeamMembersMemberArgs{ +// Username: pulumi.String("AnotherUser"), +// Role: pulumi.String("member"), +// }, +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// > **Note** Although the team id or team slug can be used it is recommended to use the team id. Using the team slug will result in terraform doing conversions between the team slug and team id. This will cause team members associations to the team to be destroyed and recreated on import. +// +// GitHub Team Membership can be imported using the team ID team id or team slug, e.g. +// +// ```sh +// $ pulumi import github:index/teamMembers:TeamMembers some_team 1234567 +// $ pulumi import github:index/teamMembers:TeamMembers some_team Administrators +// ``` +type TeamMembers struct { + pulumi.CustomResourceState + + // List of team members. See Members below for details. + Members TeamMembersMemberArrayOutput `pulumi:"members"` + // The team id or the team slug + // + // > **Note** Although the team id or team slug can be used it is recommended to use the team id. Using the team slug will cause the team members associations to the team to be destroyed and recreated if the team name is updated. + TeamId pulumi.StringOutput `pulumi:"teamId"` +} + +// NewTeamMembers registers a new resource with the given unique name, arguments, and options. +func NewTeamMembers(ctx *pulumi.Context, + name string, args *TeamMembersArgs, opts ...pulumi.ResourceOption) (*TeamMembers, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Members == nil { + return nil, errors.New("invalid value for required argument 'Members'") + } + if args.TeamId == nil { + return nil, errors.New("invalid value for required argument 'TeamId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource TeamMembers + err := ctx.RegisterResource("github:index/teamMembers:TeamMembers", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetTeamMembers gets an existing TeamMembers 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 GetTeamMembers(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *TeamMembersState, opts ...pulumi.ResourceOption) (*TeamMembers, error) { + var resource TeamMembers + err := ctx.ReadResource("github:index/teamMembers:TeamMembers", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering TeamMembers resources. +type teamMembersState struct { + // List of team members. See Members below for details. + Members []TeamMembersMember `pulumi:"members"` + // The team id or the team slug + // + // > **Note** Although the team id or team slug can be used it is recommended to use the team id. Using the team slug will cause the team members associations to the team to be destroyed and recreated if the team name is updated. + TeamId *string `pulumi:"teamId"` +} + +type TeamMembersState struct { + // List of team members. See Members below for details. + Members TeamMembersMemberArrayInput + // The team id or the team slug + // + // > **Note** Although the team id or team slug can be used it is recommended to use the team id. Using the team slug will cause the team members associations to the team to be destroyed and recreated if the team name is updated. + TeamId pulumi.StringPtrInput +} + +func (TeamMembersState) ElementType() reflect.Type { + return reflect.TypeOf((*teamMembersState)(nil)).Elem() +} + +type teamMembersArgs struct { + // List of team members. See Members below for details. + Members []TeamMembersMember `pulumi:"members"` + // The team id or the team slug + // + // > **Note** Although the team id or team slug can be used it is recommended to use the team id. Using the team slug will cause the team members associations to the team to be destroyed and recreated if the team name is updated. + TeamId string `pulumi:"teamId"` +} + +// The set of arguments for constructing a TeamMembers resource. +type TeamMembersArgs struct { + // List of team members. See Members below for details. + Members TeamMembersMemberArrayInput + // The team id or the team slug + // + // > **Note** Although the team id or team slug can be used it is recommended to use the team id. Using the team slug will cause the team members associations to the team to be destroyed and recreated if the team name is updated. + TeamId pulumi.StringInput +} + +func (TeamMembersArgs) ElementType() reflect.Type { + return reflect.TypeOf((*teamMembersArgs)(nil)).Elem() +} + +type TeamMembersInput interface { + pulumi.Input + + ToTeamMembersOutput() TeamMembersOutput + ToTeamMembersOutputWithContext(ctx context.Context) TeamMembersOutput +} + +func (*TeamMembers) ElementType() reflect.Type { + return reflect.TypeOf((**TeamMembers)(nil)).Elem() +} + +func (i *TeamMembers) ToTeamMembersOutput() TeamMembersOutput { + return i.ToTeamMembersOutputWithContext(context.Background()) +} + +func (i *TeamMembers) ToTeamMembersOutputWithContext(ctx context.Context) TeamMembersOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamMembersOutput) +} + +// TeamMembersArrayInput is an input type that accepts TeamMembersArray and TeamMembersArrayOutput values. +// You can construct a concrete instance of `TeamMembersArrayInput` via: +// +// TeamMembersArray{ TeamMembersArgs{...} } +type TeamMembersArrayInput interface { + pulumi.Input + + ToTeamMembersArrayOutput() TeamMembersArrayOutput + ToTeamMembersArrayOutputWithContext(context.Context) TeamMembersArrayOutput +} + +type TeamMembersArray []TeamMembersInput + +func (TeamMembersArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*TeamMembers)(nil)).Elem() +} + +func (i TeamMembersArray) ToTeamMembersArrayOutput() TeamMembersArrayOutput { + return i.ToTeamMembersArrayOutputWithContext(context.Background()) +} + +func (i TeamMembersArray) ToTeamMembersArrayOutputWithContext(ctx context.Context) TeamMembersArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamMembersArrayOutput) +} + +// TeamMembersMapInput is an input type that accepts TeamMembersMap and TeamMembersMapOutput values. +// You can construct a concrete instance of `TeamMembersMapInput` via: +// +// TeamMembersMap{ "key": TeamMembersArgs{...} } +type TeamMembersMapInput interface { + pulumi.Input + + ToTeamMembersMapOutput() TeamMembersMapOutput + ToTeamMembersMapOutputWithContext(context.Context) TeamMembersMapOutput +} + +type TeamMembersMap map[string]TeamMembersInput + +func (TeamMembersMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*TeamMembers)(nil)).Elem() +} + +func (i TeamMembersMap) ToTeamMembersMapOutput() TeamMembersMapOutput { + return i.ToTeamMembersMapOutputWithContext(context.Background()) +} + +func (i TeamMembersMap) ToTeamMembersMapOutputWithContext(ctx context.Context) TeamMembersMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamMembersMapOutput) +} + +type TeamMembersOutput struct{ *pulumi.OutputState } + +func (TeamMembersOutput) ElementType() reflect.Type { + return reflect.TypeOf((**TeamMembers)(nil)).Elem() +} + +func (o TeamMembersOutput) ToTeamMembersOutput() TeamMembersOutput { + return o +} + +func (o TeamMembersOutput) ToTeamMembersOutputWithContext(ctx context.Context) TeamMembersOutput { + return o +} + +// List of team members. See Members below for details. +func (o TeamMembersOutput) Members() TeamMembersMemberArrayOutput { + return o.ApplyT(func(v *TeamMembers) TeamMembersMemberArrayOutput { return v.Members }).(TeamMembersMemberArrayOutput) +} + +// The team id or the team slug +// +// > **Note** Although the team id or team slug can be used it is recommended to use the team id. Using the team slug will cause the team members associations to the team to be destroyed and recreated if the team name is updated. +func (o TeamMembersOutput) TeamId() pulumi.StringOutput { + return o.ApplyT(func(v *TeamMembers) pulumi.StringOutput { return v.TeamId }).(pulumi.StringOutput) +} + +type TeamMembersArrayOutput struct{ *pulumi.OutputState } + +func (TeamMembersArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*TeamMembers)(nil)).Elem() +} + +func (o TeamMembersArrayOutput) ToTeamMembersArrayOutput() TeamMembersArrayOutput { + return o +} + +func (o TeamMembersArrayOutput) ToTeamMembersArrayOutputWithContext(ctx context.Context) TeamMembersArrayOutput { + return o +} + +func (o TeamMembersArrayOutput) Index(i pulumi.IntInput) TeamMembersOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *TeamMembers { + return vs[0].([]*TeamMembers)[vs[1].(int)] + }).(TeamMembersOutput) +} + +type TeamMembersMapOutput struct{ *pulumi.OutputState } + +func (TeamMembersMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*TeamMembers)(nil)).Elem() +} + +func (o TeamMembersMapOutput) ToTeamMembersMapOutput() TeamMembersMapOutput { + return o +} + +func (o TeamMembersMapOutput) ToTeamMembersMapOutputWithContext(ctx context.Context) TeamMembersMapOutput { + return o +} + +func (o TeamMembersMapOutput) MapIndex(k pulumi.StringInput) TeamMembersOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *TeamMembers { + return vs[0].(map[string]*TeamMembers)[vs[1].(string)] + }).(TeamMembersOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*TeamMembersInput)(nil)).Elem(), &TeamMembers{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamMembersArrayInput)(nil)).Elem(), TeamMembersArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamMembersMapInput)(nil)).Elem(), TeamMembersMap{}) + pulumi.RegisterOutputType(TeamMembersOutput{}) + pulumi.RegisterOutputType(TeamMembersArrayOutput{}) + pulumi.RegisterOutputType(TeamMembersMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/teamMembership.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/teamMembership.go new file mode 100644 index 000000000..1719980b3 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/teamMembership.go @@ -0,0 +1,326 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// 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 `TeamMembers`. Use either `TeamMembers` or `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 +// +// ```go +// 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 +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Team Membership can be imported using an ID made up of `teamid:username` or `teamname:username`, e.g. +// +// ```sh +// $ pulumi import github:index/teamMembership:TeamMembership member 1234567:someuser +// $ pulumi import github:index/teamMembership:TeamMembership member Administrators:someuser +// ``` +type TeamMembership struct { + pulumi.CustomResourceState + + Etag pulumi.StringOutput `pulumi:"etag"` + // The role of the user within the team. + // Must be one of `member` or `maintainer`. Defaults to `member`. + Role pulumi.StringPtrOutput `pulumi:"role"` + // The GitHub team id or the GitHub team slug + TeamId pulumi.StringOutput `pulumi:"teamId"` + // The user to add to the team. + Username pulumi.StringOutput `pulumi:"username"` +} + +// NewTeamMembership registers a new resource with the given unique name, arguments, and options. +func NewTeamMembership(ctx *pulumi.Context, + name string, args *TeamMembershipArgs, opts ...pulumi.ResourceOption) (*TeamMembership, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.TeamId == nil { + return nil, errors.New("invalid value for required argument 'TeamId'") + } + if args.Username == nil { + return nil, errors.New("invalid value for required argument 'Username'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource TeamMembership + err := ctx.RegisterResource("github:index/teamMembership:TeamMembership", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetTeamMembership gets an existing TeamMembership 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 GetTeamMembership(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *TeamMembershipState, opts ...pulumi.ResourceOption) (*TeamMembership, error) { + var resource TeamMembership + err := ctx.ReadResource("github:index/teamMembership:TeamMembership", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering TeamMembership resources. +type teamMembershipState struct { + Etag *string `pulumi:"etag"` + // The role of the user within the team. + // Must be one of `member` or `maintainer`. Defaults to `member`. + Role *string `pulumi:"role"` + // The GitHub team id or the GitHub team slug + TeamId *string `pulumi:"teamId"` + // The user to add to the team. + Username *string `pulumi:"username"` +} + +type TeamMembershipState struct { + Etag pulumi.StringPtrInput + // The role of the user within the team. + // Must be one of `member` or `maintainer`. Defaults to `member`. + Role pulumi.StringPtrInput + // The GitHub team id or the GitHub team slug + TeamId pulumi.StringPtrInput + // The user to add to the team. + Username pulumi.StringPtrInput +} + +func (TeamMembershipState) ElementType() reflect.Type { + return reflect.TypeOf((*teamMembershipState)(nil)).Elem() +} + +type teamMembershipArgs struct { + // The role of the user within the team. + // Must be one of `member` or `maintainer`. Defaults to `member`. + Role *string `pulumi:"role"` + // The GitHub team id or the GitHub team slug + TeamId string `pulumi:"teamId"` + // The user to add to the team. + Username string `pulumi:"username"` +} + +// The set of arguments for constructing a TeamMembership resource. +type TeamMembershipArgs struct { + // The role of the user within the team. + // Must be one of `member` or `maintainer`. Defaults to `member`. + Role pulumi.StringPtrInput + // The GitHub team id or the GitHub team slug + TeamId pulumi.StringInput + // The user to add to the team. + Username pulumi.StringInput +} + +func (TeamMembershipArgs) ElementType() reflect.Type { + return reflect.TypeOf((*teamMembershipArgs)(nil)).Elem() +} + +type TeamMembershipInput interface { + pulumi.Input + + ToTeamMembershipOutput() TeamMembershipOutput + ToTeamMembershipOutputWithContext(ctx context.Context) TeamMembershipOutput +} + +func (*TeamMembership) ElementType() reflect.Type { + return reflect.TypeOf((**TeamMembership)(nil)).Elem() +} + +func (i *TeamMembership) ToTeamMembershipOutput() TeamMembershipOutput { + return i.ToTeamMembershipOutputWithContext(context.Background()) +} + +func (i *TeamMembership) ToTeamMembershipOutputWithContext(ctx context.Context) TeamMembershipOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamMembershipOutput) +} + +// TeamMembershipArrayInput is an input type that accepts TeamMembershipArray and TeamMembershipArrayOutput values. +// You can construct a concrete instance of `TeamMembershipArrayInput` via: +// +// TeamMembershipArray{ TeamMembershipArgs{...} } +type TeamMembershipArrayInput interface { + pulumi.Input + + ToTeamMembershipArrayOutput() TeamMembershipArrayOutput + ToTeamMembershipArrayOutputWithContext(context.Context) TeamMembershipArrayOutput +} + +type TeamMembershipArray []TeamMembershipInput + +func (TeamMembershipArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*TeamMembership)(nil)).Elem() +} + +func (i TeamMembershipArray) ToTeamMembershipArrayOutput() TeamMembershipArrayOutput { + return i.ToTeamMembershipArrayOutputWithContext(context.Background()) +} + +func (i TeamMembershipArray) ToTeamMembershipArrayOutputWithContext(ctx context.Context) TeamMembershipArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamMembershipArrayOutput) +} + +// TeamMembershipMapInput is an input type that accepts TeamMembershipMap and TeamMembershipMapOutput values. +// You can construct a concrete instance of `TeamMembershipMapInput` via: +// +// TeamMembershipMap{ "key": TeamMembershipArgs{...} } +type TeamMembershipMapInput interface { + pulumi.Input + + ToTeamMembershipMapOutput() TeamMembershipMapOutput + ToTeamMembershipMapOutputWithContext(context.Context) TeamMembershipMapOutput +} + +type TeamMembershipMap map[string]TeamMembershipInput + +func (TeamMembershipMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*TeamMembership)(nil)).Elem() +} + +func (i TeamMembershipMap) ToTeamMembershipMapOutput() TeamMembershipMapOutput { + return i.ToTeamMembershipMapOutputWithContext(context.Background()) +} + +func (i TeamMembershipMap) ToTeamMembershipMapOutputWithContext(ctx context.Context) TeamMembershipMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamMembershipMapOutput) +} + +type TeamMembershipOutput struct{ *pulumi.OutputState } + +func (TeamMembershipOutput) ElementType() reflect.Type { + return reflect.TypeOf((**TeamMembership)(nil)).Elem() +} + +func (o TeamMembershipOutput) ToTeamMembershipOutput() TeamMembershipOutput { + return o +} + +func (o TeamMembershipOutput) ToTeamMembershipOutputWithContext(ctx context.Context) TeamMembershipOutput { + return o +} + +func (o TeamMembershipOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *TeamMembership) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// The role of the user within the team. +// Must be one of `member` or `maintainer`. Defaults to `member`. +func (o TeamMembershipOutput) Role() pulumi.StringPtrOutput { + return o.ApplyT(func(v *TeamMembership) pulumi.StringPtrOutput { return v.Role }).(pulumi.StringPtrOutput) +} + +// The GitHub team id or the GitHub team slug +func (o TeamMembershipOutput) TeamId() pulumi.StringOutput { + return o.ApplyT(func(v *TeamMembership) pulumi.StringOutput { return v.TeamId }).(pulumi.StringOutput) +} + +// The user to add to the team. +func (o TeamMembershipOutput) Username() pulumi.StringOutput { + return o.ApplyT(func(v *TeamMembership) pulumi.StringOutput { return v.Username }).(pulumi.StringOutput) +} + +type TeamMembershipArrayOutput struct{ *pulumi.OutputState } + +func (TeamMembershipArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*TeamMembership)(nil)).Elem() +} + +func (o TeamMembershipArrayOutput) ToTeamMembershipArrayOutput() TeamMembershipArrayOutput { + return o +} + +func (o TeamMembershipArrayOutput) ToTeamMembershipArrayOutputWithContext(ctx context.Context) TeamMembershipArrayOutput { + return o +} + +func (o TeamMembershipArrayOutput) Index(i pulumi.IntInput) TeamMembershipOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *TeamMembership { + return vs[0].([]*TeamMembership)[vs[1].(int)] + }).(TeamMembershipOutput) +} + +type TeamMembershipMapOutput struct{ *pulumi.OutputState } + +func (TeamMembershipMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*TeamMembership)(nil)).Elem() +} + +func (o TeamMembershipMapOutput) ToTeamMembershipMapOutput() TeamMembershipMapOutput { + return o +} + +func (o TeamMembershipMapOutput) ToTeamMembershipMapOutputWithContext(ctx context.Context) TeamMembershipMapOutput { + return o +} + +func (o TeamMembershipMapOutput) MapIndex(k pulumi.StringInput) TeamMembershipOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *TeamMembership { + return vs[0].(map[string]*TeamMembership)[vs[1].(string)] + }).(TeamMembershipOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*TeamMembershipInput)(nil)).Elem(), &TeamMembership{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamMembershipArrayInput)(nil)).Elem(), TeamMembershipArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamMembershipMapInput)(nil)).Elem(), TeamMembershipMap{}) + pulumi.RegisterOutputType(TeamMembershipOutput{}) + pulumi.RegisterOutputType(TeamMembershipArrayOutput{}) + pulumi.RegisterOutputType(TeamMembershipMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/teamRepository.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/teamRepository.go new file mode 100644 index 000000000..d56680944 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/teamRepository.go @@ -0,0 +1,332 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// > Note: TeamRepository cannot be used in conjunction with RepositoryCollaborators or +// they will fight over what your policy should be. +// +// This resource manages relationships between teams and repositories +// in your GitHub organization. +// +// Creating this resource grants a particular team permissions on a +// particular repository. +// +// The repository and the team must both belong to the same organization +// on GitHub. This resource does not actually *create* any repositories; +// to do that, see `Repository`. +// +// > **Note on Archived Repositories**: When a repository is archived, GitHub makes it read-only, preventing team permission modifications. If you attempt to destroy resources associated with archived repositories, the provider will gracefully handle the operation by logging an informational message and removing the resource from Terraform state without attempting to modify the archived repository. +// +// This resource is non-authoritative, for managing ALL collaborators of a repo, use RepositoryCollaborators +// instead. +// +// ## Example Usage +// +// ```go +// 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 repository to the team +// someTeam, err := github.NewTeam(ctx, "some_team", &github.TeamArgs{ +// Name: pulumi.String("SomeTeam"), +// Description: pulumi.String("Some cool team"), +// }) +// if err != nil { +// return err +// } +// someRepo, err := github.NewRepository(ctx, "some_repo", &github.RepositoryArgs{ +// Name: pulumi.String("some-repo"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewTeamRepository(ctx, "some_team_repo", &github.TeamRepositoryArgs{ +// TeamId: someTeam.ID(), +// Repository: someRepo.Name, +// Permission: pulumi.String("pull"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Team Repository can be imported using an ID made up of `team_id:repository` or `team_name:repository`, e.g. +// +// ```sh +// $ pulumi import github:index/teamRepository:TeamRepository terraform_repo 1234567:terraform +// $ pulumi import github:index/teamRepository:TeamRepository terraform_repo Administrators:terraform +// ``` +type TeamRepository struct { + pulumi.CustomResourceState + + Etag pulumi.StringOutput `pulumi:"etag"` + // The permissions of team members regarding the repository. + // Must be one of `pull`, `triage`, `push`, `maintain`, `admin` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organisation. Defaults to `pull`. + Permission pulumi.StringPtrOutput `pulumi:"permission"` + // The repository to add to the team. + Repository pulumi.StringOutput `pulumi:"repository"` + // The GitHub team id or the GitHub team slug + TeamId pulumi.StringOutput `pulumi:"teamId"` +} + +// NewTeamRepository registers a new resource with the given unique name, arguments, and options. +func NewTeamRepository(ctx *pulumi.Context, + name string, args *TeamRepositoryArgs, opts ...pulumi.ResourceOption) (*TeamRepository, 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.TeamId == nil { + return nil, errors.New("invalid value for required argument 'TeamId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource TeamRepository + err := ctx.RegisterResource("github:index/teamRepository:TeamRepository", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetTeamRepository gets an existing TeamRepository 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 GetTeamRepository(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *TeamRepositoryState, opts ...pulumi.ResourceOption) (*TeamRepository, error) { + var resource TeamRepository + err := ctx.ReadResource("github:index/teamRepository:TeamRepository", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering TeamRepository resources. +type teamRepositoryState struct { + Etag *string `pulumi:"etag"` + // The permissions of team members regarding the repository. + // Must be one of `pull`, `triage`, `push`, `maintain`, `admin` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organisation. Defaults to `pull`. + Permission *string `pulumi:"permission"` + // The repository to add to the team. + Repository *string `pulumi:"repository"` + // The GitHub team id or the GitHub team slug + TeamId *string `pulumi:"teamId"` +} + +type TeamRepositoryState struct { + Etag pulumi.StringPtrInput + // The permissions of team members regarding the repository. + // Must be one of `pull`, `triage`, `push`, `maintain`, `admin` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organisation. Defaults to `pull`. + Permission pulumi.StringPtrInput + // The repository to add to the team. + Repository pulumi.StringPtrInput + // The GitHub team id or the GitHub team slug + TeamId pulumi.StringPtrInput +} + +func (TeamRepositoryState) ElementType() reflect.Type { + return reflect.TypeOf((*teamRepositoryState)(nil)).Elem() +} + +type teamRepositoryArgs struct { + // The permissions of team members regarding the repository. + // Must be one of `pull`, `triage`, `push`, `maintain`, `admin` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organisation. Defaults to `pull`. + Permission *string `pulumi:"permission"` + // The repository to add to the team. + Repository string `pulumi:"repository"` + // The GitHub team id or the GitHub team slug + TeamId string `pulumi:"teamId"` +} + +// The set of arguments for constructing a TeamRepository resource. +type TeamRepositoryArgs struct { + // The permissions of team members regarding the repository. + // Must be one of `pull`, `triage`, `push`, `maintain`, `admin` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organisation. Defaults to `pull`. + Permission pulumi.StringPtrInput + // The repository to add to the team. + Repository pulumi.StringInput + // The GitHub team id or the GitHub team slug + TeamId pulumi.StringInput +} + +func (TeamRepositoryArgs) ElementType() reflect.Type { + return reflect.TypeOf((*teamRepositoryArgs)(nil)).Elem() +} + +type TeamRepositoryInput interface { + pulumi.Input + + ToTeamRepositoryOutput() TeamRepositoryOutput + ToTeamRepositoryOutputWithContext(ctx context.Context) TeamRepositoryOutput +} + +func (*TeamRepository) ElementType() reflect.Type { + return reflect.TypeOf((**TeamRepository)(nil)).Elem() +} + +func (i *TeamRepository) ToTeamRepositoryOutput() TeamRepositoryOutput { + return i.ToTeamRepositoryOutputWithContext(context.Background()) +} + +func (i *TeamRepository) ToTeamRepositoryOutputWithContext(ctx context.Context) TeamRepositoryOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamRepositoryOutput) +} + +// TeamRepositoryArrayInput is an input type that accepts TeamRepositoryArray and TeamRepositoryArrayOutput values. +// You can construct a concrete instance of `TeamRepositoryArrayInput` via: +// +// TeamRepositoryArray{ TeamRepositoryArgs{...} } +type TeamRepositoryArrayInput interface { + pulumi.Input + + ToTeamRepositoryArrayOutput() TeamRepositoryArrayOutput + ToTeamRepositoryArrayOutputWithContext(context.Context) TeamRepositoryArrayOutput +} + +type TeamRepositoryArray []TeamRepositoryInput + +func (TeamRepositoryArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*TeamRepository)(nil)).Elem() +} + +func (i TeamRepositoryArray) ToTeamRepositoryArrayOutput() TeamRepositoryArrayOutput { + return i.ToTeamRepositoryArrayOutputWithContext(context.Background()) +} + +func (i TeamRepositoryArray) ToTeamRepositoryArrayOutputWithContext(ctx context.Context) TeamRepositoryArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamRepositoryArrayOutput) +} + +// TeamRepositoryMapInput is an input type that accepts TeamRepositoryMap and TeamRepositoryMapOutput values. +// You can construct a concrete instance of `TeamRepositoryMapInput` via: +// +// TeamRepositoryMap{ "key": TeamRepositoryArgs{...} } +type TeamRepositoryMapInput interface { + pulumi.Input + + ToTeamRepositoryMapOutput() TeamRepositoryMapOutput + ToTeamRepositoryMapOutputWithContext(context.Context) TeamRepositoryMapOutput +} + +type TeamRepositoryMap map[string]TeamRepositoryInput + +func (TeamRepositoryMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*TeamRepository)(nil)).Elem() +} + +func (i TeamRepositoryMap) ToTeamRepositoryMapOutput() TeamRepositoryMapOutput { + return i.ToTeamRepositoryMapOutputWithContext(context.Background()) +} + +func (i TeamRepositoryMap) ToTeamRepositoryMapOutputWithContext(ctx context.Context) TeamRepositoryMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamRepositoryMapOutput) +} + +type TeamRepositoryOutput struct{ *pulumi.OutputState } + +func (TeamRepositoryOutput) ElementType() reflect.Type { + return reflect.TypeOf((**TeamRepository)(nil)).Elem() +} + +func (o TeamRepositoryOutput) ToTeamRepositoryOutput() TeamRepositoryOutput { + return o +} + +func (o TeamRepositoryOutput) ToTeamRepositoryOutputWithContext(ctx context.Context) TeamRepositoryOutput { + return o +} + +func (o TeamRepositoryOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *TeamRepository) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// The permissions of team members regarding the repository. +// Must be one of `pull`, `triage`, `push`, `maintain`, `admin` or the name of an existing [custom repository role](https://docs.github.com/en/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization) within the organisation. Defaults to `pull`. +func (o TeamRepositoryOutput) Permission() pulumi.StringPtrOutput { + return o.ApplyT(func(v *TeamRepository) pulumi.StringPtrOutput { return v.Permission }).(pulumi.StringPtrOutput) +} + +// The repository to add to the team. +func (o TeamRepositoryOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *TeamRepository) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +// The GitHub team id or the GitHub team slug +func (o TeamRepositoryOutput) TeamId() pulumi.StringOutput { + return o.ApplyT(func(v *TeamRepository) pulumi.StringOutput { return v.TeamId }).(pulumi.StringOutput) +} + +type TeamRepositoryArrayOutput struct{ *pulumi.OutputState } + +func (TeamRepositoryArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*TeamRepository)(nil)).Elem() +} + +func (o TeamRepositoryArrayOutput) ToTeamRepositoryArrayOutput() TeamRepositoryArrayOutput { + return o +} + +func (o TeamRepositoryArrayOutput) ToTeamRepositoryArrayOutputWithContext(ctx context.Context) TeamRepositoryArrayOutput { + return o +} + +func (o TeamRepositoryArrayOutput) Index(i pulumi.IntInput) TeamRepositoryOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *TeamRepository { + return vs[0].([]*TeamRepository)[vs[1].(int)] + }).(TeamRepositoryOutput) +} + +type TeamRepositoryMapOutput struct{ *pulumi.OutputState } + +func (TeamRepositoryMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*TeamRepository)(nil)).Elem() +} + +func (o TeamRepositoryMapOutput) ToTeamRepositoryMapOutput() TeamRepositoryMapOutput { + return o +} + +func (o TeamRepositoryMapOutput) ToTeamRepositoryMapOutputWithContext(ctx context.Context) TeamRepositoryMapOutput { + return o +} + +func (o TeamRepositoryMapOutput) MapIndex(k pulumi.StringInput) TeamRepositoryOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *TeamRepository { + return vs[0].(map[string]*TeamRepository)[vs[1].(string)] + }).(TeamRepositoryOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*TeamRepositoryInput)(nil)).Elem(), &TeamRepository{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamRepositoryArrayInput)(nil)).Elem(), TeamRepositoryArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamRepositoryMapInput)(nil)).Elem(), TeamRepositoryMap{}) + pulumi.RegisterOutputType(TeamRepositoryOutput{}) + pulumi.RegisterOutputType(TeamRepositoryArrayOutput{}) + pulumi.RegisterOutputType(TeamRepositoryMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/teamSettings.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/teamSettings.go new file mode 100644 index 000000000..c4379e4fe --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/teamSettings.go @@ -0,0 +1,357 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource manages the team settings (in particular the request review delegation settings) within the organization +// +// Creating this resource will alter the team Code Review settings. +// +// The team must both belong to the same organization configured in the provider on GitHub. +// +// > **Note**: This resource relies on the v4 GraphQl GitHub API. If this API is not available, or the Stone Crop schema preview is not available, then this resource will not work as intended. +// +// ## Example Usage +// +// ### Notify without delegation +// +// ```go +// 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 { +// 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.NewTeamSettings(ctx, "code_review_settings", &github.TeamSettingsArgs{ +// TeamId: someTeam.ID(), +// Notify: pulumi.Bool(true), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ### Notify with delegation +// +// ```go +// 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 { +// 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.NewTeamSettings(ctx, "code_review_settings", &github.TeamSettingsArgs{ +// TeamId: someTeam.ID(), +// Notify: pulumi.Bool(true), +// ReviewRequestDelegation: &github.TeamSettingsReviewRequestDelegationArgs{ +// Algorithm: pulumi.String("ROUND_ROBIN"), +// MemberCount: pulumi.Int(1), +// }, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GitHub Teams can be imported using the GitHub team ID, or the team slug e.g. +// +// or, +type TeamSettings struct { + pulumi.CustomResourceState + + // Whether to notify the entire team when at least one member is also assigned to the pull request. Can be set independently of `reviewRequestDelegation`. Default value is `false`. + Notify pulumi.BoolPtrOutput `pulumi:"notify"` + // The settings for delegating code reviews to individuals on behalf of the team. If this block is present, even without any fields, then review request delegation will be enabled for the team. See GitHub Review Request Delegation below for details. See [GitHub's documentation](https://docs.github.com/en/organizations/organizing-members-into-teams/managing-code-review-settings-for-your-team#configuring-team-notifications) for more configuration details. + ReviewRequestDelegation TeamSettingsReviewRequestDelegationPtrOutput `pulumi:"reviewRequestDelegation"` + // The GitHub team id or the GitHub team slug + TeamId pulumi.StringOutput `pulumi:"teamId"` + // The slug of the Team. + TeamSlug pulumi.StringOutput `pulumi:"teamSlug"` + // The unique node ID of the Team on GitHub. Corresponds to the ID of the `TeamSettings` resource. + TeamUid pulumi.StringOutput `pulumi:"teamUid"` +} + +// NewTeamSettings registers a new resource with the given unique name, arguments, and options. +func NewTeamSettings(ctx *pulumi.Context, + name string, args *TeamSettingsArgs, opts ...pulumi.ResourceOption) (*TeamSettings, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.TeamId == nil { + return nil, errors.New("invalid value for required argument 'TeamId'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource TeamSettings + err := ctx.RegisterResource("github:index/teamSettings:TeamSettings", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetTeamSettings gets an existing TeamSettings 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 GetTeamSettings(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *TeamSettingsState, opts ...pulumi.ResourceOption) (*TeamSettings, error) { + var resource TeamSettings + err := ctx.ReadResource("github:index/teamSettings:TeamSettings", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering TeamSettings resources. +type teamSettingsState struct { + // Whether to notify the entire team when at least one member is also assigned to the pull request. Can be set independently of `reviewRequestDelegation`. Default value is `false`. + Notify *bool `pulumi:"notify"` + // The settings for delegating code reviews to individuals on behalf of the team. If this block is present, even without any fields, then review request delegation will be enabled for the team. See GitHub Review Request Delegation below for details. See [GitHub's documentation](https://docs.github.com/en/organizations/organizing-members-into-teams/managing-code-review-settings-for-your-team#configuring-team-notifications) for more configuration details. + ReviewRequestDelegation *TeamSettingsReviewRequestDelegation `pulumi:"reviewRequestDelegation"` + // The GitHub team id or the GitHub team slug + TeamId *string `pulumi:"teamId"` + // The slug of the Team. + TeamSlug *string `pulumi:"teamSlug"` + // The unique node ID of the Team on GitHub. Corresponds to the ID of the `TeamSettings` resource. + TeamUid *string `pulumi:"teamUid"` +} + +type TeamSettingsState struct { + // Whether to notify the entire team when at least one member is also assigned to the pull request. Can be set independently of `reviewRequestDelegation`. Default value is `false`. + Notify pulumi.BoolPtrInput + // The settings for delegating code reviews to individuals on behalf of the team. If this block is present, even without any fields, then review request delegation will be enabled for the team. See GitHub Review Request Delegation below for details. See [GitHub's documentation](https://docs.github.com/en/organizations/organizing-members-into-teams/managing-code-review-settings-for-your-team#configuring-team-notifications) for more configuration details. + ReviewRequestDelegation TeamSettingsReviewRequestDelegationPtrInput + // The GitHub team id or the GitHub team slug + TeamId pulumi.StringPtrInput + // The slug of the Team. + TeamSlug pulumi.StringPtrInput + // The unique node ID of the Team on GitHub. Corresponds to the ID of the `TeamSettings` resource. + TeamUid pulumi.StringPtrInput +} + +func (TeamSettingsState) ElementType() reflect.Type { + return reflect.TypeOf((*teamSettingsState)(nil)).Elem() +} + +type teamSettingsArgs struct { + // Whether to notify the entire team when at least one member is also assigned to the pull request. Can be set independently of `reviewRequestDelegation`. Default value is `false`. + Notify *bool `pulumi:"notify"` + // The settings for delegating code reviews to individuals on behalf of the team. If this block is present, even without any fields, then review request delegation will be enabled for the team. See GitHub Review Request Delegation below for details. See [GitHub's documentation](https://docs.github.com/en/organizations/organizing-members-into-teams/managing-code-review-settings-for-your-team#configuring-team-notifications) for more configuration details. + ReviewRequestDelegation *TeamSettingsReviewRequestDelegation `pulumi:"reviewRequestDelegation"` + // The GitHub team id or the GitHub team slug + TeamId string `pulumi:"teamId"` +} + +// The set of arguments for constructing a TeamSettings resource. +type TeamSettingsArgs struct { + // Whether to notify the entire team when at least one member is also assigned to the pull request. Can be set independently of `reviewRequestDelegation`. Default value is `false`. + Notify pulumi.BoolPtrInput + // The settings for delegating code reviews to individuals on behalf of the team. If this block is present, even without any fields, then review request delegation will be enabled for the team. See GitHub Review Request Delegation below for details. See [GitHub's documentation](https://docs.github.com/en/organizations/organizing-members-into-teams/managing-code-review-settings-for-your-team#configuring-team-notifications) for more configuration details. + ReviewRequestDelegation TeamSettingsReviewRequestDelegationPtrInput + // The GitHub team id or the GitHub team slug + TeamId pulumi.StringInput +} + +func (TeamSettingsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*teamSettingsArgs)(nil)).Elem() +} + +type TeamSettingsInput interface { + pulumi.Input + + ToTeamSettingsOutput() TeamSettingsOutput + ToTeamSettingsOutputWithContext(ctx context.Context) TeamSettingsOutput +} + +func (*TeamSettings) ElementType() reflect.Type { + return reflect.TypeOf((**TeamSettings)(nil)).Elem() +} + +func (i *TeamSettings) ToTeamSettingsOutput() TeamSettingsOutput { + return i.ToTeamSettingsOutputWithContext(context.Background()) +} + +func (i *TeamSettings) ToTeamSettingsOutputWithContext(ctx context.Context) TeamSettingsOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamSettingsOutput) +} + +// TeamSettingsArrayInput is an input type that accepts TeamSettingsArray and TeamSettingsArrayOutput values. +// You can construct a concrete instance of `TeamSettingsArrayInput` via: +// +// TeamSettingsArray{ TeamSettingsArgs{...} } +type TeamSettingsArrayInput interface { + pulumi.Input + + ToTeamSettingsArrayOutput() TeamSettingsArrayOutput + ToTeamSettingsArrayOutputWithContext(context.Context) TeamSettingsArrayOutput +} + +type TeamSettingsArray []TeamSettingsInput + +func (TeamSettingsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*TeamSettings)(nil)).Elem() +} + +func (i TeamSettingsArray) ToTeamSettingsArrayOutput() TeamSettingsArrayOutput { + return i.ToTeamSettingsArrayOutputWithContext(context.Background()) +} + +func (i TeamSettingsArray) ToTeamSettingsArrayOutputWithContext(ctx context.Context) TeamSettingsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamSettingsArrayOutput) +} + +// TeamSettingsMapInput is an input type that accepts TeamSettingsMap and TeamSettingsMapOutput values. +// You can construct a concrete instance of `TeamSettingsMapInput` via: +// +// TeamSettingsMap{ "key": TeamSettingsArgs{...} } +type TeamSettingsMapInput interface { + pulumi.Input + + ToTeamSettingsMapOutput() TeamSettingsMapOutput + ToTeamSettingsMapOutputWithContext(context.Context) TeamSettingsMapOutput +} + +type TeamSettingsMap map[string]TeamSettingsInput + +func (TeamSettingsMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*TeamSettings)(nil)).Elem() +} + +func (i TeamSettingsMap) ToTeamSettingsMapOutput() TeamSettingsMapOutput { + return i.ToTeamSettingsMapOutputWithContext(context.Background()) +} + +func (i TeamSettingsMap) ToTeamSettingsMapOutputWithContext(ctx context.Context) TeamSettingsMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamSettingsMapOutput) +} + +type TeamSettingsOutput struct{ *pulumi.OutputState } + +func (TeamSettingsOutput) ElementType() reflect.Type { + return reflect.TypeOf((**TeamSettings)(nil)).Elem() +} + +func (o TeamSettingsOutput) ToTeamSettingsOutput() TeamSettingsOutput { + return o +} + +func (o TeamSettingsOutput) ToTeamSettingsOutputWithContext(ctx context.Context) TeamSettingsOutput { + return o +} + +// Whether to notify the entire team when at least one member is also assigned to the pull request. Can be set independently of `reviewRequestDelegation`. Default value is `false`. +func (o TeamSettingsOutput) Notify() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *TeamSettings) pulumi.BoolPtrOutput { return v.Notify }).(pulumi.BoolPtrOutput) +} + +// The settings for delegating code reviews to individuals on behalf of the team. If this block is present, even without any fields, then review request delegation will be enabled for the team. See GitHub Review Request Delegation below for details. See [GitHub's documentation](https://docs.github.com/en/organizations/organizing-members-into-teams/managing-code-review-settings-for-your-team#configuring-team-notifications) for more configuration details. +func (o TeamSettingsOutput) ReviewRequestDelegation() TeamSettingsReviewRequestDelegationPtrOutput { + return o.ApplyT(func(v *TeamSettings) TeamSettingsReviewRequestDelegationPtrOutput { return v.ReviewRequestDelegation }).(TeamSettingsReviewRequestDelegationPtrOutput) +} + +// The GitHub team id or the GitHub team slug +func (o TeamSettingsOutput) TeamId() pulumi.StringOutput { + return o.ApplyT(func(v *TeamSettings) pulumi.StringOutput { return v.TeamId }).(pulumi.StringOutput) +} + +// The slug of the Team. +func (o TeamSettingsOutput) TeamSlug() pulumi.StringOutput { + return o.ApplyT(func(v *TeamSettings) pulumi.StringOutput { return v.TeamSlug }).(pulumi.StringOutput) +} + +// The unique node ID of the Team on GitHub. Corresponds to the ID of the `TeamSettings` resource. +func (o TeamSettingsOutput) TeamUid() pulumi.StringOutput { + return o.ApplyT(func(v *TeamSettings) pulumi.StringOutput { return v.TeamUid }).(pulumi.StringOutput) +} + +type TeamSettingsArrayOutput struct{ *pulumi.OutputState } + +func (TeamSettingsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*TeamSettings)(nil)).Elem() +} + +func (o TeamSettingsArrayOutput) ToTeamSettingsArrayOutput() TeamSettingsArrayOutput { + return o +} + +func (o TeamSettingsArrayOutput) ToTeamSettingsArrayOutputWithContext(ctx context.Context) TeamSettingsArrayOutput { + return o +} + +func (o TeamSettingsArrayOutput) Index(i pulumi.IntInput) TeamSettingsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *TeamSettings { + return vs[0].([]*TeamSettings)[vs[1].(int)] + }).(TeamSettingsOutput) +} + +type TeamSettingsMapOutput struct{ *pulumi.OutputState } + +func (TeamSettingsMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*TeamSettings)(nil)).Elem() +} + +func (o TeamSettingsMapOutput) ToTeamSettingsMapOutput() TeamSettingsMapOutput { + return o +} + +func (o TeamSettingsMapOutput) ToTeamSettingsMapOutputWithContext(ctx context.Context) TeamSettingsMapOutput { + return o +} + +func (o TeamSettingsMapOutput) MapIndex(k pulumi.StringInput) TeamSettingsOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *TeamSettings { + return vs[0].(map[string]*TeamSettings)[vs[1].(string)] + }).(TeamSettingsOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*TeamSettingsInput)(nil)).Elem(), &TeamSettings{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamSettingsArrayInput)(nil)).Elem(), TeamSettingsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamSettingsMapInput)(nil)).Elem(), TeamSettingsMap{}) + pulumi.RegisterOutputType(TeamSettingsOutput{}) + pulumi.RegisterOutputType(TeamSettingsArrayOutput{}) + pulumi.RegisterOutputType(TeamSettingsMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/teamSyncGroupMapping.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/teamSyncGroupMapping.go new file mode 100644 index 000000000..e6a909203 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/teamSyncGroupMapping.go @@ -0,0 +1,273 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to create and manage Identity Provider (IdP) group connections within your GitHub teams. +// You must have team synchronization enabled for organizations owned by enterprise accounts. +// +// To learn more about team synchronization between IdPs and GitHub, please refer to: +// https://help.github.com/en/github/setting-up-and-managing-organizations-and-teams/synchronizing-teams-between-your-identity-provider-and-github +// +// ## Example Usage +// +// ## Import +// +// GitHub Team Sync Group Mappings can be imported using the GitHub team `slug` e.g. +// +// ```sh +// $ pulumi import github:index/teamSyncGroupMapping:TeamSyncGroupMapping example some_team +// ``` +type TeamSyncGroupMapping struct { + pulumi.CustomResourceState + + Etag pulumi.StringOutput `pulumi:"etag"` + // An Array of GitHub Identity Provider Groups (or empty []). Each `group` block consists of the fields documented below. + // *** + // + // The `group` block consists of: + Groups TeamSyncGroupMappingGroupArrayOutput `pulumi:"groups"` + // Slug of the team + TeamSlug pulumi.StringOutput `pulumi:"teamSlug"` +} + +// NewTeamSyncGroupMapping registers a new resource with the given unique name, arguments, and options. +func NewTeamSyncGroupMapping(ctx *pulumi.Context, + name string, args *TeamSyncGroupMappingArgs, opts ...pulumi.ResourceOption) (*TeamSyncGroupMapping, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.TeamSlug == nil { + return nil, errors.New("invalid value for required argument 'TeamSlug'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource TeamSyncGroupMapping + err := ctx.RegisterResource("github:index/teamSyncGroupMapping:TeamSyncGroupMapping", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetTeamSyncGroupMapping gets an existing TeamSyncGroupMapping 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 GetTeamSyncGroupMapping(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *TeamSyncGroupMappingState, opts ...pulumi.ResourceOption) (*TeamSyncGroupMapping, error) { + var resource TeamSyncGroupMapping + err := ctx.ReadResource("github:index/teamSyncGroupMapping:TeamSyncGroupMapping", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering TeamSyncGroupMapping resources. +type teamSyncGroupMappingState struct { + Etag *string `pulumi:"etag"` + // An Array of GitHub Identity Provider Groups (or empty []). Each `group` block consists of the fields documented below. + // *** + // + // The `group` block consists of: + Groups []TeamSyncGroupMappingGroup `pulumi:"groups"` + // Slug of the team + TeamSlug *string `pulumi:"teamSlug"` +} + +type TeamSyncGroupMappingState struct { + Etag pulumi.StringPtrInput + // An Array of GitHub Identity Provider Groups (or empty []). Each `group` block consists of the fields documented below. + // *** + // + // The `group` block consists of: + Groups TeamSyncGroupMappingGroupArrayInput + // Slug of the team + TeamSlug pulumi.StringPtrInput +} + +func (TeamSyncGroupMappingState) ElementType() reflect.Type { + return reflect.TypeOf((*teamSyncGroupMappingState)(nil)).Elem() +} + +type teamSyncGroupMappingArgs struct { + // An Array of GitHub Identity Provider Groups (or empty []). Each `group` block consists of the fields documented below. + // *** + // + // The `group` block consists of: + Groups []TeamSyncGroupMappingGroup `pulumi:"groups"` + // Slug of the team + TeamSlug string `pulumi:"teamSlug"` +} + +// The set of arguments for constructing a TeamSyncGroupMapping resource. +type TeamSyncGroupMappingArgs struct { + // An Array of GitHub Identity Provider Groups (or empty []). Each `group` block consists of the fields documented below. + // *** + // + // The `group` block consists of: + Groups TeamSyncGroupMappingGroupArrayInput + // Slug of the team + TeamSlug pulumi.StringInput +} + +func (TeamSyncGroupMappingArgs) ElementType() reflect.Type { + return reflect.TypeOf((*teamSyncGroupMappingArgs)(nil)).Elem() +} + +type TeamSyncGroupMappingInput interface { + pulumi.Input + + ToTeamSyncGroupMappingOutput() TeamSyncGroupMappingOutput + ToTeamSyncGroupMappingOutputWithContext(ctx context.Context) TeamSyncGroupMappingOutput +} + +func (*TeamSyncGroupMapping) ElementType() reflect.Type { + return reflect.TypeOf((**TeamSyncGroupMapping)(nil)).Elem() +} + +func (i *TeamSyncGroupMapping) ToTeamSyncGroupMappingOutput() TeamSyncGroupMappingOutput { + return i.ToTeamSyncGroupMappingOutputWithContext(context.Background()) +} + +func (i *TeamSyncGroupMapping) ToTeamSyncGroupMappingOutputWithContext(ctx context.Context) TeamSyncGroupMappingOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamSyncGroupMappingOutput) +} + +// TeamSyncGroupMappingArrayInput is an input type that accepts TeamSyncGroupMappingArray and TeamSyncGroupMappingArrayOutput values. +// You can construct a concrete instance of `TeamSyncGroupMappingArrayInput` via: +// +// TeamSyncGroupMappingArray{ TeamSyncGroupMappingArgs{...} } +type TeamSyncGroupMappingArrayInput interface { + pulumi.Input + + ToTeamSyncGroupMappingArrayOutput() TeamSyncGroupMappingArrayOutput + ToTeamSyncGroupMappingArrayOutputWithContext(context.Context) TeamSyncGroupMappingArrayOutput +} + +type TeamSyncGroupMappingArray []TeamSyncGroupMappingInput + +func (TeamSyncGroupMappingArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*TeamSyncGroupMapping)(nil)).Elem() +} + +func (i TeamSyncGroupMappingArray) ToTeamSyncGroupMappingArrayOutput() TeamSyncGroupMappingArrayOutput { + return i.ToTeamSyncGroupMappingArrayOutputWithContext(context.Background()) +} + +func (i TeamSyncGroupMappingArray) ToTeamSyncGroupMappingArrayOutputWithContext(ctx context.Context) TeamSyncGroupMappingArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamSyncGroupMappingArrayOutput) +} + +// TeamSyncGroupMappingMapInput is an input type that accepts TeamSyncGroupMappingMap and TeamSyncGroupMappingMapOutput values. +// You can construct a concrete instance of `TeamSyncGroupMappingMapInput` via: +// +// TeamSyncGroupMappingMap{ "key": TeamSyncGroupMappingArgs{...} } +type TeamSyncGroupMappingMapInput interface { + pulumi.Input + + ToTeamSyncGroupMappingMapOutput() TeamSyncGroupMappingMapOutput + ToTeamSyncGroupMappingMapOutputWithContext(context.Context) TeamSyncGroupMappingMapOutput +} + +type TeamSyncGroupMappingMap map[string]TeamSyncGroupMappingInput + +func (TeamSyncGroupMappingMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*TeamSyncGroupMapping)(nil)).Elem() +} + +func (i TeamSyncGroupMappingMap) ToTeamSyncGroupMappingMapOutput() TeamSyncGroupMappingMapOutput { + return i.ToTeamSyncGroupMappingMapOutputWithContext(context.Background()) +} + +func (i TeamSyncGroupMappingMap) ToTeamSyncGroupMappingMapOutputWithContext(ctx context.Context) TeamSyncGroupMappingMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(TeamSyncGroupMappingMapOutput) +} + +type TeamSyncGroupMappingOutput struct{ *pulumi.OutputState } + +func (TeamSyncGroupMappingOutput) ElementType() reflect.Type { + return reflect.TypeOf((**TeamSyncGroupMapping)(nil)).Elem() +} + +func (o TeamSyncGroupMappingOutput) ToTeamSyncGroupMappingOutput() TeamSyncGroupMappingOutput { + return o +} + +func (o TeamSyncGroupMappingOutput) ToTeamSyncGroupMappingOutputWithContext(ctx context.Context) TeamSyncGroupMappingOutput { + return o +} + +func (o TeamSyncGroupMappingOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *TeamSyncGroupMapping) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// An Array of GitHub Identity Provider Groups (or empty []). Each `group` block consists of the fields documented below. +// *** +// +// The `group` block consists of: +func (o TeamSyncGroupMappingOutput) Groups() TeamSyncGroupMappingGroupArrayOutput { + return o.ApplyT(func(v *TeamSyncGroupMapping) TeamSyncGroupMappingGroupArrayOutput { return v.Groups }).(TeamSyncGroupMappingGroupArrayOutput) +} + +// Slug of the team +func (o TeamSyncGroupMappingOutput) TeamSlug() pulumi.StringOutput { + return o.ApplyT(func(v *TeamSyncGroupMapping) pulumi.StringOutput { return v.TeamSlug }).(pulumi.StringOutput) +} + +type TeamSyncGroupMappingArrayOutput struct{ *pulumi.OutputState } + +func (TeamSyncGroupMappingArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*TeamSyncGroupMapping)(nil)).Elem() +} + +func (o TeamSyncGroupMappingArrayOutput) ToTeamSyncGroupMappingArrayOutput() TeamSyncGroupMappingArrayOutput { + return o +} + +func (o TeamSyncGroupMappingArrayOutput) ToTeamSyncGroupMappingArrayOutputWithContext(ctx context.Context) TeamSyncGroupMappingArrayOutput { + return o +} + +func (o TeamSyncGroupMappingArrayOutput) Index(i pulumi.IntInput) TeamSyncGroupMappingOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *TeamSyncGroupMapping { + return vs[0].([]*TeamSyncGroupMapping)[vs[1].(int)] + }).(TeamSyncGroupMappingOutput) +} + +type TeamSyncGroupMappingMapOutput struct{ *pulumi.OutputState } + +func (TeamSyncGroupMappingMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*TeamSyncGroupMapping)(nil)).Elem() +} + +func (o TeamSyncGroupMappingMapOutput) ToTeamSyncGroupMappingMapOutput() TeamSyncGroupMappingMapOutput { + return o +} + +func (o TeamSyncGroupMappingMapOutput) ToTeamSyncGroupMappingMapOutputWithContext(ctx context.Context) TeamSyncGroupMappingMapOutput { + return o +} + +func (o TeamSyncGroupMappingMapOutput) MapIndex(k pulumi.StringInput) TeamSyncGroupMappingOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *TeamSyncGroupMapping { + return vs[0].(map[string]*TeamSyncGroupMapping)[vs[1].(string)] + }).(TeamSyncGroupMappingOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*TeamSyncGroupMappingInput)(nil)).Elem(), &TeamSyncGroupMapping{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamSyncGroupMappingArrayInput)(nil)).Elem(), TeamSyncGroupMappingArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*TeamSyncGroupMappingMapInput)(nil)).Elem(), TeamSyncGroupMappingMap{}) + pulumi.RegisterOutputType(TeamSyncGroupMappingOutput{}) + pulumi.RegisterOutputType(TeamSyncGroupMappingArrayOutput{}) + pulumi.RegisterOutputType(TeamSyncGroupMappingMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/userGpgKey.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/userGpgKey.go new file mode 100644 index 000000000..be81a914b --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/userGpgKey.go @@ -0,0 +1,276 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Provides a GitHub user's GPG key resource. +// +// This resource allows you to add/remove GPG keys from your user account. +// +// ## Example Usage +// +// ```go +// 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.NewUserGpgKey(ctx, "example", &github.UserGpgKeyArgs{ +// ArmoredPublicKey: pulumi.String("-----BEGIN PGP PUBLIC KEY BLOCK-----\n...\n-----END PGP PUBLIC KEY BLOCK-----"), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// GPG keys are not importable due to the fact that [API](https://developer.github.com/v3/users/gpg_keys/#gpg-keys) +// does not return previously uploaded GPG key. +type UserGpgKey struct { + pulumi.CustomResourceState + + // Your public GPG key, generated in ASCII-armored format. + // See [Generating a new GPG key](https://help.github.com/articles/generating-a-new-gpg-key/) for help on creating a GPG key. + ArmoredPublicKey pulumi.StringOutput `pulumi:"armoredPublicKey"` + Etag pulumi.StringOutput `pulumi:"etag"` + // The key ID of the GPG key, e.g. `3262EFF25BA0D270` + KeyId pulumi.StringOutput `pulumi:"keyId"` +} + +// NewUserGpgKey registers a new resource with the given unique name, arguments, and options. +func NewUserGpgKey(ctx *pulumi.Context, + name string, args *UserGpgKeyArgs, opts ...pulumi.ResourceOption) (*UserGpgKey, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.ArmoredPublicKey == nil { + return nil, errors.New("invalid value for required argument 'ArmoredPublicKey'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource UserGpgKey + err := ctx.RegisterResource("github:index/userGpgKey:UserGpgKey", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetUserGpgKey gets an existing UserGpgKey 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 GetUserGpgKey(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *UserGpgKeyState, opts ...pulumi.ResourceOption) (*UserGpgKey, error) { + var resource UserGpgKey + err := ctx.ReadResource("github:index/userGpgKey:UserGpgKey", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering UserGpgKey resources. +type userGpgKeyState struct { + // Your public GPG key, generated in ASCII-armored format. + // See [Generating a new GPG key](https://help.github.com/articles/generating-a-new-gpg-key/) for help on creating a GPG key. + ArmoredPublicKey *string `pulumi:"armoredPublicKey"` + Etag *string `pulumi:"etag"` + // The key ID of the GPG key, e.g. `3262EFF25BA0D270` + KeyId *string `pulumi:"keyId"` +} + +type UserGpgKeyState struct { + // Your public GPG key, generated in ASCII-armored format. + // See [Generating a new GPG key](https://help.github.com/articles/generating-a-new-gpg-key/) for help on creating a GPG key. + ArmoredPublicKey pulumi.StringPtrInput + Etag pulumi.StringPtrInput + // The key ID of the GPG key, e.g. `3262EFF25BA0D270` + KeyId pulumi.StringPtrInput +} + +func (UserGpgKeyState) ElementType() reflect.Type { + return reflect.TypeOf((*userGpgKeyState)(nil)).Elem() +} + +type userGpgKeyArgs struct { + // Your public GPG key, generated in ASCII-armored format. + // See [Generating a new GPG key](https://help.github.com/articles/generating-a-new-gpg-key/) for help on creating a GPG key. + ArmoredPublicKey string `pulumi:"armoredPublicKey"` +} + +// The set of arguments for constructing a UserGpgKey resource. +type UserGpgKeyArgs struct { + // Your public GPG key, generated in ASCII-armored format. + // See [Generating a new GPG key](https://help.github.com/articles/generating-a-new-gpg-key/) for help on creating a GPG key. + ArmoredPublicKey pulumi.StringInput +} + +func (UserGpgKeyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*userGpgKeyArgs)(nil)).Elem() +} + +type UserGpgKeyInput interface { + pulumi.Input + + ToUserGpgKeyOutput() UserGpgKeyOutput + ToUserGpgKeyOutputWithContext(ctx context.Context) UserGpgKeyOutput +} + +func (*UserGpgKey) ElementType() reflect.Type { + return reflect.TypeOf((**UserGpgKey)(nil)).Elem() +} + +func (i *UserGpgKey) ToUserGpgKeyOutput() UserGpgKeyOutput { + return i.ToUserGpgKeyOutputWithContext(context.Background()) +} + +func (i *UserGpgKey) ToUserGpgKeyOutputWithContext(ctx context.Context) UserGpgKeyOutput { + return pulumi.ToOutputWithContext(ctx, i).(UserGpgKeyOutput) +} + +// UserGpgKeyArrayInput is an input type that accepts UserGpgKeyArray and UserGpgKeyArrayOutput values. +// You can construct a concrete instance of `UserGpgKeyArrayInput` via: +// +// UserGpgKeyArray{ UserGpgKeyArgs{...} } +type UserGpgKeyArrayInput interface { + pulumi.Input + + ToUserGpgKeyArrayOutput() UserGpgKeyArrayOutput + ToUserGpgKeyArrayOutputWithContext(context.Context) UserGpgKeyArrayOutput +} + +type UserGpgKeyArray []UserGpgKeyInput + +func (UserGpgKeyArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*UserGpgKey)(nil)).Elem() +} + +func (i UserGpgKeyArray) ToUserGpgKeyArrayOutput() UserGpgKeyArrayOutput { + return i.ToUserGpgKeyArrayOutputWithContext(context.Background()) +} + +func (i UserGpgKeyArray) ToUserGpgKeyArrayOutputWithContext(ctx context.Context) UserGpgKeyArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(UserGpgKeyArrayOutput) +} + +// UserGpgKeyMapInput is an input type that accepts UserGpgKeyMap and UserGpgKeyMapOutput values. +// You can construct a concrete instance of `UserGpgKeyMapInput` via: +// +// UserGpgKeyMap{ "key": UserGpgKeyArgs{...} } +type UserGpgKeyMapInput interface { + pulumi.Input + + ToUserGpgKeyMapOutput() UserGpgKeyMapOutput + ToUserGpgKeyMapOutputWithContext(context.Context) UserGpgKeyMapOutput +} + +type UserGpgKeyMap map[string]UserGpgKeyInput + +func (UserGpgKeyMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*UserGpgKey)(nil)).Elem() +} + +func (i UserGpgKeyMap) ToUserGpgKeyMapOutput() UserGpgKeyMapOutput { + return i.ToUserGpgKeyMapOutputWithContext(context.Background()) +} + +func (i UserGpgKeyMap) ToUserGpgKeyMapOutputWithContext(ctx context.Context) UserGpgKeyMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(UserGpgKeyMapOutput) +} + +type UserGpgKeyOutput struct{ *pulumi.OutputState } + +func (UserGpgKeyOutput) ElementType() reflect.Type { + return reflect.TypeOf((**UserGpgKey)(nil)).Elem() +} + +func (o UserGpgKeyOutput) ToUserGpgKeyOutput() UserGpgKeyOutput { + return o +} + +func (o UserGpgKeyOutput) ToUserGpgKeyOutputWithContext(ctx context.Context) UserGpgKeyOutput { + return o +} + +// Your public GPG key, generated in ASCII-armored format. +// See [Generating a new GPG key](https://help.github.com/articles/generating-a-new-gpg-key/) for help on creating a GPG key. +func (o UserGpgKeyOutput) ArmoredPublicKey() pulumi.StringOutput { + return o.ApplyT(func(v *UserGpgKey) pulumi.StringOutput { return v.ArmoredPublicKey }).(pulumi.StringOutput) +} + +func (o UserGpgKeyOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *UserGpgKey) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// The key ID of the GPG key, e.g. `3262EFF25BA0D270` +func (o UserGpgKeyOutput) KeyId() pulumi.StringOutput { + return o.ApplyT(func(v *UserGpgKey) pulumi.StringOutput { return v.KeyId }).(pulumi.StringOutput) +} + +type UserGpgKeyArrayOutput struct{ *pulumi.OutputState } + +func (UserGpgKeyArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*UserGpgKey)(nil)).Elem() +} + +func (o UserGpgKeyArrayOutput) ToUserGpgKeyArrayOutput() UserGpgKeyArrayOutput { + return o +} + +func (o UserGpgKeyArrayOutput) ToUserGpgKeyArrayOutputWithContext(ctx context.Context) UserGpgKeyArrayOutput { + return o +} + +func (o UserGpgKeyArrayOutput) Index(i pulumi.IntInput) UserGpgKeyOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *UserGpgKey { + return vs[0].([]*UserGpgKey)[vs[1].(int)] + }).(UserGpgKeyOutput) +} + +type UserGpgKeyMapOutput struct{ *pulumi.OutputState } + +func (UserGpgKeyMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*UserGpgKey)(nil)).Elem() +} + +func (o UserGpgKeyMapOutput) ToUserGpgKeyMapOutput() UserGpgKeyMapOutput { + return o +} + +func (o UserGpgKeyMapOutput) ToUserGpgKeyMapOutputWithContext(ctx context.Context) UserGpgKeyMapOutput { + return o +} + +func (o UserGpgKeyMapOutput) MapIndex(k pulumi.StringInput) UserGpgKeyOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *UserGpgKey { + return vs[0].(map[string]*UserGpgKey)[vs[1].(string)] + }).(UserGpgKeyOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*UserGpgKeyInput)(nil)).Elem(), &UserGpgKey{}) + pulumi.RegisterInputType(reflect.TypeOf((*UserGpgKeyArrayInput)(nil)).Elem(), UserGpgKeyArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*UserGpgKeyMapInput)(nil)).Elem(), UserGpgKeyMap{}) + pulumi.RegisterOutputType(UserGpgKeyOutput{}) + pulumi.RegisterOutputType(UserGpgKeyArrayOutput{}) + pulumi.RegisterOutputType(UserGpgKeyMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/userInvitationAccepter.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/userInvitationAccepter.go new file mode 100644 index 000000000..6d170fc81 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/userInvitationAccepter.go @@ -0,0 +1,282 @@ +// Code generated by pulumi-language-go 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/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Provides a resource to manage GitHub repository collaborator invitations. +// +// ## Example Usage +// +// ```go +// 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("example-repo"), +// }) +// if err != nil { +// return err +// } +// exampleRepositoryCollaborator, err := github.NewRepositoryCollaborator(ctx, "example", &github.RepositoryCollaboratorArgs{ +// Repository: example.Name, +// Username: pulumi.String("example-username"), +// Permission: pulumi.String("push"), +// }) +// if err != nil { +// return err +// } +// _, err = github.NewUserInvitationAccepter(ctx, "example", &github.UserInvitationAccepterArgs{ +// InvitationId: exampleRepositoryCollaborator.InvitationId, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Allowing empty invitation IDs +// +// Set `allowEmptyId` when using `forEach` over a list of `github_repository_collaborator.invitation_id`'s. +// +// This allows applying a module again when a new `RepositoryCollaborator` resource is added to the `forEach` loop. +// This is needed as the `github_repository_collaborator.invitation_id` will be empty after a state refresh when the invitation has been accepted. +// +// Note that when an invitation is accepted manually or by another tool between a state refresh and a `pulumi up` using that refreshed state, +// the plan will contain the invitation ID, but the apply will receive an HTTP 404 from the API since the invitation has already been accepted. +// +// This is tracked in #1157. +type UserInvitationAccepter struct { + pulumi.CustomResourceState + + // Allow the ID to be unset. This will result in the resource being skipped when the ID is not set instead of returning an error. + AllowEmptyId pulumi.BoolPtrOutput `pulumi:"allowEmptyId"` + // ID of the invitation to accept. Must be set when `allowEmptyId` is `false`. + InvitationId pulumi.StringPtrOutput `pulumi:"invitationId"` +} + +// NewUserInvitationAccepter registers a new resource with the given unique name, arguments, and options. +func NewUserInvitationAccepter(ctx *pulumi.Context, + name string, args *UserInvitationAccepterArgs, opts ...pulumi.ResourceOption) (*UserInvitationAccepter, error) { + if args == nil { + args = &UserInvitationAccepterArgs{} + } + + opts = internal.PkgResourceDefaultOpts(opts) + var resource UserInvitationAccepter + err := ctx.RegisterResource("github:index/userInvitationAccepter:UserInvitationAccepter", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetUserInvitationAccepter gets an existing UserInvitationAccepter 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 GetUserInvitationAccepter(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *UserInvitationAccepterState, opts ...pulumi.ResourceOption) (*UserInvitationAccepter, error) { + var resource UserInvitationAccepter + err := ctx.ReadResource("github:index/userInvitationAccepter:UserInvitationAccepter", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering UserInvitationAccepter resources. +type userInvitationAccepterState struct { + // Allow the ID to be unset. This will result in the resource being skipped when the ID is not set instead of returning an error. + AllowEmptyId *bool `pulumi:"allowEmptyId"` + // ID of the invitation to accept. Must be set when `allowEmptyId` is `false`. + InvitationId *string `pulumi:"invitationId"` +} + +type UserInvitationAccepterState struct { + // Allow the ID to be unset. This will result in the resource being skipped when the ID is not set instead of returning an error. + AllowEmptyId pulumi.BoolPtrInput + // ID of the invitation to accept. Must be set when `allowEmptyId` is `false`. + InvitationId pulumi.StringPtrInput +} + +func (UserInvitationAccepterState) ElementType() reflect.Type { + return reflect.TypeOf((*userInvitationAccepterState)(nil)).Elem() +} + +type userInvitationAccepterArgs struct { + // Allow the ID to be unset. This will result in the resource being skipped when the ID is not set instead of returning an error. + AllowEmptyId *bool `pulumi:"allowEmptyId"` + // ID of the invitation to accept. Must be set when `allowEmptyId` is `false`. + InvitationId *string `pulumi:"invitationId"` +} + +// The set of arguments for constructing a UserInvitationAccepter resource. +type UserInvitationAccepterArgs struct { + // Allow the ID to be unset. This will result in the resource being skipped when the ID is not set instead of returning an error. + AllowEmptyId pulumi.BoolPtrInput + // ID of the invitation to accept. Must be set when `allowEmptyId` is `false`. + InvitationId pulumi.StringPtrInput +} + +func (UserInvitationAccepterArgs) ElementType() reflect.Type { + return reflect.TypeOf((*userInvitationAccepterArgs)(nil)).Elem() +} + +type UserInvitationAccepterInput interface { + pulumi.Input + + ToUserInvitationAccepterOutput() UserInvitationAccepterOutput + ToUserInvitationAccepterOutputWithContext(ctx context.Context) UserInvitationAccepterOutput +} + +func (*UserInvitationAccepter) ElementType() reflect.Type { + return reflect.TypeOf((**UserInvitationAccepter)(nil)).Elem() +} + +func (i *UserInvitationAccepter) ToUserInvitationAccepterOutput() UserInvitationAccepterOutput { + return i.ToUserInvitationAccepterOutputWithContext(context.Background()) +} + +func (i *UserInvitationAccepter) ToUserInvitationAccepterOutputWithContext(ctx context.Context) UserInvitationAccepterOutput { + return pulumi.ToOutputWithContext(ctx, i).(UserInvitationAccepterOutput) +} + +// UserInvitationAccepterArrayInput is an input type that accepts UserInvitationAccepterArray and UserInvitationAccepterArrayOutput values. +// You can construct a concrete instance of `UserInvitationAccepterArrayInput` via: +// +// UserInvitationAccepterArray{ UserInvitationAccepterArgs{...} } +type UserInvitationAccepterArrayInput interface { + pulumi.Input + + ToUserInvitationAccepterArrayOutput() UserInvitationAccepterArrayOutput + ToUserInvitationAccepterArrayOutputWithContext(context.Context) UserInvitationAccepterArrayOutput +} + +type UserInvitationAccepterArray []UserInvitationAccepterInput + +func (UserInvitationAccepterArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*UserInvitationAccepter)(nil)).Elem() +} + +func (i UserInvitationAccepterArray) ToUserInvitationAccepterArrayOutput() UserInvitationAccepterArrayOutput { + return i.ToUserInvitationAccepterArrayOutputWithContext(context.Background()) +} + +func (i UserInvitationAccepterArray) ToUserInvitationAccepterArrayOutputWithContext(ctx context.Context) UserInvitationAccepterArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(UserInvitationAccepterArrayOutput) +} + +// UserInvitationAccepterMapInput is an input type that accepts UserInvitationAccepterMap and UserInvitationAccepterMapOutput values. +// You can construct a concrete instance of `UserInvitationAccepterMapInput` via: +// +// UserInvitationAccepterMap{ "key": UserInvitationAccepterArgs{...} } +type UserInvitationAccepterMapInput interface { + pulumi.Input + + ToUserInvitationAccepterMapOutput() UserInvitationAccepterMapOutput + ToUserInvitationAccepterMapOutputWithContext(context.Context) UserInvitationAccepterMapOutput +} + +type UserInvitationAccepterMap map[string]UserInvitationAccepterInput + +func (UserInvitationAccepterMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*UserInvitationAccepter)(nil)).Elem() +} + +func (i UserInvitationAccepterMap) ToUserInvitationAccepterMapOutput() UserInvitationAccepterMapOutput { + return i.ToUserInvitationAccepterMapOutputWithContext(context.Background()) +} + +func (i UserInvitationAccepterMap) ToUserInvitationAccepterMapOutputWithContext(ctx context.Context) UserInvitationAccepterMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(UserInvitationAccepterMapOutput) +} + +type UserInvitationAccepterOutput struct{ *pulumi.OutputState } + +func (UserInvitationAccepterOutput) ElementType() reflect.Type { + return reflect.TypeOf((**UserInvitationAccepter)(nil)).Elem() +} + +func (o UserInvitationAccepterOutput) ToUserInvitationAccepterOutput() UserInvitationAccepterOutput { + return o +} + +func (o UserInvitationAccepterOutput) ToUserInvitationAccepterOutputWithContext(ctx context.Context) UserInvitationAccepterOutput { + return o +} + +// Allow the ID to be unset. This will result in the resource being skipped when the ID is not set instead of returning an error. +func (o UserInvitationAccepterOutput) AllowEmptyId() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *UserInvitationAccepter) pulumi.BoolPtrOutput { return v.AllowEmptyId }).(pulumi.BoolPtrOutput) +} + +// ID of the invitation to accept. Must be set when `allowEmptyId` is `false`. +func (o UserInvitationAccepterOutput) InvitationId() pulumi.StringPtrOutput { + return o.ApplyT(func(v *UserInvitationAccepter) pulumi.StringPtrOutput { return v.InvitationId }).(pulumi.StringPtrOutput) +} + +type UserInvitationAccepterArrayOutput struct{ *pulumi.OutputState } + +func (UserInvitationAccepterArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*UserInvitationAccepter)(nil)).Elem() +} + +func (o UserInvitationAccepterArrayOutput) ToUserInvitationAccepterArrayOutput() UserInvitationAccepterArrayOutput { + return o +} + +func (o UserInvitationAccepterArrayOutput) ToUserInvitationAccepterArrayOutputWithContext(ctx context.Context) UserInvitationAccepterArrayOutput { + return o +} + +func (o UserInvitationAccepterArrayOutput) Index(i pulumi.IntInput) UserInvitationAccepterOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *UserInvitationAccepter { + return vs[0].([]*UserInvitationAccepter)[vs[1].(int)] + }).(UserInvitationAccepterOutput) +} + +type UserInvitationAccepterMapOutput struct{ *pulumi.OutputState } + +func (UserInvitationAccepterMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*UserInvitationAccepter)(nil)).Elem() +} + +func (o UserInvitationAccepterMapOutput) ToUserInvitationAccepterMapOutput() UserInvitationAccepterMapOutput { + return o +} + +func (o UserInvitationAccepterMapOutput) ToUserInvitationAccepterMapOutputWithContext(ctx context.Context) UserInvitationAccepterMapOutput { + return o +} + +func (o UserInvitationAccepterMapOutput) MapIndex(k pulumi.StringInput) UserInvitationAccepterOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *UserInvitationAccepter { + return vs[0].(map[string]*UserInvitationAccepter)[vs[1].(string)] + }).(UserInvitationAccepterOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*UserInvitationAccepterInput)(nil)).Elem(), &UserInvitationAccepter{}) + pulumi.RegisterInputType(reflect.TypeOf((*UserInvitationAccepterArrayInput)(nil)).Elem(), UserInvitationAccepterArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*UserInvitationAccepterMapInput)(nil)).Elem(), UserInvitationAccepterMap{}) + pulumi.RegisterOutputType(UserInvitationAccepterOutput{}) + pulumi.RegisterOutputType(UserInvitationAccepterArrayOutput{}) + pulumi.RegisterOutputType(UserInvitationAccepterMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/userSshKey.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/userSshKey.go new file mode 100644 index 000000000..27dc64f20 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/userSshKey.go @@ -0,0 +1,299 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// Provides a GitHub user's SSH key resource. +// +// This resource allows you to add/remove SSH keys from your user account. +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi-github/sdk/v6/go/github" +// "github.com/pulumi/pulumi-std/sdk/go/std" +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// invokeFile, err := std.File(ctx, &std.FileArgs{ +// Input: "~/.ssh/id_rsa.pub", +// }, nil) +// if err != nil { +// return err +// } +// _, err = github.NewUserSshKey(ctx, "example", &github.UserSshKeyArgs{ +// Title: pulumi.String("example title"), +// Key: pulumi.String(invokeFile.Result), +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// SSH keys can be imported using their ID e.g. +// +// ```sh +// $ pulumi import github:index/userSshKey:UserSshKey example 1234567 +// ``` +type UserSshKey struct { + pulumi.CustomResourceState + + Etag pulumi.StringOutput `pulumi:"etag"` + // The public SSH key to add to your GitHub account. + Key pulumi.StringOutput `pulumi:"key"` + // A descriptive name for the new key. e.g. `Personal MacBook Air` + Title pulumi.StringOutput `pulumi:"title"` + // The URL of the SSH key + Url pulumi.StringOutput `pulumi:"url"` +} + +// NewUserSshKey registers a new resource with the given unique name, arguments, and options. +func NewUserSshKey(ctx *pulumi.Context, + name string, args *UserSshKeyArgs, opts ...pulumi.ResourceOption) (*UserSshKey, error) { + if args == nil { + return nil, errors.New("missing one or more required arguments") + } + + if args.Key == nil { + return nil, errors.New("invalid value for required argument 'Key'") + } + if args.Title == nil { + return nil, errors.New("invalid value for required argument 'Title'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource UserSshKey + err := ctx.RegisterResource("github:index/userSshKey:UserSshKey", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetUserSshKey gets an existing UserSshKey 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 GetUserSshKey(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *UserSshKeyState, opts ...pulumi.ResourceOption) (*UserSshKey, error) { + var resource UserSshKey + err := ctx.ReadResource("github:index/userSshKey:UserSshKey", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering UserSshKey resources. +type userSshKeyState struct { + Etag *string `pulumi:"etag"` + // The public SSH key to add to your GitHub account. + Key *string `pulumi:"key"` + // A descriptive name for the new key. e.g. `Personal MacBook Air` + Title *string `pulumi:"title"` + // The URL of the SSH key + Url *string `pulumi:"url"` +} + +type UserSshKeyState struct { + Etag pulumi.StringPtrInput + // The public SSH key to add to your GitHub account. + Key pulumi.StringPtrInput + // A descriptive name for the new key. e.g. `Personal MacBook Air` + Title pulumi.StringPtrInput + // The URL of the SSH key + Url pulumi.StringPtrInput +} + +func (UserSshKeyState) ElementType() reflect.Type { + return reflect.TypeOf((*userSshKeyState)(nil)).Elem() +} + +type userSshKeyArgs struct { + // The public SSH key to add to your GitHub account. + Key string `pulumi:"key"` + // A descriptive name for the new key. e.g. `Personal MacBook Air` + Title string `pulumi:"title"` +} + +// The set of arguments for constructing a UserSshKey resource. +type UserSshKeyArgs struct { + // The public SSH key to add to your GitHub account. + Key pulumi.StringInput + // A descriptive name for the new key. e.g. `Personal MacBook Air` + Title pulumi.StringInput +} + +func (UserSshKeyArgs) ElementType() reflect.Type { + return reflect.TypeOf((*userSshKeyArgs)(nil)).Elem() +} + +type UserSshKeyInput interface { + pulumi.Input + + ToUserSshKeyOutput() UserSshKeyOutput + ToUserSshKeyOutputWithContext(ctx context.Context) UserSshKeyOutput +} + +func (*UserSshKey) ElementType() reflect.Type { + return reflect.TypeOf((**UserSshKey)(nil)).Elem() +} + +func (i *UserSshKey) ToUserSshKeyOutput() UserSshKeyOutput { + return i.ToUserSshKeyOutputWithContext(context.Background()) +} + +func (i *UserSshKey) ToUserSshKeyOutputWithContext(ctx context.Context) UserSshKeyOutput { + return pulumi.ToOutputWithContext(ctx, i).(UserSshKeyOutput) +} + +// UserSshKeyArrayInput is an input type that accepts UserSshKeyArray and UserSshKeyArrayOutput values. +// You can construct a concrete instance of `UserSshKeyArrayInput` via: +// +// UserSshKeyArray{ UserSshKeyArgs{...} } +type UserSshKeyArrayInput interface { + pulumi.Input + + ToUserSshKeyArrayOutput() UserSshKeyArrayOutput + ToUserSshKeyArrayOutputWithContext(context.Context) UserSshKeyArrayOutput +} + +type UserSshKeyArray []UserSshKeyInput + +func (UserSshKeyArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*UserSshKey)(nil)).Elem() +} + +func (i UserSshKeyArray) ToUserSshKeyArrayOutput() UserSshKeyArrayOutput { + return i.ToUserSshKeyArrayOutputWithContext(context.Background()) +} + +func (i UserSshKeyArray) ToUserSshKeyArrayOutputWithContext(ctx context.Context) UserSshKeyArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(UserSshKeyArrayOutput) +} + +// UserSshKeyMapInput is an input type that accepts UserSshKeyMap and UserSshKeyMapOutput values. +// You can construct a concrete instance of `UserSshKeyMapInput` via: +// +// UserSshKeyMap{ "key": UserSshKeyArgs{...} } +type UserSshKeyMapInput interface { + pulumi.Input + + ToUserSshKeyMapOutput() UserSshKeyMapOutput + ToUserSshKeyMapOutputWithContext(context.Context) UserSshKeyMapOutput +} + +type UserSshKeyMap map[string]UserSshKeyInput + +func (UserSshKeyMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*UserSshKey)(nil)).Elem() +} + +func (i UserSshKeyMap) ToUserSshKeyMapOutput() UserSshKeyMapOutput { + return i.ToUserSshKeyMapOutputWithContext(context.Background()) +} + +func (i UserSshKeyMap) ToUserSshKeyMapOutputWithContext(ctx context.Context) UserSshKeyMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(UserSshKeyMapOutput) +} + +type UserSshKeyOutput struct{ *pulumi.OutputState } + +func (UserSshKeyOutput) ElementType() reflect.Type { + return reflect.TypeOf((**UserSshKey)(nil)).Elem() +} + +func (o UserSshKeyOutput) ToUserSshKeyOutput() UserSshKeyOutput { + return o +} + +func (o UserSshKeyOutput) ToUserSshKeyOutputWithContext(ctx context.Context) UserSshKeyOutput { + return o +} + +func (o UserSshKeyOutput) Etag() pulumi.StringOutput { + return o.ApplyT(func(v *UserSshKey) pulumi.StringOutput { return v.Etag }).(pulumi.StringOutput) +} + +// The public SSH key to add to your GitHub account. +func (o UserSshKeyOutput) Key() pulumi.StringOutput { + return o.ApplyT(func(v *UserSshKey) pulumi.StringOutput { return v.Key }).(pulumi.StringOutput) +} + +// A descriptive name for the new key. e.g. `Personal MacBook Air` +func (o UserSshKeyOutput) Title() pulumi.StringOutput { + return o.ApplyT(func(v *UserSshKey) pulumi.StringOutput { return v.Title }).(pulumi.StringOutput) +} + +// The URL of the SSH key +func (o UserSshKeyOutput) Url() pulumi.StringOutput { + return o.ApplyT(func(v *UserSshKey) pulumi.StringOutput { return v.Url }).(pulumi.StringOutput) +} + +type UserSshKeyArrayOutput struct{ *pulumi.OutputState } + +func (UserSshKeyArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*UserSshKey)(nil)).Elem() +} + +func (o UserSshKeyArrayOutput) ToUserSshKeyArrayOutput() UserSshKeyArrayOutput { + return o +} + +func (o UserSshKeyArrayOutput) ToUserSshKeyArrayOutputWithContext(ctx context.Context) UserSshKeyArrayOutput { + return o +} + +func (o UserSshKeyArrayOutput) Index(i pulumi.IntInput) UserSshKeyOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *UserSshKey { + return vs[0].([]*UserSshKey)[vs[1].(int)] + }).(UserSshKeyOutput) +} + +type UserSshKeyMapOutput struct{ *pulumi.OutputState } + +func (UserSshKeyMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*UserSshKey)(nil)).Elem() +} + +func (o UserSshKeyMapOutput) ToUserSshKeyMapOutput() UserSshKeyMapOutput { + return o +} + +func (o UserSshKeyMapOutput) ToUserSshKeyMapOutputWithContext(ctx context.Context) UserSshKeyMapOutput { + return o +} + +func (o UserSshKeyMapOutput) MapIndex(k pulumi.StringInput) UserSshKeyOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *UserSshKey { + return vs[0].(map[string]*UserSshKey)[vs[1].(string)] + }).(UserSshKeyOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*UserSshKeyInput)(nil)).Elem(), &UserSshKey{}) + pulumi.RegisterInputType(reflect.TypeOf((*UserSshKeyArrayInput)(nil)).Elem(), UserSshKeyArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*UserSshKeyMapInput)(nil)).Elem(), UserSshKeyMap{}) + pulumi.RegisterOutputType(UserSshKeyOutput{}) + pulumi.RegisterOutputType(UserSshKeyArrayOutput{}) + pulumi.RegisterOutputType(UserSshKeyMapOutput{}) +} diff --git a/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/workflowRepositoryPermissions.go b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/workflowRepositoryPermissions.go new file mode 100644 index 000000000..24fa0cd83 --- /dev/null +++ b/vendor/github.com/pulumi/pulumi-github/sdk/v6/go/github/workflowRepositoryPermissions.go @@ -0,0 +1,292 @@ +// Code generated by pulumi-language-go DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package github + +import ( + "context" + "reflect" + + "errors" + "github.com/pulumi/pulumi-github/sdk/v6/go/github/internal" + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +) + +// This resource allows you to manage GitHub Workflow permissions for a given repository. +// You must have admin access to a repository to use this resource. +// +// ## Example Usage +// +// ```go +// 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.NewWorkflowRepositoryPermissions(ctx, "test", &github.WorkflowRepositoryPermissionsArgs{ +// DefaultWorkflowPermissions: pulumi.String("read"), +// CanApprovePullRequestReviews: pulumi.Bool(true), +// Repository: example.Name, +// }) +// if err != nil { +// return err +// } +// return nil +// }) +// } +// +// ``` +// +// ## Import +// +// This resource can be imported using the name of the GitHub repository: +// +// ```sh +// $ pulumi import github:index/workflowRepositoryPermissions:WorkflowRepositoryPermissions test my-repository +// ``` +type WorkflowRepositoryPermissions struct { + pulumi.CustomResourceState + + // Whether GitHub Actions can approve pull requests. Enabling this can be a security risk. + CanApprovePullRequestReviews pulumi.BoolPtrOutput `pulumi:"canApprovePullRequestReviews"` + // The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be one of: `read` or `write`. + DefaultWorkflowPermissions pulumi.StringPtrOutput `pulumi:"defaultWorkflowPermissions"` + // The GitHub repository + Repository pulumi.StringOutput `pulumi:"repository"` +} + +// NewWorkflowRepositoryPermissions registers a new resource with the given unique name, arguments, and options. +func NewWorkflowRepositoryPermissions(ctx *pulumi.Context, + name string, args *WorkflowRepositoryPermissionsArgs, opts ...pulumi.ResourceOption) (*WorkflowRepositoryPermissions, 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'") + } + opts = internal.PkgResourceDefaultOpts(opts) + var resource WorkflowRepositoryPermissions + err := ctx.RegisterResource("github:index/workflowRepositoryPermissions:WorkflowRepositoryPermissions", name, args, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// GetWorkflowRepositoryPermissions gets an existing WorkflowRepositoryPermissions 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 GetWorkflowRepositoryPermissions(ctx *pulumi.Context, + name string, id pulumi.IDInput, state *WorkflowRepositoryPermissionsState, opts ...pulumi.ResourceOption) (*WorkflowRepositoryPermissions, error) { + var resource WorkflowRepositoryPermissions + err := ctx.ReadResource("github:index/workflowRepositoryPermissions:WorkflowRepositoryPermissions", name, id, state, &resource, opts...) + if err != nil { + return nil, err + } + return &resource, nil +} + +// Input properties used for looking up and filtering WorkflowRepositoryPermissions resources. +type workflowRepositoryPermissionsState struct { + // Whether GitHub Actions can approve pull requests. Enabling this can be a security risk. + CanApprovePullRequestReviews *bool `pulumi:"canApprovePullRequestReviews"` + // The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be one of: `read` or `write`. + DefaultWorkflowPermissions *string `pulumi:"defaultWorkflowPermissions"` + // The GitHub repository + Repository *string `pulumi:"repository"` +} + +type WorkflowRepositoryPermissionsState struct { + // Whether GitHub Actions can approve pull requests. Enabling this can be a security risk. + CanApprovePullRequestReviews pulumi.BoolPtrInput + // The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be one of: `read` or `write`. + DefaultWorkflowPermissions pulumi.StringPtrInput + // The GitHub repository + Repository pulumi.StringPtrInput +} + +func (WorkflowRepositoryPermissionsState) ElementType() reflect.Type { + return reflect.TypeOf((*workflowRepositoryPermissionsState)(nil)).Elem() +} + +type workflowRepositoryPermissionsArgs struct { + // Whether GitHub Actions can approve pull requests. Enabling this can be a security risk. + CanApprovePullRequestReviews *bool `pulumi:"canApprovePullRequestReviews"` + // The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be one of: `read` or `write`. + DefaultWorkflowPermissions *string `pulumi:"defaultWorkflowPermissions"` + // The GitHub repository + Repository string `pulumi:"repository"` +} + +// The set of arguments for constructing a WorkflowRepositoryPermissions resource. +type WorkflowRepositoryPermissionsArgs struct { + // Whether GitHub Actions can approve pull requests. Enabling this can be a security risk. + CanApprovePullRequestReviews pulumi.BoolPtrInput + // The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be one of: `read` or `write`. + DefaultWorkflowPermissions pulumi.StringPtrInput + // The GitHub repository + Repository pulumi.StringInput +} + +func (WorkflowRepositoryPermissionsArgs) ElementType() reflect.Type { + return reflect.TypeOf((*workflowRepositoryPermissionsArgs)(nil)).Elem() +} + +type WorkflowRepositoryPermissionsInput interface { + pulumi.Input + + ToWorkflowRepositoryPermissionsOutput() WorkflowRepositoryPermissionsOutput + ToWorkflowRepositoryPermissionsOutputWithContext(ctx context.Context) WorkflowRepositoryPermissionsOutput +} + +func (*WorkflowRepositoryPermissions) ElementType() reflect.Type { + return reflect.TypeOf((**WorkflowRepositoryPermissions)(nil)).Elem() +} + +func (i *WorkflowRepositoryPermissions) ToWorkflowRepositoryPermissionsOutput() WorkflowRepositoryPermissionsOutput { + return i.ToWorkflowRepositoryPermissionsOutputWithContext(context.Background()) +} + +func (i *WorkflowRepositoryPermissions) ToWorkflowRepositoryPermissionsOutputWithContext(ctx context.Context) WorkflowRepositoryPermissionsOutput { + return pulumi.ToOutputWithContext(ctx, i).(WorkflowRepositoryPermissionsOutput) +} + +// WorkflowRepositoryPermissionsArrayInput is an input type that accepts WorkflowRepositoryPermissionsArray and WorkflowRepositoryPermissionsArrayOutput values. +// You can construct a concrete instance of `WorkflowRepositoryPermissionsArrayInput` via: +// +// WorkflowRepositoryPermissionsArray{ WorkflowRepositoryPermissionsArgs{...} } +type WorkflowRepositoryPermissionsArrayInput interface { + pulumi.Input + + ToWorkflowRepositoryPermissionsArrayOutput() WorkflowRepositoryPermissionsArrayOutput + ToWorkflowRepositoryPermissionsArrayOutputWithContext(context.Context) WorkflowRepositoryPermissionsArrayOutput +} + +type WorkflowRepositoryPermissionsArray []WorkflowRepositoryPermissionsInput + +func (WorkflowRepositoryPermissionsArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]*WorkflowRepositoryPermissions)(nil)).Elem() +} + +func (i WorkflowRepositoryPermissionsArray) ToWorkflowRepositoryPermissionsArrayOutput() WorkflowRepositoryPermissionsArrayOutput { + return i.ToWorkflowRepositoryPermissionsArrayOutputWithContext(context.Background()) +} + +func (i WorkflowRepositoryPermissionsArray) ToWorkflowRepositoryPermissionsArrayOutputWithContext(ctx context.Context) WorkflowRepositoryPermissionsArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(WorkflowRepositoryPermissionsArrayOutput) +} + +// WorkflowRepositoryPermissionsMapInput is an input type that accepts WorkflowRepositoryPermissionsMap and WorkflowRepositoryPermissionsMapOutput values. +// You can construct a concrete instance of `WorkflowRepositoryPermissionsMapInput` via: +// +// WorkflowRepositoryPermissionsMap{ "key": WorkflowRepositoryPermissionsArgs{...} } +type WorkflowRepositoryPermissionsMapInput interface { + pulumi.Input + + ToWorkflowRepositoryPermissionsMapOutput() WorkflowRepositoryPermissionsMapOutput + ToWorkflowRepositoryPermissionsMapOutputWithContext(context.Context) WorkflowRepositoryPermissionsMapOutput +} + +type WorkflowRepositoryPermissionsMap map[string]WorkflowRepositoryPermissionsInput + +func (WorkflowRepositoryPermissionsMap) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*WorkflowRepositoryPermissions)(nil)).Elem() +} + +func (i WorkflowRepositoryPermissionsMap) ToWorkflowRepositoryPermissionsMapOutput() WorkflowRepositoryPermissionsMapOutput { + return i.ToWorkflowRepositoryPermissionsMapOutputWithContext(context.Background()) +} + +func (i WorkflowRepositoryPermissionsMap) ToWorkflowRepositoryPermissionsMapOutputWithContext(ctx context.Context) WorkflowRepositoryPermissionsMapOutput { + return pulumi.ToOutputWithContext(ctx, i).(WorkflowRepositoryPermissionsMapOutput) +} + +type WorkflowRepositoryPermissionsOutput struct{ *pulumi.OutputState } + +func (WorkflowRepositoryPermissionsOutput) ElementType() reflect.Type { + return reflect.TypeOf((**WorkflowRepositoryPermissions)(nil)).Elem() +} + +func (o WorkflowRepositoryPermissionsOutput) ToWorkflowRepositoryPermissionsOutput() WorkflowRepositoryPermissionsOutput { + return o +} + +func (o WorkflowRepositoryPermissionsOutput) ToWorkflowRepositoryPermissionsOutputWithContext(ctx context.Context) WorkflowRepositoryPermissionsOutput { + return o +} + +// Whether GitHub Actions can approve pull requests. Enabling this can be a security risk. +func (o WorkflowRepositoryPermissionsOutput) CanApprovePullRequestReviews() pulumi.BoolPtrOutput { + return o.ApplyT(func(v *WorkflowRepositoryPermissions) pulumi.BoolPtrOutput { return v.CanApprovePullRequestReviews }).(pulumi.BoolPtrOutput) +} + +// The default workflow permissions granted to the GITHUB_TOKEN when running workflows. Can be one of: `read` or `write`. +func (o WorkflowRepositoryPermissionsOutput) DefaultWorkflowPermissions() pulumi.StringPtrOutput { + return o.ApplyT(func(v *WorkflowRepositoryPermissions) pulumi.StringPtrOutput { return v.DefaultWorkflowPermissions }).(pulumi.StringPtrOutput) +} + +// The GitHub repository +func (o WorkflowRepositoryPermissionsOutput) Repository() pulumi.StringOutput { + return o.ApplyT(func(v *WorkflowRepositoryPermissions) pulumi.StringOutput { return v.Repository }).(pulumi.StringOutput) +} + +type WorkflowRepositoryPermissionsArrayOutput struct{ *pulumi.OutputState } + +func (WorkflowRepositoryPermissionsArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]*WorkflowRepositoryPermissions)(nil)).Elem() +} + +func (o WorkflowRepositoryPermissionsArrayOutput) ToWorkflowRepositoryPermissionsArrayOutput() WorkflowRepositoryPermissionsArrayOutput { + return o +} + +func (o WorkflowRepositoryPermissionsArrayOutput) ToWorkflowRepositoryPermissionsArrayOutputWithContext(ctx context.Context) WorkflowRepositoryPermissionsArrayOutput { + return o +} + +func (o WorkflowRepositoryPermissionsArrayOutput) Index(i pulumi.IntInput) WorkflowRepositoryPermissionsOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) *WorkflowRepositoryPermissions { + return vs[0].([]*WorkflowRepositoryPermissions)[vs[1].(int)] + }).(WorkflowRepositoryPermissionsOutput) +} + +type WorkflowRepositoryPermissionsMapOutput struct{ *pulumi.OutputState } + +func (WorkflowRepositoryPermissionsMapOutput) ElementType() reflect.Type { + return reflect.TypeOf((*map[string]*WorkflowRepositoryPermissions)(nil)).Elem() +} + +func (o WorkflowRepositoryPermissionsMapOutput) ToWorkflowRepositoryPermissionsMapOutput() WorkflowRepositoryPermissionsMapOutput { + return o +} + +func (o WorkflowRepositoryPermissionsMapOutput) ToWorkflowRepositoryPermissionsMapOutputWithContext(ctx context.Context) WorkflowRepositoryPermissionsMapOutput { + return o +} + +func (o WorkflowRepositoryPermissionsMapOutput) MapIndex(k pulumi.StringInput) WorkflowRepositoryPermissionsOutput { + return pulumi.All(o, k).ApplyT(func(vs []interface{}) *WorkflowRepositoryPermissions { + return vs[0].(map[string]*WorkflowRepositoryPermissions)[vs[1].(string)] + }).(WorkflowRepositoryPermissionsOutput) +} + +func init() { + pulumi.RegisterInputType(reflect.TypeOf((*WorkflowRepositoryPermissionsInput)(nil)).Elem(), &WorkflowRepositoryPermissions{}) + pulumi.RegisterInputType(reflect.TypeOf((*WorkflowRepositoryPermissionsArrayInput)(nil)).Elem(), WorkflowRepositoryPermissionsArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*WorkflowRepositoryPermissionsMapInput)(nil)).Elem(), WorkflowRepositoryPermissionsMap{}) + pulumi.RegisterOutputType(WorkflowRepositoryPermissionsOutput{}) + pulumi.RegisterOutputType(WorkflowRepositoryPermissionsArrayOutput{}) + pulumi.RegisterOutputType(WorkflowRepositoryPermissionsMapOutput{}) +} diff --git a/vendor/modules.txt b/vendor/modules.txt index 6d7f4bb50..6f6e062f5 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -927,6 +927,10 @@ github.com/pulumi/pulumi-docker-build/sdk/go/dockerbuild/internal ## explicit; go 1.21 github.com/pulumi/pulumi-docker/sdk/v4/go/docker github.com/pulumi/pulumi-docker/sdk/v4/go/docker/internal +# github.com/pulumi/pulumi-github/sdk/v6 v6.14.0 +## explicit; go 1.25.8 +github.com/pulumi/pulumi-github/sdk/v6/go/github +github.com/pulumi/pulumi-github/sdk/v6/go/github/internal # github.com/pulumi/pulumi-gitlab/sdk/v9 v9.11.1 ## explicit; go 1.25.8 github.com/pulumi/pulumi-gitlab/sdk/v9/go/gitlab