Update dependencies

This change updates all dependencies.

Signed-off-by: Gabriel Adrian Samfira <gsamfira@cloudbasesolutions.com>

vendor/github.com/google/go-github/v69/github/actions.go

@@ -0,0 +1,12 @@
+// Copyright 2020 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+// ActionsService handles communication with the actions related
+// methods of the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/
+type ActionsService service

vendor/github.com/google/go-github/v69/github/actions_artifacts.go

@@ -0,0 +1,205 @@
+// Copyright 2020 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+)
+
+// ArtifactWorkflowRun represents a GitHub artifact's workflow run.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/artifacts
+type ArtifactWorkflowRun struct {
+	ID               *int64  `json:"id,omitempty"`
+	RepositoryID     *int64  `json:"repository_id,omitempty"`
+	HeadRepositoryID *int64  `json:"head_repository_id,omitempty"`
+	HeadBranch       *string `json:"head_branch,omitempty"`
+	HeadSHA          *string `json:"head_sha,omitempty"`
+}
+
+// Artifact represents a GitHub artifact.  Artifacts allow sharing
+// data between jobs in a workflow and provide storage for data
+// once a workflow is complete.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/artifacts
+type Artifact struct {
+	ID                 *int64               `json:"id,omitempty"`
+	NodeID             *string              `json:"node_id,omitempty"`
+	Name               *string              `json:"name,omitempty"`
+	SizeInBytes        *int64               `json:"size_in_bytes,omitempty"`
+	URL                *string              `json:"url,omitempty"`
+	ArchiveDownloadURL *string              `json:"archive_download_url,omitempty"`
+	Expired            *bool                `json:"expired,omitempty"`
+	CreatedAt          *Timestamp           `json:"created_at,omitempty"`
+	UpdatedAt          *Timestamp           `json:"updated_at,omitempty"`
+	ExpiresAt          *Timestamp           `json:"expires_at,omitempty"`
+	WorkflowRun        *ArtifactWorkflowRun `json:"workflow_run,omitempty"`
+}
+
+// ArtifactList represents a list of GitHub artifacts.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/artifacts#artifacts
+type ArtifactList struct {
+	TotalCount *int64      `json:"total_count,omitempty"`
+	Artifacts  []*Artifact `json:"artifacts,omitempty"`
+}
+
+// ListArtifactsOptions specifies the optional parameters to the
+// ActionsService.ListArtifacts method.
+type ListArtifactsOptions struct {
+	// Name represents the name field of an artifact.
+	// When specified, only artifacts with this name will be returned.
+	Name *string `url:"name,omitempty"`
+
+	ListOptions
+}
+
+// ListArtifacts lists all artifacts that belong to a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/artifacts#list-artifacts-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/artifacts
+func (s *ActionsService) ListArtifacts(ctx context.Context, owner, repo string, opts *ListArtifactsOptions) (*ArtifactList, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/artifacts", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	artifactList := new(ArtifactList)
+	resp, err := s.client.Do(ctx, req, artifactList)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return artifactList, resp, nil
+}
+
+// ListWorkflowRunArtifacts lists all artifacts that belong to a workflow run.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/artifacts#list-workflow-run-artifacts
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/runs/{run_id}/artifacts
+func (s *ActionsService) ListWorkflowRunArtifacts(ctx context.Context, owner, repo string, runID int64, opts *ListOptions) (*ArtifactList, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runs/%v/artifacts", owner, repo, runID)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	artifactList := new(ArtifactList)
+	resp, err := s.client.Do(ctx, req, artifactList)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return artifactList, resp, nil
+}
+
+// GetArtifact gets a specific artifact for a workflow run.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/artifacts#get-an-artifact
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}
+func (s *ActionsService) GetArtifact(ctx context.Context, owner, repo string, artifactID int64) (*Artifact, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/artifacts/%v", owner, repo, artifactID)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	artifact := new(Artifact)
+	resp, err := s.client.Do(ctx, req, artifact)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return artifact, resp, nil
+}
+
+// DownloadArtifact gets a redirect URL to download an archive for a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/artifacts#download-an-artifact
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/artifacts/{artifact_id}/{archive_format}
+func (s *ActionsService) DownloadArtifact(ctx context.Context, owner, repo string, artifactID int64, maxRedirects int) (*url.URL, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/artifacts/%v/zip", owner, repo, artifactID)
+
+	if s.client.RateLimitRedirectionalEndpoints {
+		return s.downloadArtifactWithRateLimit(ctx, u, maxRedirects)
+	}
+
+	return s.downloadArtifactWithoutRateLimit(ctx, u, maxRedirects)
+}
+
+func (s *ActionsService) downloadArtifactWithoutRateLimit(ctx context.Context, u string, maxRedirects int) (*url.URL, *Response, error) {
+	resp, err := s.client.roundTripWithOptionalFollowRedirect(ctx, u, maxRedirects)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusFound {
+		return nil, newResponse(resp), fmt.Errorf("unexpected status code: %v", resp.Status)
+	}
+
+	parsedURL, err := url.Parse(resp.Header.Get("Location"))
+	if err != nil {
+		return nil, newResponse(resp), err
+	}
+
+	return parsedURL, newResponse(resp), nil
+}
+
+func (s *ActionsService) downloadArtifactWithRateLimit(ctx context.Context, u string, maxRedirects int) (*url.URL, *Response, error) {
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	url, resp, err := s.client.bareDoUntilFound(ctx, req, maxRedirects)
+	if err != nil {
+		return nil, resp, err
+	}
+	defer resp.Body.Close()
+
+	// If we didn't receive a valid Location in a 302 response
+	if url == nil {
+		return nil, resp, fmt.Errorf("unexpected status code: %v", resp.Status)
+	}
+
+	return url, resp, nil
+}
+
+// DeleteArtifact deletes a workflow run artifact.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/artifacts#delete-an-artifact
+//
+//meta:operation DELETE /repos/{owner}/{repo}/actions/artifacts/{artifact_id}
+func (s *ActionsService) DeleteArtifact(ctx context.Context, owner, repo string, artifactID int64) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/artifacts/%v", owner, repo, artifactID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/actions_cache.go

@@ -0,0 +1,249 @@
+// Copyright 2022 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ActionsCache represents a GitHub action cache.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/cache#about-the-cache-api
+type ActionsCache struct {
+	ID             *int64     `json:"id,omitempty" url:"-"`
+	Ref            *string    `json:"ref,omitempty" url:"ref"`
+	Key            *string    `json:"key,omitempty" url:"key"`
+	Version        *string    `json:"version,omitempty" url:"-"`
+	LastAccessedAt *Timestamp `json:"last_accessed_at,omitempty" url:"-"`
+	CreatedAt      *Timestamp `json:"created_at,omitempty" url:"-"`
+	SizeInBytes    *int64     `json:"size_in_bytes,omitempty" url:"-"`
+}
+
+// ActionsCacheList represents a list of GitHub actions Cache.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/cache#list-github-actions-caches-for-a-repository
+type ActionsCacheList struct {
+	TotalCount    int             `json:"total_count"`
+	ActionsCaches []*ActionsCache `json:"actions_caches,omitempty"`
+}
+
+// ActionsCacheUsage represents a GitHub Actions Cache Usage object.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/cache#get-github-actions-cache-usage-for-a-repository
+type ActionsCacheUsage struct {
+	FullName                string `json:"full_name"`
+	ActiveCachesSizeInBytes int64  `json:"active_caches_size_in_bytes"`
+	ActiveCachesCount       int    `json:"active_caches_count"`
+}
+
+// ActionsCacheUsageList represents a list of repositories with GitHub Actions cache usage for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/cache#get-github-actions-cache-usage-for-a-repository
+type ActionsCacheUsageList struct {
+	TotalCount     int                  `json:"total_count"`
+	RepoCacheUsage []*ActionsCacheUsage `json:"repository_cache_usages,omitempty"`
+}
+
+// TotalCacheUsage represents total GitHub actions cache usage of an organization or enterprise.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/cache#get-github-actions-cache-usage-for-an-enterprise
+type TotalCacheUsage struct {
+	TotalActiveCachesUsageSizeInBytes int64 `json:"total_active_caches_size_in_bytes"`
+	TotalActiveCachesCount            int   `json:"total_active_caches_count"`
+}
+
+// ActionsCacheListOptions represents a list of all possible optional Query parameters for ListCaches method.
+//
+// GitHub API docs:  https://docs.github.com/rest/actions/cache#list-github-actions-caches-for-a-repository
+type ActionsCacheListOptions struct {
+	ListOptions
+	// The Git reference for the results you want to list.
+	// The ref for a branch can be formatted either as refs/heads/<branch name>
+	// or simply <branch name>. To reference a pull request use refs/pull/<number>/merge
+	Ref *string `url:"ref,omitempty"`
+	Key *string `url:"key,omitempty"`
+	// Can be one of: "created_at", "last_accessed_at", "size_in_bytes". Default: "last_accessed_at"
+	Sort *string `url:"sort,omitempty"`
+	// Can be one of: "asc", "desc" Default: desc
+	Direction *string `url:"direction,omitempty"`
+}
+
+// ListCaches lists the GitHub Actions caches for a repository.
+// You must authenticate using an access token with the repo scope to use this endpoint.
+//
+// Permissions: must have the actions:read permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/cache#list-github-actions-caches-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/caches
+func (s *ActionsService) ListCaches(ctx context.Context, owner, repo string, opts *ActionsCacheListOptions) (*ActionsCacheList, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/caches", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	actionCacheList := new(ActionsCacheList)
+	resp, err := s.client.Do(ctx, req, actionCacheList)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return actionCacheList, resp, nil
+}
+
+// DeleteCachesByKey deletes one or more GitHub Actions caches for a repository, using a complete cache key.
+// By default, all caches that match the provided key are deleted, but you can optionally provide
+// a Git ref to restrict deletions to caches that match both the provided key and the Git ref.
+// The ref for a branch can be formatted either as "refs/heads/<branch name>" or simply "<branch name>".
+// To reference a pull request use "refs/pull/<number>/merge". If you don't want to use ref just pass nil in parameter.
+//
+// Permissions: You must authenticate using an access token with the repo scope to use this endpoint. GitHub Apps must have the actions:write permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/cache#delete-github-actions-caches-for-a-repository-using-a-cache-key
+//
+//meta:operation DELETE /repos/{owner}/{repo}/actions/caches
+func (s *ActionsService) DeleteCachesByKey(ctx context.Context, owner, repo, key string, ref *string) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/caches", owner, repo)
+	u, err := addOptions(u, ActionsCache{Key: &key, Ref: ref})
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// DeleteCachesByID deletes a GitHub Actions cache for a repository, using a cache ID.
+//
+// Permissions: You must authenticate using an access token with the repo scope to use this endpoint. GitHub Apps must have the actions:write permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/cache#delete-a-github-actions-cache-for-a-repository-using-a-cache-id
+//
+//meta:operation DELETE /repos/{owner}/{repo}/actions/caches/{cache_id}
+func (s *ActionsService) DeleteCachesByID(ctx context.Context, owner, repo string, cacheID int64) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/caches/%v", owner, repo, cacheID)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// GetCacheUsageForRepo gets GitHub Actions cache usage for a repository. The data fetched using this API is refreshed approximately every 5 minutes,
+// so values returned from this endpoint may take at least 5 minutes to get updated.
+//
+// Permissions: Anyone with read access to the repository can use this endpoint. If the repository is private, you must use an
+// access token with the repo scope. GitHub Apps must have the actions:read permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/cache#get-github-actions-cache-usage-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/cache/usage
+func (s *ActionsService) GetCacheUsageForRepo(ctx context.Context, owner, repo string) (*ActionsCacheUsage, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/cache/usage", owner, repo)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	cacheUsage := new(ActionsCacheUsage)
+	res, err := s.client.Do(ctx, req, cacheUsage)
+	if err != nil {
+		return nil, res, err
+	}
+
+	return cacheUsage, res, err
+}
+
+// ListCacheUsageByRepoForOrg lists repositories and their GitHub Actions cache usage for an organization. The data fetched using this API is
+// refreshed approximately every 5 minutes, so values returned from this endpoint may take at least 5 minutes to get updated.
+//
+// Permissions: You must authenticate using an access token with the read:org scope to use this endpoint.
+// GitHub Apps must have the organization_administration:read permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/cache#list-repositories-with-github-actions-cache-usage-for-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/cache/usage-by-repository
+func (s *ActionsService) ListCacheUsageByRepoForOrg(ctx context.Context, org string, opts *ListOptions) (*ActionsCacheUsageList, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/cache/usage-by-repository", org)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	cacheUsage := new(ActionsCacheUsageList)
+	res, err := s.client.Do(ctx, req, cacheUsage)
+	if err != nil {
+		return nil, res, err
+	}
+
+	return cacheUsage, res, err
+}
+
+// GetTotalCacheUsageForOrg gets the total GitHub Actions cache usage for an organization. The data fetched using this API is refreshed approximately every
+// 5 minutes, so values returned from this endpoint may take at least 5 minutes to get updated.
+//
+// Permissions: You must authenticate using an access token with the read:org scope to use this endpoint.
+// GitHub Apps must have the organization_administration:read permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/cache#get-github-actions-cache-usage-for-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/cache/usage
+func (s *ActionsService) GetTotalCacheUsageForOrg(ctx context.Context, org string) (*TotalCacheUsage, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/cache/usage", org)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	cacheUsage := new(TotalCacheUsage)
+	res, err := s.client.Do(ctx, req, cacheUsage)
+	if err != nil {
+		return nil, res, err
+	}
+
+	return cacheUsage, res, err
+}
+
+// GetTotalCacheUsageForEnterprise gets the total GitHub Actions cache usage for an enterprise. The data fetched using this API is refreshed approximately every 5 minutes,
+// so values returned from this endpoint may take at least 5 minutes to get updated.
+//
+// Permissions: You must authenticate using an access token with the "admin:enterprise" scope to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/cache#get-github-actions-cache-usage-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/actions/cache/usage
+func (s *ActionsService) GetTotalCacheUsageForEnterprise(ctx context.Context, enterprise string) (*TotalCacheUsage, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/cache/usage", enterprise)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	cacheUsage := new(TotalCacheUsage)
+	res, err := s.client.Do(ctx, req, cacheUsage)
+	if err != nil {
+		return nil, res, err
+	}
+
+	return cacheUsage, res, err
+}

vendor/github.com/google/go-github/v69/github/actions_oidc.go

@@ -0,0 +1,81 @@
+// Copyright 2023 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// OIDCSubjectClaimCustomTemplate represents an OIDC subject claim customization template.
+type OIDCSubjectClaimCustomTemplate struct {
+	UseDefault       *bool    `json:"use_default,omitempty"`
+	IncludeClaimKeys []string `json:"include_claim_keys,omitempty"`
+}
+
+// GetOrgOIDCSubjectClaimCustomTemplate gets the subject claim customization template for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/oidc#get-the-customization-template-for-an-oidc-subject-claim-for-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/oidc/customization/sub
+func (s *ActionsService) GetOrgOIDCSubjectClaimCustomTemplate(ctx context.Context, org string) (*OIDCSubjectClaimCustomTemplate, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/oidc/customization/sub", org)
+	return s.getOIDCSubjectClaimCustomTemplate(ctx, u)
+}
+
+// GetRepoOIDCSubjectClaimCustomTemplate gets the subject claim customization template for a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/oidc#get-the-customization-template-for-an-oidc-subject-claim-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/oidc/customization/sub
+func (s *ActionsService) GetRepoOIDCSubjectClaimCustomTemplate(ctx context.Context, owner, repo string) (*OIDCSubjectClaimCustomTemplate, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/oidc/customization/sub", owner, repo)
+	return s.getOIDCSubjectClaimCustomTemplate(ctx, u)
+}
+
+func (s *ActionsService) getOIDCSubjectClaimCustomTemplate(ctx context.Context, url string) (*OIDCSubjectClaimCustomTemplate, *Response, error) {
+	req, err := s.client.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	tmpl := new(OIDCSubjectClaimCustomTemplate)
+	resp, err := s.client.Do(ctx, req, tmpl)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return tmpl, resp, nil
+}
+
+// SetOrgOIDCSubjectClaimCustomTemplate sets the subject claim customization for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/oidc#set-the-customization-template-for-an-oidc-subject-claim-for-an-organization
+//
+//meta:operation PUT /orgs/{org}/actions/oidc/customization/sub
+func (s *ActionsService) SetOrgOIDCSubjectClaimCustomTemplate(ctx context.Context, org string, template *OIDCSubjectClaimCustomTemplate) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/oidc/customization/sub", org)
+	return s.setOIDCSubjectClaimCustomTemplate(ctx, u, template)
+}
+
+// SetRepoOIDCSubjectClaimCustomTemplate sets the subject claim customization for a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/oidc#set-the-customization-template-for-an-oidc-subject-claim-for-a-repository
+//
+//meta:operation PUT /repos/{owner}/{repo}/actions/oidc/customization/sub
+func (s *ActionsService) SetRepoOIDCSubjectClaimCustomTemplate(ctx context.Context, owner, repo string, template *OIDCSubjectClaimCustomTemplate) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/oidc/customization/sub", owner, repo)
+	return s.setOIDCSubjectClaimCustomTemplate(ctx, u, template)
+}
+
+func (s *ActionsService) setOIDCSubjectClaimCustomTemplate(ctx context.Context, url string, template *OIDCSubjectClaimCustomTemplate) (*Response, error) {
+	req, err := s.client.NewRequest("PUT", url, template)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/actions_permissions_enterprise.go

@@ -0,0 +1,258 @@
+// Copyright 2023 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ActionsEnabledOnEnterpriseRepos represents all the repositories in an enterprise for which Actions is enabled.
+type ActionsEnabledOnEnterpriseRepos struct {
+	TotalCount    int             `json:"total_count"`
+	Organizations []*Organization `json:"organizations"`
+}
+
+// ActionsPermissionsEnterprise represents a policy for allowed actions in an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/permissions
+type ActionsPermissionsEnterprise struct {
+	EnabledOrganizations *string `json:"enabled_organizations,omitempty"`
+	AllowedActions       *string `json:"allowed_actions,omitempty"`
+	SelectedActionsURL   *string `json:"selected_actions_url,omitempty"`
+}
+
+func (a ActionsPermissionsEnterprise) String() string {
+	return Stringify(a)
+}
+
+// DefaultWorkflowPermissionEnterprise represents the default permissions for GitHub Actions workflows for an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/permissions
+type DefaultWorkflowPermissionEnterprise struct {
+	DefaultWorkflowPermissions   *string `json:"default_workflow_permissions,omitempty"`
+	CanApprovePullRequestReviews *bool   `json:"can_approve_pull_request_reviews,omitempty"`
+}
+
+// GetActionsPermissionsInEnterprise gets the GitHub Actions permissions policy for an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/permissions#get-github-actions-permissions-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/actions/permissions
+func (s *ActionsService) GetActionsPermissionsInEnterprise(ctx context.Context, enterprise string) (*ActionsPermissionsEnterprise, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/permissions", enterprise)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	permissions := new(ActionsPermissionsEnterprise)
+	resp, err := s.client.Do(ctx, req, permissions)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return permissions, resp, nil
+}
+
+// EditActionsPermissionsInEnterprise sets the permissions policy in an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/permissions#set-github-actions-permissions-for-an-enterprise
+//
+//meta:operation PUT /enterprises/{enterprise}/actions/permissions
+func (s *ActionsService) EditActionsPermissionsInEnterprise(ctx context.Context, enterprise string, actionsPermissionsEnterprise ActionsPermissionsEnterprise) (*ActionsPermissionsEnterprise, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/permissions", enterprise)
+	req, err := s.client.NewRequest("PUT", u, actionsPermissionsEnterprise)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	p := new(ActionsPermissionsEnterprise)
+	resp, err := s.client.Do(ctx, req, p)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return p, resp, nil
+}
+
+// ListEnabledOrgsInEnterprise lists the selected organizations that are enabled for GitHub Actions in an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/permissions#list-selected-organizations-enabled-for-github-actions-in-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/actions/permissions/organizations
+func (s *ActionsService) ListEnabledOrgsInEnterprise(ctx context.Context, owner string, opts *ListOptions) (*ActionsEnabledOnEnterpriseRepos, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/permissions/organizations", owner)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	orgs := &ActionsEnabledOnEnterpriseRepos{}
+	resp, err := s.client.Do(ctx, req, orgs)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return orgs, resp, nil
+}
+
+// SetEnabledOrgsInEnterprise replaces the list of selected organizations that are enabled for GitHub Actions in an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/permissions#set-selected-organizations-enabled-for-github-actions-in-an-enterprise
+//
+//meta:operation PUT /enterprises/{enterprise}/actions/permissions/organizations
+func (s *ActionsService) SetEnabledOrgsInEnterprise(ctx context.Context, owner string, organizationIDs []int64) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/permissions/organizations", owner)
+
+	req, err := s.client.NewRequest("PUT", u, struct {
+		IDs []int64 `json:"selected_organization_ids"`
+	}{IDs: organizationIDs})
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// AddEnabledOrgInEnterprise adds an organization to the list of selected organizations that are enabled for GitHub Actions in an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/permissions#enable-a-selected-organization-for-github-actions-in-an-enterprise
+//
+//meta:operation PUT /enterprises/{enterprise}/actions/permissions/organizations/{org_id}
+func (s *ActionsService) AddEnabledOrgInEnterprise(ctx context.Context, owner string, organizationID int64) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/permissions/organizations/%v", owner, organizationID)
+
+	req, err := s.client.NewRequest("PUT", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// RemoveEnabledOrgInEnterprise removes an organization from the list of selected organizations that are enabled for GitHub Actions in an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/permissions#disable-a-selected-organization-for-github-actions-in-an-enterprise
+//
+//meta:operation DELETE /enterprises/{enterprise}/actions/permissions/organizations/{org_id}
+func (s *ActionsService) RemoveEnabledOrgInEnterprise(ctx context.Context, owner string, organizationID int64) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/permissions/organizations/%v", owner, organizationID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// GetActionsAllowedInEnterprise gets the actions that are allowed in an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/permissions#get-allowed-actions-and-reusable-workflows-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/actions/permissions/selected-actions
+func (s *ActionsService) GetActionsAllowedInEnterprise(ctx context.Context, enterprise string) (*ActionsAllowed, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/permissions/selected-actions", enterprise)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	actionsAllowed := new(ActionsAllowed)
+	resp, err := s.client.Do(ctx, req, actionsAllowed)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return actionsAllowed, resp, nil
+}
+
+// EditActionsAllowedInEnterprise sets the actions that are allowed in an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/permissions#set-allowed-actions-and-reusable-workflows-for-an-enterprise
+//
+//meta:operation PUT /enterprises/{enterprise}/actions/permissions/selected-actions
+func (s *ActionsService) EditActionsAllowedInEnterprise(ctx context.Context, enterprise string, actionsAllowed ActionsAllowed) (*ActionsAllowed, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/permissions/selected-actions", enterprise)
+	req, err := s.client.NewRequest("PUT", u, actionsAllowed)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	p := new(ActionsAllowed)
+	resp, err := s.client.Do(ctx, req, p)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return p, resp, nil
+}
+
+// GetDefaultWorkflowPermissionsInEnterprise gets the GitHub Actions default workflow permissions for an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/permissions#get-default-workflow-permissions-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/actions/permissions/workflow
+func (s *ActionsService) GetDefaultWorkflowPermissionsInEnterprise(ctx context.Context, enterprise string) (*DefaultWorkflowPermissionEnterprise, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/permissions/workflow", enterprise)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	permissions := new(DefaultWorkflowPermissionEnterprise)
+	resp, err := s.client.Do(ctx, req, permissions)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return permissions, resp, nil
+}
+
+// EditDefaultWorkflowPermissionsInEnterprise sets the GitHub Actions default workflow permissions for an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/permissions#set-default-workflow-permissions-for-an-enterprise
+//
+//meta:operation PUT /enterprises/{enterprise}/actions/permissions/workflow
+func (s *ActionsService) EditDefaultWorkflowPermissionsInEnterprise(ctx context.Context, enterprise string, permissions DefaultWorkflowPermissionEnterprise) (*DefaultWorkflowPermissionEnterprise, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/permissions/workflow", enterprise)
+	req, err := s.client.NewRequest("PUT", u, permissions)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	p := new(DefaultWorkflowPermissionEnterprise)
+	resp, err := s.client.Do(ctx, req, p)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return p, resp, nil
+}

vendor/github.com/google/go-github/v69/github/actions_permissions_orgs.go

@@ -0,0 +1,271 @@
+// Copyright 2023 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ActionsPermissions represents a policy for repositories and allowed actions in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions
+type ActionsPermissions struct {
+	EnabledRepositories *string `json:"enabled_repositories,omitempty"`
+	AllowedActions      *string `json:"allowed_actions,omitempty"`
+	SelectedActionsURL  *string `json:"selected_actions_url,omitempty"`
+}
+
+func (a ActionsPermissions) String() string {
+	return Stringify(a)
+}
+
+// ActionsEnabledOnOrgRepos represents all the repositories in an organization for which Actions is enabled.
+type ActionsEnabledOnOrgRepos struct {
+	TotalCount   int           `json:"total_count"`
+	Repositories []*Repository `json:"repositories"`
+}
+
+// ActionsAllowed represents selected actions that are allowed.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions
+type ActionsAllowed struct {
+	GithubOwnedAllowed *bool    `json:"github_owned_allowed,omitempty"`
+	VerifiedAllowed    *bool    `json:"verified_allowed,omitempty"`
+	PatternsAllowed    []string `json:"patterns_allowed,omitempty"`
+}
+
+func (a ActionsAllowed) String() string {
+	return Stringify(a)
+}
+
+// DefaultWorkflowPermissionOrganization represents the default permissions for GitHub Actions workflows for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions
+type DefaultWorkflowPermissionOrganization struct {
+	DefaultWorkflowPermissions   *string `json:"default_workflow_permissions,omitempty"`
+	CanApprovePullRequestReviews *bool   `json:"can_approve_pull_request_reviews,omitempty"`
+}
+
+// GetActionsPermissions gets the GitHub Actions permissions policy for repositories and allowed actions in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions#get-github-actions-permissions-for-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/permissions
+func (s *ActionsService) GetActionsPermissions(ctx context.Context, org string) (*ActionsPermissions, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/permissions", org)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	permissions := new(ActionsPermissions)
+	resp, err := s.client.Do(ctx, req, permissions)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return permissions, resp, nil
+}
+
+// EditActionsPermissions sets the permissions policy for repositories and allowed actions in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions#set-github-actions-permissions-for-an-organization
+//
+//meta:operation PUT /orgs/{org}/actions/permissions
+func (s *ActionsService) EditActionsPermissions(ctx context.Context, org string, actionsPermissions ActionsPermissions) (*ActionsPermissions, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/permissions", org)
+	req, err := s.client.NewRequest("PUT", u, actionsPermissions)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	p := new(ActionsPermissions)
+	resp, err := s.client.Do(ctx, req, p)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return p, resp, nil
+}
+
+// ListEnabledReposInOrg lists the selected repositories that are enabled for GitHub Actions in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions#list-selected-repositories-enabled-for-github-actions-in-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/permissions/repositories
+func (s *ActionsService) ListEnabledReposInOrg(ctx context.Context, owner string, opts *ListOptions) (*ActionsEnabledOnOrgRepos, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/permissions/repositories", owner)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	repos := &ActionsEnabledOnOrgRepos{}
+	resp, err := s.client.Do(ctx, req, repos)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return repos, resp, nil
+}
+
+// SetEnabledReposInOrg replaces the list of selected repositories that are enabled for GitHub Actions in an organization..
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions#set-selected-repositories-enabled-for-github-actions-in-an-organization
+//
+//meta:operation PUT /orgs/{org}/actions/permissions/repositories
+func (s *ActionsService) SetEnabledReposInOrg(ctx context.Context, owner string, repositoryIDs []int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/permissions/repositories", owner)
+
+	req, err := s.client.NewRequest("PUT", u, struct {
+		IDs []int64 `json:"selected_repository_ids"`
+	}{IDs: repositoryIDs})
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// AddEnabledReposInOrg adds a repository to the list of selected repositories that are enabled for GitHub Actions in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions#enable-a-selected-repository-for-github-actions-in-an-organization
+//
+//meta:operation PUT /orgs/{org}/actions/permissions/repositories/{repository_id}
+func (s *ActionsService) AddEnabledReposInOrg(ctx context.Context, owner string, repositoryID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/permissions/repositories/%v", owner, repositoryID)
+
+	req, err := s.client.NewRequest("PUT", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// RemoveEnabledReposInOrg removes a single repository from the list of enabled repos for GitHub Actions in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions#disable-a-selected-repository-for-github-actions-in-an-organization
+//
+//meta:operation DELETE /orgs/{org}/actions/permissions/repositories/{repository_id}
+func (s *ActionsService) RemoveEnabledReposInOrg(ctx context.Context, owner string, repositoryID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/permissions/repositories/%v", owner, repositoryID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// GetActionsAllowed gets the actions that are allowed in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions#get-allowed-actions-and-reusable-workflows-for-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/permissions/selected-actions
+func (s *ActionsService) GetActionsAllowed(ctx context.Context, org string) (*ActionsAllowed, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/permissions/selected-actions", org)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	actionsAllowed := new(ActionsAllowed)
+	resp, err := s.client.Do(ctx, req, actionsAllowed)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return actionsAllowed, resp, nil
+}
+
+// EditActionsAllowed sets the actions that are allowed in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions#set-allowed-actions-and-reusable-workflows-for-an-organization
+//
+//meta:operation PUT /orgs/{org}/actions/permissions/selected-actions
+func (s *ActionsService) EditActionsAllowed(ctx context.Context, org string, actionsAllowed ActionsAllowed) (*ActionsAllowed, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/permissions/selected-actions", org)
+	req, err := s.client.NewRequest("PUT", u, actionsAllowed)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	p := new(ActionsAllowed)
+	resp, err := s.client.Do(ctx, req, p)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return p, resp, nil
+}
+
+// GetDefaultWorkflowPermissionsInOrganization gets the GitHub Actions default workflow permissions for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions#get-default-workflow-permissions-for-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/permissions/workflow
+func (s *ActionsService) GetDefaultWorkflowPermissionsInOrganization(ctx context.Context, org string) (*DefaultWorkflowPermissionOrganization, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/permissions/workflow", org)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	permissions := new(DefaultWorkflowPermissionOrganization)
+	resp, err := s.client.Do(ctx, req, permissions)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return permissions, resp, nil
+}
+
+// EditDefaultWorkflowPermissionsInOrganization sets the GitHub Actions default workflow permissions for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions#set-default-workflow-permissions-for-an-organization
+//
+//meta:operation PUT /orgs/{org}/actions/permissions/workflow
+func (s *ActionsService) EditDefaultWorkflowPermissionsInOrganization(ctx context.Context, org string, permissions DefaultWorkflowPermissionOrganization) (*DefaultWorkflowPermissionOrganization, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/permissions/workflow", org)
+	req, err := s.client.NewRequest("PUT", u, permissions)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	p := new(DefaultWorkflowPermissionOrganization)
+	resp, err := s.client.Do(ctx, req, p)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return p, resp, nil
+}

vendor/github.com/google/go-github/v69/github/actions_required_workflows.go

@@ -0,0 +1,267 @@
+// Copyright 2023 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// OrgRequiredWorkflow represents a required workflow object at the org level.
+type OrgRequiredWorkflow struct {
+	ID                      *int64      `json:"id,omitempty"`
+	Name                    *string     `json:"name,omitempty"`
+	Path                    *string     `json:"path,omitempty"`
+	Scope                   *string     `json:"scope,omitempty"`
+	Ref                     *string     `json:"ref,omitempty"`
+	State                   *string     `json:"state,omitempty"`
+	SelectedRepositoriesURL *string     `json:"selected_repositories_url,omitempty"`
+	CreatedAt               *Timestamp  `json:"created_at,omitempty"`
+	UpdatedAt               *Timestamp  `json:"updated_at,omitempty"`
+	Repository              *Repository `json:"repository,omitempty"`
+}
+
+// OrgRequiredWorkflows represents the required workflows for the org.
+type OrgRequiredWorkflows struct {
+	TotalCount        *int                   `json:"total_count,omitempty"`
+	RequiredWorkflows []*OrgRequiredWorkflow `json:"required_workflows,omitempty"`
+}
+
+// CreateUpdateRequiredWorkflowOptions represents the input object used to create or update required workflows.
+type CreateUpdateRequiredWorkflowOptions struct {
+	WorkflowFilePath      *string          `json:"workflow_file_path,omitempty"`
+	RepositoryID          *int64           `json:"repository_id,omitempty"`
+	Scope                 *string          `json:"scope,omitempty"`
+	SelectedRepositoryIDs *SelectedRepoIDs `json:"selected_repository_ids,omitempty"`
+}
+
+// RequiredWorkflowSelectedRepos represents the repos that a required workflow is applied to.
+type RequiredWorkflowSelectedRepos struct {
+	TotalCount   *int          `json:"total_count,omitempty"`
+	Repositories []*Repository `json:"repositories,omitempty"`
+}
+
+// RepoRequiredWorkflow represents a required workflow object at the repo level.
+type RepoRequiredWorkflow struct {
+	ID               *int64      `json:"id,omitempty"`
+	NodeID           *string     `json:"node_id,omitempty"`
+	Name             *string     `json:"name,omitempty"`
+	Path             *string     `json:"path,omitempty"`
+	State            *string     `json:"state,omitempty"`
+	URL              *string     `json:"url,omitempty"`
+	HTMLURL          *string     `json:"html_url,omitempty"`
+	BadgeURL         *string     `json:"badge_url,omitempty"`
+	CreatedAt        *Timestamp  `json:"created_at,omitempty"`
+	UpdatedAt        *Timestamp  `json:"updated_at,omitempty"`
+	SourceRepository *Repository `json:"source_repository,omitempty"`
+}
+
+// RepoRequiredWorkflows represents the required workflows for a repo.
+type RepoRequiredWorkflows struct {
+	TotalCount        *int                    `json:"total_count,omitempty"`
+	RequiredWorkflows []*RepoRequiredWorkflow `json:"required_workflows,omitempty"`
+}
+
+// ListOrgRequiredWorkflows lists the RequiredWorkflows for an org.
+//
+// GitHub API docs: https://docs.github.com/actions/using-workflows/required-workflows
+//
+//meta:operation GET /orgs/{org}/actions/required_workflows
+func (s *ActionsService) ListOrgRequiredWorkflows(ctx context.Context, org string, opts *ListOptions) (*OrgRequiredWorkflows, *Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/required_workflows", org)
+	u, err := addOptions(url, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	requiredWorkflows := new(OrgRequiredWorkflows)
+	resp, err := s.client.Do(ctx, req, &requiredWorkflows)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return requiredWorkflows, resp, nil
+}
+
+// CreateRequiredWorkflow creates the required workflow in an org.
+//
+// GitHub API docs: https://docs.github.com/actions/using-workflows/required-workflows
+//
+//meta:operation POST /orgs/{org}/actions/required_workflows
+func (s *ActionsService) CreateRequiredWorkflow(ctx context.Context, org string, createRequiredWorkflowOptions *CreateUpdateRequiredWorkflowOptions) (*OrgRequiredWorkflow, *Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/required_workflows", org)
+	req, err := s.client.NewRequest("POST", url, createRequiredWorkflowOptions)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	orgRequiredWorkflow := new(OrgRequiredWorkflow)
+	resp, err := s.client.Do(ctx, req, orgRequiredWorkflow)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return orgRequiredWorkflow, resp, nil
+}
+
+// GetRequiredWorkflowByID get the RequiredWorkflows for an org by its ID.
+//
+// GitHub API docs: https://docs.github.com/actions/using-workflows/required-workflows
+//
+//meta:operation GET /orgs/{org}/actions/required_workflows/{workflow_id}
+func (s *ActionsService) GetRequiredWorkflowByID(ctx context.Context, owner string, requiredWorkflowID int64) (*OrgRequiredWorkflow, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/required_workflows/%v", owner, requiredWorkflowID)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	requiredWorkflow := new(OrgRequiredWorkflow)
+	resp, err := s.client.Do(ctx, req, &requiredWorkflow)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return requiredWorkflow, resp, nil
+}
+
+// UpdateRequiredWorkflow updates a required workflow in an org.
+//
+// GitHub API docs: https://docs.github.com/actions/using-workflows/required-workflows
+//
+//meta:operation PATCH /orgs/{org}/actions/required_workflows/{workflow_id}
+func (s *ActionsService) UpdateRequiredWorkflow(ctx context.Context, org string, requiredWorkflowID int64, updateRequiredWorkflowOptions *CreateUpdateRequiredWorkflowOptions) (*OrgRequiredWorkflow, *Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/required_workflows/%v", org, requiredWorkflowID)
+	req, err := s.client.NewRequest("PATCH", url, updateRequiredWorkflowOptions)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	orgRequiredWorkflow := new(OrgRequiredWorkflow)
+	resp, err := s.client.Do(ctx, req, orgRequiredWorkflow)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return orgRequiredWorkflow, resp, nil
+}
+
+// DeleteRequiredWorkflow deletes a required workflow in an org.
+//
+// GitHub API docs: https://docs.github.com/actions/using-workflows/required-workflows
+//
+//meta:operation DELETE /orgs/{org}/actions/required_workflows/{workflow_id}
+func (s *ActionsService) DeleteRequiredWorkflow(ctx context.Context, org string, requiredWorkflowID int64) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/required_workflows/%v", org, requiredWorkflowID)
+	req, err := s.client.NewRequest("DELETE", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	return s.client.Do(ctx, req, nil)
+}
+
+// ListRequiredWorkflowSelectedRepos lists the Repositories selected for a workflow.
+//
+// GitHub API docs: https://docs.github.com/actions/using-workflows/required-workflows
+//
+//meta:operation GET /orgs/{org}/actions/required_workflows/{workflow_id}/repositories
+func (s *ActionsService) ListRequiredWorkflowSelectedRepos(ctx context.Context, org string, requiredWorkflowID int64, opts *ListOptions) (*RequiredWorkflowSelectedRepos, *Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/required_workflows/%v/repositories", org, requiredWorkflowID)
+	u, err := addOptions(url, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	requiredWorkflowRepos := new(RequiredWorkflowSelectedRepos)
+	resp, err := s.client.Do(ctx, req, &requiredWorkflowRepos)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return requiredWorkflowRepos, resp, nil
+}
+
+// SetRequiredWorkflowSelectedRepos sets the Repositories selected for a workflow.
+//
+// GitHub API docs: https://docs.github.com/actions/using-workflows/required-workflows
+//
+//meta:operation PUT /orgs/{org}/actions/required_workflows/{workflow_id}/repositories
+func (s *ActionsService) SetRequiredWorkflowSelectedRepos(ctx context.Context, org string, requiredWorkflowID int64, ids SelectedRepoIDs) (*Response, error) {
+	type repoIDs struct {
+		SelectedIDs SelectedRepoIDs `json:"selected_repository_ids"`
+	}
+	url := fmt.Sprintf("orgs/%v/actions/required_workflows/%v/repositories", org, requiredWorkflowID)
+	req, err := s.client.NewRequest("PUT", url, repoIDs{SelectedIDs: ids})
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// AddRepoToRequiredWorkflow adds the Repository to a required workflow.
+//
+// GitHub API docs: https://docs.github.com/actions/using-workflows/required-workflows
+//
+//meta:operation PUT /orgs/{org}/actions/required_workflows/{workflow_id}/repositories/{repository_id}
+func (s *ActionsService) AddRepoToRequiredWorkflow(ctx context.Context, org string, requiredWorkflowID, repoID int64) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/required_workflows/%v/repositories/%v", org, requiredWorkflowID, repoID)
+	req, err := s.client.NewRequest("PUT", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	return s.client.Do(ctx, req, nil)
+}
+
+// RemoveRepoFromRequiredWorkflow removes the Repository from a required workflow.
+//
+// GitHub API docs: https://docs.github.com/actions/using-workflows/required-workflows
+//
+//meta:operation DELETE /orgs/{org}/actions/required_workflows/{workflow_id}/repositories/{repository_id}
+func (s *ActionsService) RemoveRepoFromRequiredWorkflow(ctx context.Context, org string, requiredWorkflowID, repoID int64) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/required_workflows/%v/repositories/%v", org, requiredWorkflowID, repoID)
+	req, err := s.client.NewRequest("DELETE", url, nil)
+	if err != nil {
+		return nil, err
+	}
+	return s.client.Do(ctx, req, nil)
+}
+
+// ListRepoRequiredWorkflows lists the RequiredWorkflows for a repo.
+//
+// GitHub API docs: https://docs.github.com/actions/using-workflows/required-workflows
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/required_workflows
+func (s *ActionsService) ListRepoRequiredWorkflows(ctx context.Context, owner, repo string, opts *ListOptions) (*RepoRequiredWorkflows, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/actions/required_workflows", owner, repo)
+	u, err := addOptions(url, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	requiredWorkflows := new(RepoRequiredWorkflows)
+	resp, err := s.client.Do(ctx, req, &requiredWorkflows)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return requiredWorkflows, resp, nil
+}

vendor/github.com/google/go-github/v69/github/actions_runner_groups.go

@@ -0,0 +1,337 @@
+// Copyright 2021 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// RunnerGroup represents a self-hosted runner group configured in an organization.
+type RunnerGroup struct {
+	ID                           *int64   `json:"id,omitempty"`
+	Name                         *string  `json:"name,omitempty"`
+	Visibility                   *string  `json:"visibility,omitempty"`
+	Default                      *bool    `json:"default,omitempty"`
+	SelectedRepositoriesURL      *string  `json:"selected_repositories_url,omitempty"`
+	RunnersURL                   *string  `json:"runners_url,omitempty"`
+	Inherited                    *bool    `json:"inherited,omitempty"`
+	AllowsPublicRepositories     *bool    `json:"allows_public_repositories,omitempty"`
+	RestrictedToWorkflows        *bool    `json:"restricted_to_workflows,omitempty"`
+	SelectedWorkflows            []string `json:"selected_workflows,omitempty"`
+	WorkflowRestrictionsReadOnly *bool    `json:"workflow_restrictions_read_only,omitempty"`
+}
+
+// RunnerGroups represents a collection of self-hosted runner groups configured for an organization.
+type RunnerGroups struct {
+	TotalCount   int            `json:"total_count"`
+	RunnerGroups []*RunnerGroup `json:"runner_groups"`
+}
+
+// CreateRunnerGroupRequest represents a request to create a Runner group for an organization.
+type CreateRunnerGroupRequest struct {
+	Name       *string `json:"name,omitempty"`
+	Visibility *string `json:"visibility,omitempty"`
+	// List of repository IDs that can access the runner group.
+	SelectedRepositoryIDs []int64 `json:"selected_repository_ids,omitempty"`
+	// Runners represent a list of runner IDs to add to the runner group.
+	Runners []int64 `json:"runners,omitempty"`
+	// If set to True, public repos can use this runner group
+	AllowsPublicRepositories *bool `json:"allows_public_repositories,omitempty"`
+	// If true, the runner group will be restricted to running only the workflows specified in the SelectedWorkflows slice.
+	RestrictedToWorkflows *bool `json:"restricted_to_workflows,omitempty"`
+	// List of workflows the runner group should be allowed to run. This setting will be ignored unless RestrictedToWorkflows is set to true.
+	SelectedWorkflows []string `json:"selected_workflows,omitempty"`
+}
+
+// UpdateRunnerGroupRequest represents a request to update a Runner group for an organization.
+type UpdateRunnerGroupRequest struct {
+	Name                     *string  `json:"name,omitempty"`
+	Visibility               *string  `json:"visibility,omitempty"`
+	AllowsPublicRepositories *bool    `json:"allows_public_repositories,omitempty"`
+	RestrictedToWorkflows    *bool    `json:"restricted_to_workflows,omitempty"`
+	SelectedWorkflows        []string `json:"selected_workflows,omitempty"`
+}
+
+// SetRepoAccessRunnerGroupRequest represents a request to replace the list of repositories
+// that can access a self-hosted runner group configured in an organization.
+type SetRepoAccessRunnerGroupRequest struct {
+	// Updated list of repository IDs that should be given access to the runner group.
+	SelectedRepositoryIDs []int64 `json:"selected_repository_ids"`
+}
+
+// SetRunnerGroupRunnersRequest represents a request to replace the list of
+// self-hosted runners that are part of an organization runner group.
+type SetRunnerGroupRunnersRequest struct {
+	// Updated list of runner IDs that should be given access to the runner group.
+	Runners []int64 `json:"runners"`
+}
+
+// ListOrgRunnerGroupOptions extend ListOptions to have the optional parameters VisibleToRepository.
+type ListOrgRunnerGroupOptions struct {
+	ListOptions
+
+	// Only return runner groups that are allowed to be used by this repository.
+	VisibleToRepository string `url:"visible_to_repository,omitempty"`
+}
+
+// ListOrganizationRunnerGroups lists all self-hosted runner groups configured in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runner-groups#list-self-hosted-runner-groups-for-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/runner-groups
+func (s *ActionsService) ListOrganizationRunnerGroups(ctx context.Context, org string, opts *ListOrgRunnerGroupOptions) (*RunnerGroups, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runner-groups", org)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	groups := &RunnerGroups{}
+	resp, err := s.client.Do(ctx, req, &groups)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return groups, resp, nil
+}
+
+// GetOrganizationRunnerGroup gets a specific self-hosted runner group for an organization using its RunnerGroup ID.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runner-groups#get-a-self-hosted-runner-group-for-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/runner-groups/{runner_group_id}
+func (s *ActionsService) GetOrganizationRunnerGroup(ctx context.Context, org string, groupID int64) (*RunnerGroup, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runner-groups/%v", org, groupID)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runnerGroup := new(RunnerGroup)
+	resp, err := s.client.Do(ctx, req, runnerGroup)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return runnerGroup, resp, nil
+}
+
+// DeleteOrganizationRunnerGroup deletes a self-hosted runner group from an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runner-groups#delete-a-self-hosted-runner-group-from-an-organization
+//
+//meta:operation DELETE /orgs/{org}/actions/runner-groups/{runner_group_id}
+func (s *ActionsService) DeleteOrganizationRunnerGroup(ctx context.Context, org string, groupID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runner-groups/%v", org, groupID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// CreateOrganizationRunnerGroup creates a new self-hosted runner group for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runner-groups#create-a-self-hosted-runner-group-for-an-organization
+//
+//meta:operation POST /orgs/{org}/actions/runner-groups
+func (s *ActionsService) CreateOrganizationRunnerGroup(ctx context.Context, org string, createReq CreateRunnerGroupRequest) (*RunnerGroup, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runner-groups", org)
+	req, err := s.client.NewRequest("POST", u, createReq)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runnerGroup := new(RunnerGroup)
+	resp, err := s.client.Do(ctx, req, runnerGroup)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return runnerGroup, resp, nil
+}
+
+// UpdateOrganizationRunnerGroup updates a self-hosted runner group for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runner-groups#update-a-self-hosted-runner-group-for-an-organization
+//
+//meta:operation PATCH /orgs/{org}/actions/runner-groups/{runner_group_id}
+func (s *ActionsService) UpdateOrganizationRunnerGroup(ctx context.Context, org string, groupID int64, updateReq UpdateRunnerGroupRequest) (*RunnerGroup, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runner-groups/%v", org, groupID)
+	req, err := s.client.NewRequest("PATCH", u, updateReq)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runnerGroup := new(RunnerGroup)
+	resp, err := s.client.Do(ctx, req, runnerGroup)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return runnerGroup, resp, nil
+}
+
+// ListRepositoryAccessRunnerGroup lists the repositories with access to a self-hosted runner group configured in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runner-groups#list-repository-access-to-a-self-hosted-runner-group-in-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/runner-groups/{runner_group_id}/repositories
+func (s *ActionsService) ListRepositoryAccessRunnerGroup(ctx context.Context, org string, groupID int64, opts *ListOptions) (*ListRepositories, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runner-groups/%v/repositories", org, groupID)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	repos := &ListRepositories{}
+	resp, err := s.client.Do(ctx, req, &repos)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return repos, resp, nil
+}
+
+// SetRepositoryAccessRunnerGroup replaces the list of repositories that have access to a self-hosted runner group configured in an organization
+// with a new List of repositories.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runner-groups#set-repository-access-for-a-self-hosted-runner-group-in-an-organization
+//
+//meta:operation PUT /orgs/{org}/actions/runner-groups/{runner_group_id}/repositories
+func (s *ActionsService) SetRepositoryAccessRunnerGroup(ctx context.Context, org string, groupID int64, ids SetRepoAccessRunnerGroupRequest) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runner-groups/%v/repositories", org, groupID)
+
+	req, err := s.client.NewRequest("PUT", u, ids)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// AddRepositoryAccessRunnerGroup adds a repository to the list of selected repositories that can access a self-hosted runner group.
+// The runner group must have visibility set to 'selected'.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runner-groups#add-repository-access-to-a-self-hosted-runner-group-in-an-organization
+//
+//meta:operation PUT /orgs/{org}/actions/runner-groups/{runner_group_id}/repositories/{repository_id}
+func (s *ActionsService) AddRepositoryAccessRunnerGroup(ctx context.Context, org string, groupID, repoID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runner-groups/%v/repositories/%v", org, groupID, repoID)
+
+	req, err := s.client.NewRequest("PUT", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// RemoveRepositoryAccessRunnerGroup removes a repository from the list of selected repositories that can access a self-hosted runner group.
+// The runner group must have visibility set to 'selected'.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runner-groups#remove-repository-access-to-a-self-hosted-runner-group-in-an-organization
+//
+//meta:operation DELETE /orgs/{org}/actions/runner-groups/{runner_group_id}/repositories/{repository_id}
+func (s *ActionsService) RemoveRepositoryAccessRunnerGroup(ctx context.Context, org string, groupID, repoID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runner-groups/%v/repositories/%v", org, groupID, repoID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// ListRunnerGroupRunners lists self-hosted runners that are in a specific organization group.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runner-groups#list-self-hosted-runners-in-a-group-for-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/runner-groups/{runner_group_id}/runners
+func (s *ActionsService) ListRunnerGroupRunners(ctx context.Context, org string, groupID int64, opts *ListOptions) (*Runners, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runner-groups/%v/runners", org, groupID)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runners := &Runners{}
+	resp, err := s.client.Do(ctx, req, &runners)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return runners, resp, nil
+}
+
+// SetRunnerGroupRunners replaces the list of self-hosted runners that are part of an organization runner group
+// with a new list of runners.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runner-groups#set-self-hosted-runners-in-a-group-for-an-organization
+//
+//meta:operation PUT /orgs/{org}/actions/runner-groups/{runner_group_id}/runners
+func (s *ActionsService) SetRunnerGroupRunners(ctx context.Context, org string, groupID int64, ids SetRunnerGroupRunnersRequest) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runner-groups/%v/runners", org, groupID)
+
+	req, err := s.client.NewRequest("PUT", u, ids)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// AddRunnerGroupRunners adds a self-hosted runner to a runner group configured in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runner-groups#add-a-self-hosted-runner-to-a-group-for-an-organization
+//
+//meta:operation PUT /orgs/{org}/actions/runner-groups/{runner_group_id}/runners/{runner_id}
+func (s *ActionsService) AddRunnerGroupRunners(ctx context.Context, org string, groupID, runnerID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runner-groups/%v/runners/%v", org, groupID, runnerID)
+
+	req, err := s.client.NewRequest("PUT", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// RemoveRunnerGroupRunners removes a self-hosted runner from a group configured in an organization.
+// The runner is then returned to the default group.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runner-groups#remove-a-self-hosted-runner-from-a-group-for-an-organization
+//
+//meta:operation DELETE /orgs/{org}/actions/runner-groups/{runner_group_id}/runners/{runner_id}
+func (s *ActionsService) RemoveRunnerGroupRunners(ctx context.Context, org string, groupID, runnerID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runner-groups/%v/runners/%v", org, groupID, runnerID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/actions_runners.go

@@ -0,0 +1,377 @@
+// Copyright 2020 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// RunnerApplicationDownload represents a binary for the self-hosted runner application that can be downloaded.
+type RunnerApplicationDownload struct {
+	OS                *string `json:"os,omitempty"`
+	Architecture      *string `json:"architecture,omitempty"`
+	DownloadURL       *string `json:"download_url,omitempty"`
+	Filename          *string `json:"filename,omitempty"`
+	TempDownloadToken *string `json:"temp_download_token,omitempty"`
+	SHA256Checksum    *string `json:"sha256_checksum,omitempty"`
+}
+
+// ListRunnerApplicationDownloads lists self-hosted runner application binaries that can be downloaded and run.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runners#list-runner-applications-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/runners/downloads
+func (s *ActionsService) ListRunnerApplicationDownloads(ctx context.Context, owner, repo string) ([]*RunnerApplicationDownload, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runners/downloads", owner, repo)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var rads []*RunnerApplicationDownload
+	resp, err := s.client.Do(ctx, req, &rads)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return rads, resp, nil
+}
+
+// GenerateJITConfigRequest specifies body parameters to GenerateRepoJITConfig.
+type GenerateJITConfigRequest struct {
+	Name          string  `json:"name"`
+	RunnerGroupID int64   `json:"runner_group_id"`
+	WorkFolder    *string `json:"work_folder,omitempty"`
+
+	// Labels represents the names of the custom labels to add to the runner.
+	// Minimum items: 1. Maximum items: 100.
+	Labels []string `json:"labels"`
+}
+
+// JITRunnerConfig represents encoded JIT configuration that can be used to bootstrap a self-hosted runner.
+type JITRunnerConfig struct {
+	Runner           *Runner `json:"runner,omitempty"`
+	EncodedJITConfig *string `json:"encoded_jit_config,omitempty"`
+}
+
+// GenerateOrgJITConfig generate a just-in-time configuration for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runners#create-configuration-for-a-just-in-time-runner-for-an-organization
+//
+//meta:operation POST /orgs/{org}/actions/runners/generate-jitconfig
+func (s *ActionsService) GenerateOrgJITConfig(ctx context.Context, org string, request *GenerateJITConfigRequest) (*JITRunnerConfig, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runners/generate-jitconfig", org)
+	req, err := s.client.NewRequest("POST", u, request)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	jitConfig := new(JITRunnerConfig)
+	resp, err := s.client.Do(ctx, req, jitConfig)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return jitConfig, resp, nil
+}
+
+// GenerateRepoJITConfig generates a just-in-time configuration for a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runners#create-configuration-for-a-just-in-time-runner-for-a-repository
+//
+//meta:operation POST /repos/{owner}/{repo}/actions/runners/generate-jitconfig
+func (s *ActionsService) GenerateRepoJITConfig(ctx context.Context, owner, repo string, request *GenerateJITConfigRequest) (*JITRunnerConfig, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runners/generate-jitconfig", owner, repo)
+	req, err := s.client.NewRequest("POST", u, request)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	jitConfig := new(JITRunnerConfig)
+	resp, err := s.client.Do(ctx, req, jitConfig)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return jitConfig, resp, nil
+}
+
+// RegistrationToken represents a token that can be used to add a self-hosted runner to a repository.
+type RegistrationToken struct {
+	Token     *string    `json:"token,omitempty"`
+	ExpiresAt *Timestamp `json:"expires_at,omitempty"`
+}
+
+// CreateRegistrationToken creates a token that can be used to add a self-hosted runner.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runners#create-a-registration-token-for-a-repository
+//
+//meta:operation POST /repos/{owner}/{repo}/actions/runners/registration-token
+func (s *ActionsService) CreateRegistrationToken(ctx context.Context, owner, repo string) (*RegistrationToken, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runners/registration-token", owner, repo)
+
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	registrationToken := new(RegistrationToken)
+	resp, err := s.client.Do(ctx, req, registrationToken)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return registrationToken, resp, nil
+}
+
+// Runner represents a self-hosted runner registered with a repository.
+type Runner struct {
+	ID     *int64          `json:"id,omitempty"`
+	Name   *string         `json:"name,omitempty"`
+	OS     *string         `json:"os,omitempty"`
+	Status *string         `json:"status,omitempty"`
+	Busy   *bool           `json:"busy,omitempty"`
+	Labels []*RunnerLabels `json:"labels,omitempty"`
+}
+
+// RunnerLabels represents a collection of labels attached to each runner.
+type RunnerLabels struct {
+	ID   *int64  `json:"id,omitempty"`
+	Name *string `json:"name,omitempty"`
+	Type *string `json:"type,omitempty"`
+}
+
+// Runners represents a collection of self-hosted runners for a repository.
+type Runners struct {
+	TotalCount int       `json:"total_count"`
+	Runners    []*Runner `json:"runners"`
+}
+
+// ListRunnersOptions specifies the optional parameters to the ListRunners and ListOrganizationRunners methods.
+type ListRunnersOptions struct {
+	Name *string `url:"name,omitempty"`
+	ListOptions
+}
+
+// ListRunners lists all the self-hosted runners for a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runners#list-self-hosted-runners-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/runners
+func (s *ActionsService) ListRunners(ctx context.Context, owner, repo string, opts *ListRunnersOptions) (*Runners, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runners", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runners := &Runners{}
+	resp, err := s.client.Do(ctx, req, &runners)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return runners, resp, nil
+}
+
+// GetRunner gets a specific self-hosted runner for a repository using its runner ID.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runners#get-a-self-hosted-runner-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/runners/{runner_id}
+func (s *ActionsService) GetRunner(ctx context.Context, owner, repo string, runnerID int64) (*Runner, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runners/%v", owner, repo, runnerID)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runner := new(Runner)
+	resp, err := s.client.Do(ctx, req, runner)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return runner, resp, nil
+}
+
+// RemoveToken represents a token that can be used to remove a self-hosted runner from a repository.
+type RemoveToken struct {
+	Token     *string    `json:"token,omitempty"`
+	ExpiresAt *Timestamp `json:"expires_at,omitempty"`
+}
+
+// CreateRemoveToken creates a token that can be used to remove a self-hosted runner from a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runners#create-a-remove-token-for-a-repository
+//
+//meta:operation POST /repos/{owner}/{repo}/actions/runners/remove-token
+func (s *ActionsService) CreateRemoveToken(ctx context.Context, owner, repo string) (*RemoveToken, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runners/remove-token", owner, repo)
+
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	removeToken := new(RemoveToken)
+	resp, err := s.client.Do(ctx, req, removeToken)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return removeToken, resp, nil
+}
+
+// RemoveRunner forces the removal of a self-hosted runner in a repository using the runner id.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runners#delete-a-self-hosted-runner-from-a-repository
+//
+//meta:operation DELETE /repos/{owner}/{repo}/actions/runners/{runner_id}
+func (s *ActionsService) RemoveRunner(ctx context.Context, owner, repo string, runnerID int64) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runners/%v", owner, repo, runnerID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// ListOrganizationRunnerApplicationDownloads lists self-hosted runner application binaries that can be downloaded and run.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runners#list-runner-applications-for-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/runners/downloads
+func (s *ActionsService) ListOrganizationRunnerApplicationDownloads(ctx context.Context, org string) ([]*RunnerApplicationDownload, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runners/downloads", org)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var rads []*RunnerApplicationDownload
+	resp, err := s.client.Do(ctx, req, &rads)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return rads, resp, nil
+}
+
+// CreateOrganizationRegistrationToken creates a token that can be used to add a self-hosted runner to an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runners#create-a-registration-token-for-an-organization
+//
+//meta:operation POST /orgs/{org}/actions/runners/registration-token
+func (s *ActionsService) CreateOrganizationRegistrationToken(ctx context.Context, org string) (*RegistrationToken, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runners/registration-token", org)
+
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	registrationToken := new(RegistrationToken)
+	resp, err := s.client.Do(ctx, req, registrationToken)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return registrationToken, resp, nil
+}
+
+// ListOrganizationRunners lists all the self-hosted runners for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runners#list-self-hosted-runners-for-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/runners
+func (s *ActionsService) ListOrganizationRunners(ctx context.Context, org string, opts *ListRunnersOptions) (*Runners, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runners", org)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runners := &Runners{}
+	resp, err := s.client.Do(ctx, req, &runners)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return runners, resp, nil
+}
+
+// GetOrganizationRunner gets a specific self-hosted runner for an organization using its runner ID.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runners#get-a-self-hosted-runner-for-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/runners/{runner_id}
+func (s *ActionsService) GetOrganizationRunner(ctx context.Context, org string, runnerID int64) (*Runner, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runners/%v", org, runnerID)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runner := new(Runner)
+	resp, err := s.client.Do(ctx, req, runner)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return runner, resp, nil
+}
+
+// CreateOrganizationRemoveToken creates a token that can be used to remove a self-hosted runner from an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runners#create-a-remove-token-for-an-organization
+//
+//meta:operation POST /orgs/{org}/actions/runners/remove-token
+func (s *ActionsService) CreateOrganizationRemoveToken(ctx context.Context, org string) (*RemoveToken, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runners/remove-token", org)
+
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	removeToken := new(RemoveToken)
+	resp, err := s.client.Do(ctx, req, removeToken)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return removeToken, resp, nil
+}
+
+// RemoveOrganizationRunner forces the removal of a self-hosted runner from an organization using the runner id.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/self-hosted-runners#delete-a-self-hosted-runner-from-an-organization
+//
+//meta:operation DELETE /orgs/{org}/actions/runners/{runner_id}
+func (s *ActionsService) RemoveOrganizationRunner(ctx context.Context, org string, runnerID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/runners/%v", org, runnerID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/actions_secrets.go

@@ -0,0 +1,407 @@
+// Copyright 2020 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strconv"
+)
+
+// PublicKey represents the public key that should be used to encrypt secrets.
+type PublicKey struct {
+	KeyID *string `json:"key_id"`
+	Key   *string `json:"key"`
+}
+
+// UnmarshalJSON implements the json.Unmarshaler interface.
+// This ensures GitHub Enterprise versions which return a numeric key id
+// do not error out when unmarshaling.
+func (p *PublicKey) UnmarshalJSON(data []byte) error {
+	var pk struct {
+		KeyID interface{} `json:"key_id"`
+		Key   *string     `json:"key"`
+	}
+
+	if err := json.Unmarshal(data, &pk); err != nil {
+		return err
+	}
+
+	p.Key = pk.Key
+
+	switch v := pk.KeyID.(type) {
+	case nil:
+		return nil
+	case string:
+		p.KeyID = &v
+	case float64:
+		p.KeyID = Ptr(strconv.FormatFloat(v, 'f', -1, 64))
+	default:
+		return fmt.Errorf("unable to unmarshal %T as a string", v)
+	}
+
+	return nil
+}
+
+func (s *ActionsService) getPublicKey(ctx context.Context, url string) (*PublicKey, *Response, error) {
+	req, err := s.client.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	pubKey := new(PublicKey)
+	resp, err := s.client.Do(ctx, req, pubKey)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return pubKey, resp, nil
+}
+
+// GetRepoPublicKey gets a public key that should be used for secret encryption.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/secrets#get-a-repository-public-key
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/secrets/public-key
+func (s *ActionsService) GetRepoPublicKey(ctx context.Context, owner, repo string) (*PublicKey, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/actions/secrets/public-key", owner, repo)
+	return s.getPublicKey(ctx, url)
+}
+
+// GetOrgPublicKey gets a public key that should be used for secret encryption.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/secrets#get-an-organization-public-key
+//
+//meta:operation GET /orgs/{org}/actions/secrets/public-key
+func (s *ActionsService) GetOrgPublicKey(ctx context.Context, org string) (*PublicKey, *Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/secrets/public-key", org)
+	return s.getPublicKey(ctx, url)
+}
+
+// GetEnvPublicKey gets a public key that should be used for secret encryption.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.7/rest/actions/secrets#get-an-environment-public-key
+//
+//meta:operation GET /repositories/{repository_id}/environments/{environment_name}/secrets/public-key
+func (s *ActionsService) GetEnvPublicKey(ctx context.Context, repoID int, env string) (*PublicKey, *Response, error) {
+	url := fmt.Sprintf("repositories/%v/environments/%v/secrets/public-key", repoID, env)
+	return s.getPublicKey(ctx, url)
+}
+
+// Secret represents a repository action secret.
+type Secret struct {
+	Name                    string    `json:"name"`
+	CreatedAt               Timestamp `json:"created_at"`
+	UpdatedAt               Timestamp `json:"updated_at"`
+	Visibility              string    `json:"visibility,omitempty"`
+	SelectedRepositoriesURL string    `json:"selected_repositories_url,omitempty"`
+}
+
+// Secrets represents one item from the ListSecrets response.
+type Secrets struct {
+	TotalCount int       `json:"total_count"`
+	Secrets    []*Secret `json:"secrets"`
+}
+
+func (s *ActionsService) listSecrets(ctx context.Context, url string, opts *ListOptions) (*Secrets, *Response, error) {
+	u, err := addOptions(url, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	secrets := new(Secrets)
+	resp, err := s.client.Do(ctx, req, &secrets)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return secrets, resp, nil
+}
+
+// ListRepoSecrets lists all secrets available in a repository
+// without revealing their encrypted values.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/secrets#list-repository-secrets
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/secrets
+func (s *ActionsService) ListRepoSecrets(ctx context.Context, owner, repo string, opts *ListOptions) (*Secrets, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/actions/secrets", owner, repo)
+	return s.listSecrets(ctx, url, opts)
+}
+
+// ListRepoOrgSecrets lists all organization secrets available in a repository
+// without revealing their encrypted values.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/secrets#list-repository-organization-secrets
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/organization-secrets
+func (s *ActionsService) ListRepoOrgSecrets(ctx context.Context, owner, repo string, opts *ListOptions) (*Secrets, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/actions/organization-secrets", owner, repo)
+	return s.listSecrets(ctx, url, opts)
+}
+
+// ListOrgSecrets lists all secrets available in an organization
+// without revealing their encrypted values.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/secrets#list-organization-secrets
+//
+//meta:operation GET /orgs/{org}/actions/secrets
+func (s *ActionsService) ListOrgSecrets(ctx context.Context, org string, opts *ListOptions) (*Secrets, *Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/secrets", org)
+	return s.listSecrets(ctx, url, opts)
+}
+
+// ListEnvSecrets lists all secrets available in an environment.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.7/rest/actions/secrets#list-environment-secrets
+//
+//meta:operation GET /repositories/{repository_id}/environments/{environment_name}/secrets
+func (s *ActionsService) ListEnvSecrets(ctx context.Context, repoID int, env string, opts *ListOptions) (*Secrets, *Response, error) {
+	url := fmt.Sprintf("repositories/%v/environments/%v/secrets", repoID, env)
+	return s.listSecrets(ctx, url, opts)
+}
+
+func (s *ActionsService) getSecret(ctx context.Context, url string) (*Secret, *Response, error) {
+	req, err := s.client.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	secret := new(Secret)
+	resp, err := s.client.Do(ctx, req, secret)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return secret, resp, nil
+}
+
+// GetRepoSecret gets a single repository secret without revealing its encrypted value.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/secrets#get-a-repository-secret
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/secrets/{secret_name}
+func (s *ActionsService) GetRepoSecret(ctx context.Context, owner, repo, name string) (*Secret, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/actions/secrets/%v", owner, repo, name)
+	return s.getSecret(ctx, url)
+}
+
+// GetOrgSecret gets a single organization secret without revealing its encrypted value.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/secrets#get-an-organization-secret
+//
+//meta:operation GET /orgs/{org}/actions/secrets/{secret_name}
+func (s *ActionsService) GetOrgSecret(ctx context.Context, org, name string) (*Secret, *Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/secrets/%v", org, name)
+	return s.getSecret(ctx, url)
+}
+
+// GetEnvSecret gets a single environment secret without revealing its encrypted value.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.7/rest/actions/secrets#get-an-environment-secret
+//
+//meta:operation GET /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}
+func (s *ActionsService) GetEnvSecret(ctx context.Context, repoID int, env, secretName string) (*Secret, *Response, error) {
+	url := fmt.Sprintf("repositories/%v/environments/%v/secrets/%v", repoID, env, secretName)
+	return s.getSecret(ctx, url)
+}
+
+// SelectedRepoIDs are the repository IDs that have access to the actions secrets.
+type SelectedRepoIDs []int64
+
+// EncryptedSecret represents a secret that is encrypted using a public key.
+//
+// The value of EncryptedValue must be your secret, encrypted with
+// LibSodium (see documentation here: https://libsodium.gitbook.io/doc/bindings_for_other_languages)
+// using the public key retrieved using the GetPublicKey method.
+type EncryptedSecret struct {
+	Name                  string          `json:"-"`
+	KeyID                 string          `json:"key_id"`
+	EncryptedValue        string          `json:"encrypted_value"`
+	Visibility            string          `json:"visibility,omitempty"`
+	SelectedRepositoryIDs SelectedRepoIDs `json:"selected_repository_ids,omitempty"`
+}
+
+func (s *ActionsService) putSecret(ctx context.Context, url string, eSecret *EncryptedSecret) (*Response, error) {
+	req, err := s.client.NewRequest("PUT", url, eSecret)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// CreateOrUpdateRepoSecret creates or updates a repository secret with an encrypted value.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/secrets#create-or-update-a-repository-secret
+//
+//meta:operation PUT /repos/{owner}/{repo}/actions/secrets/{secret_name}
+func (s *ActionsService) CreateOrUpdateRepoSecret(ctx context.Context, owner, repo string, eSecret *EncryptedSecret) (*Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/actions/secrets/%v", owner, repo, eSecret.Name)
+	return s.putSecret(ctx, url, eSecret)
+}
+
+// CreateOrUpdateOrgSecret creates or updates an organization secret with an encrypted value.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/secrets#create-or-update-an-organization-secret
+//
+//meta:operation PUT /orgs/{org}/actions/secrets/{secret_name}
+func (s *ActionsService) CreateOrUpdateOrgSecret(ctx context.Context, org string, eSecret *EncryptedSecret) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/secrets/%v", org, eSecret.Name)
+	return s.putSecret(ctx, url, eSecret)
+}
+
+// CreateOrUpdateEnvSecret creates or updates a single environment secret with an encrypted value.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.7/rest/actions/secrets#create-or-update-an-environment-secret
+//
+//meta:operation PUT /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}
+func (s *ActionsService) CreateOrUpdateEnvSecret(ctx context.Context, repoID int, env string, eSecret *EncryptedSecret) (*Response, error) {
+	url := fmt.Sprintf("repositories/%v/environments/%v/secrets/%v", repoID, env, eSecret.Name)
+	return s.putSecret(ctx, url, eSecret)
+}
+
+func (s *ActionsService) deleteSecret(ctx context.Context, url string) (*Response, error) {
+	req, err := s.client.NewRequest("DELETE", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// DeleteRepoSecret deletes a secret in a repository using the secret name.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/secrets#delete-a-repository-secret
+//
+//meta:operation DELETE /repos/{owner}/{repo}/actions/secrets/{secret_name}
+func (s *ActionsService) DeleteRepoSecret(ctx context.Context, owner, repo, name string) (*Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/actions/secrets/%v", owner, repo, name)
+	return s.deleteSecret(ctx, url)
+}
+
+// DeleteOrgSecret deletes a secret in an organization using the secret name.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/secrets#delete-an-organization-secret
+//
+//meta:operation DELETE /orgs/{org}/actions/secrets/{secret_name}
+func (s *ActionsService) DeleteOrgSecret(ctx context.Context, org, name string) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/secrets/%v", org, name)
+	return s.deleteSecret(ctx, url)
+}
+
+// DeleteEnvSecret deletes a secret in an environment using the secret name.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.7/rest/actions/secrets#delete-an-environment-secret
+//
+//meta:operation DELETE /repositories/{repository_id}/environments/{environment_name}/secrets/{secret_name}
+func (s *ActionsService) DeleteEnvSecret(ctx context.Context, repoID int, env, secretName string) (*Response, error) {
+	url := fmt.Sprintf("repositories/%v/environments/%v/secrets/%v", repoID, env, secretName)
+	return s.deleteSecret(ctx, url)
+}
+
+// SelectedReposList represents the list of repositories selected for an organization secret.
+type SelectedReposList struct {
+	TotalCount   *int          `json:"total_count,omitempty"`
+	Repositories []*Repository `json:"repositories,omitempty"`
+}
+
+func (s *ActionsService) listSelectedReposForSecret(ctx context.Context, url string, opts *ListOptions) (*SelectedReposList, *Response, error) {
+	u, err := addOptions(url, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	result := new(SelectedReposList)
+	resp, err := s.client.Do(ctx, req, result)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return result, resp, nil
+}
+
+// ListSelectedReposForOrgSecret lists all repositories that have access to a secret.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/secrets#list-selected-repositories-for-an-organization-secret
+//
+//meta:operation GET /orgs/{org}/actions/secrets/{secret_name}/repositories
+func (s *ActionsService) ListSelectedReposForOrgSecret(ctx context.Context, org, name string, opts *ListOptions) (*SelectedReposList, *Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/secrets/%v/repositories", org, name)
+	return s.listSelectedReposForSecret(ctx, url, opts)
+}
+
+func (s *ActionsService) setSelectedReposForSecret(ctx context.Context, url string, ids SelectedRepoIDs) (*Response, error) {
+	type repoIDs struct {
+		SelectedIDs SelectedRepoIDs `json:"selected_repository_ids"`
+	}
+
+	req, err := s.client.NewRequest("PUT", url, repoIDs{SelectedIDs: ids})
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// SetSelectedReposForOrgSecret sets the repositories that have access to a secret.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/secrets#set-selected-repositories-for-an-organization-secret
+//
+//meta:operation PUT /orgs/{org}/actions/secrets/{secret_name}/repositories
+func (s *ActionsService) SetSelectedReposForOrgSecret(ctx context.Context, org, name string, ids SelectedRepoIDs) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/secrets/%v/repositories", org, name)
+	return s.setSelectedReposForSecret(ctx, url, ids)
+}
+
+func (s *ActionsService) addSelectedRepoToSecret(ctx context.Context, url string) (*Response, error) {
+	req, err := s.client.NewRequest("PUT", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// AddSelectedRepoToOrgSecret adds a repository to an organization secret.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/secrets#add-selected-repository-to-an-organization-secret
+//
+//meta:operation PUT /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}
+func (s *ActionsService) AddSelectedRepoToOrgSecret(ctx context.Context, org, name string, repo *Repository) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/secrets/%v/repositories/%v", org, name, *repo.ID)
+	return s.addSelectedRepoToSecret(ctx, url)
+}
+
+func (s *ActionsService) removeSelectedRepoFromSecret(ctx context.Context, url string) (*Response, error) {
+	req, err := s.client.NewRequest("DELETE", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// RemoveSelectedRepoFromOrgSecret removes a repository from an organization secret.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/secrets#remove-selected-repository-from-an-organization-secret
+//
+//meta:operation DELETE /orgs/{org}/actions/secrets/{secret_name}/repositories/{repository_id}
+func (s *ActionsService) RemoveSelectedRepoFromOrgSecret(ctx context.Context, org, name string, repo *Repository) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/secrets/%v/repositories/%v", org, name, *repo.ID)
+	return s.removeSelectedRepoFromSecret(ctx, url)
+}

vendor/github.com/google/go-github/v69/github/actions_variables.go

@@ -0,0 +1,341 @@
+// Copyright 2023 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ActionsVariable represents a repository action variable.
+type ActionsVariable struct {
+	Name       string     `json:"name"`
+	Value      string     `json:"value"`
+	CreatedAt  *Timestamp `json:"created_at,omitempty"`
+	UpdatedAt  *Timestamp `json:"updated_at,omitempty"`
+	Visibility *string    `json:"visibility,omitempty"`
+	// Used by ListOrgVariables and GetOrgVariables
+	SelectedRepositoriesURL *string `json:"selected_repositories_url,omitempty"`
+	// Used by UpdateOrgVariable and CreateOrgVariable
+	SelectedRepositoryIDs *SelectedRepoIDs `json:"selected_repository_ids,omitempty"`
+}
+
+// ActionsVariables represents one item from the ListVariables response.
+type ActionsVariables struct {
+	TotalCount int                `json:"total_count"`
+	Variables  []*ActionsVariable `json:"variables"`
+}
+
+func (s *ActionsService) listVariables(ctx context.Context, url string, opts *ListOptions) (*ActionsVariables, *Response, error) {
+	u, err := addOptions(url, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	variables := new(ActionsVariables)
+	resp, err := s.client.Do(ctx, req, &variables)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return variables, resp, nil
+}
+
+// ListRepoVariables lists all variables available in a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#list-repository-variables
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/variables
+func (s *ActionsService) ListRepoVariables(ctx context.Context, owner, repo string, opts *ListOptions) (*ActionsVariables, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/actions/variables", owner, repo)
+	return s.listVariables(ctx, url, opts)
+}
+
+// ListRepoOrgVariables lists all organization variables available in a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#list-repository-organization-variables
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/organization-variables
+func (s *ActionsService) ListRepoOrgVariables(ctx context.Context, owner, repo string, opts *ListOptions) (*ActionsVariables, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/actions/organization-variables", owner, repo)
+	return s.listVariables(ctx, url, opts)
+}
+
+// ListOrgVariables lists all variables available in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#list-organization-variables
+//
+//meta:operation GET /orgs/{org}/actions/variables
+func (s *ActionsService) ListOrgVariables(ctx context.Context, org string, opts *ListOptions) (*ActionsVariables, *Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/variables", org)
+	return s.listVariables(ctx, url, opts)
+}
+
+// ListEnvVariables lists all variables available in an environment.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#list-environment-variables
+//
+//meta:operation GET /repos/{owner}/{repo}/environments/{environment_name}/variables
+func (s *ActionsService) ListEnvVariables(ctx context.Context, owner, repo, env string, opts *ListOptions) (*ActionsVariables, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/environments/%v/variables", owner, repo, env)
+	return s.listVariables(ctx, url, opts)
+}
+
+func (s *ActionsService) getVariable(ctx context.Context, url string) (*ActionsVariable, *Response, error) {
+	req, err := s.client.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	variable := new(ActionsVariable)
+	resp, err := s.client.Do(ctx, req, variable)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return variable, resp, nil
+}
+
+// GetRepoVariable gets a single repository variable.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#get-a-repository-variable
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/variables/{name}
+func (s *ActionsService) GetRepoVariable(ctx context.Context, owner, repo, name string) (*ActionsVariable, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/actions/variables/%v", owner, repo, name)
+	return s.getVariable(ctx, url)
+}
+
+// GetOrgVariable gets a single organization variable.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#get-an-organization-variable
+//
+//meta:operation GET /orgs/{org}/actions/variables/{name}
+func (s *ActionsService) GetOrgVariable(ctx context.Context, org, name string) (*ActionsVariable, *Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/variables/%v", org, name)
+	return s.getVariable(ctx, url)
+}
+
+// GetEnvVariable gets a single environment variable.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#get-an-environment-variable
+//
+//meta:operation GET /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}
+func (s *ActionsService) GetEnvVariable(ctx context.Context, owner, repo, env, variableName string) (*ActionsVariable, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/environments/%v/variables/%v", owner, repo, env, variableName)
+	return s.getVariable(ctx, url)
+}
+
+func (s *ActionsService) postVariable(ctx context.Context, url string, variable *ActionsVariable) (*Response, error) {
+	req, err := s.client.NewRequest("POST", url, variable)
+	if err != nil {
+		return nil, err
+	}
+	return s.client.Do(ctx, req, nil)
+}
+
+// CreateRepoVariable creates a repository variable.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#create-a-repository-variable
+//
+//meta:operation POST /repos/{owner}/{repo}/actions/variables
+func (s *ActionsService) CreateRepoVariable(ctx context.Context, owner, repo string, variable *ActionsVariable) (*Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/actions/variables", owner, repo)
+	return s.postVariable(ctx, url, variable)
+}
+
+// CreateOrgVariable creates an organization variable.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#create-an-organization-variable
+//
+//meta:operation POST /orgs/{org}/actions/variables
+func (s *ActionsService) CreateOrgVariable(ctx context.Context, org string, variable *ActionsVariable) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/variables", org)
+	return s.postVariable(ctx, url, variable)
+}
+
+// CreateEnvVariable creates an environment variable.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#create-an-environment-variable
+//
+//meta:operation POST /repos/{owner}/{repo}/environments/{environment_name}/variables
+func (s *ActionsService) CreateEnvVariable(ctx context.Context, owner, repo, env string, variable *ActionsVariable) (*Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/environments/%v/variables", owner, repo, env)
+	return s.postVariable(ctx, url, variable)
+}
+
+func (s *ActionsService) patchVariable(ctx context.Context, url string, variable *ActionsVariable) (*Response, error) {
+	req, err := s.client.NewRequest("PATCH", url, variable)
+	if err != nil {
+		return nil, err
+	}
+	return s.client.Do(ctx, req, nil)
+}
+
+// UpdateRepoVariable updates a repository variable.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#update-a-repository-variable
+//
+//meta:operation PATCH /repos/{owner}/{repo}/actions/variables/{name}
+func (s *ActionsService) UpdateRepoVariable(ctx context.Context, owner, repo string, variable *ActionsVariable) (*Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/actions/variables/%v", owner, repo, variable.Name)
+	return s.patchVariable(ctx, url, variable)
+}
+
+// UpdateOrgVariable updates an organization variable.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#update-an-organization-variable
+//
+//meta:operation PATCH /orgs/{org}/actions/variables/{name}
+func (s *ActionsService) UpdateOrgVariable(ctx context.Context, org string, variable *ActionsVariable) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/variables/%v", org, variable.Name)
+	return s.patchVariable(ctx, url, variable)
+}
+
+// UpdateEnvVariable updates an environment variable.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#update-an-environment-variable
+//
+//meta:operation PATCH /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}
+func (s *ActionsService) UpdateEnvVariable(ctx context.Context, owner, repo, env string, variable *ActionsVariable) (*Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/environments/%v/variables/%v", owner, repo, env, variable.Name)
+	return s.patchVariable(ctx, url, variable)
+}
+
+func (s *ActionsService) deleteVariable(ctx context.Context, url string) (*Response, error) {
+	req, err := s.client.NewRequest("DELETE", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// DeleteRepoVariable deletes a variable in a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#delete-a-repository-variable
+//
+//meta:operation DELETE /repos/{owner}/{repo}/actions/variables/{name}
+func (s *ActionsService) DeleteRepoVariable(ctx context.Context, owner, repo, name string) (*Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/actions/variables/%v", owner, repo, name)
+	return s.deleteVariable(ctx, url)
+}
+
+// DeleteOrgVariable deletes a variable in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#delete-an-organization-variable
+//
+//meta:operation DELETE /orgs/{org}/actions/variables/{name}
+func (s *ActionsService) DeleteOrgVariable(ctx context.Context, org, name string) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/variables/%v", org, name)
+	return s.deleteVariable(ctx, url)
+}
+
+// DeleteEnvVariable deletes a variable in an environment.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#delete-an-environment-variable
+//
+//meta:operation DELETE /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}
+func (s *ActionsService) DeleteEnvVariable(ctx context.Context, owner, repo, env, variableName string) (*Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/environments/%v/variables/%v", owner, repo, env, variableName)
+	return s.deleteVariable(ctx, url)
+}
+
+func (s *ActionsService) listSelectedReposForVariable(ctx context.Context, url string, opts *ListOptions) (*SelectedReposList, *Response, error) {
+	u, err := addOptions(url, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	result := new(SelectedReposList)
+	resp, err := s.client.Do(ctx, req, result)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return result, resp, nil
+}
+
+// ListSelectedReposForOrgVariable lists all repositories that have access to a variable.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#list-selected-repositories-for-an-organization-variable
+//
+//meta:operation GET /orgs/{org}/actions/variables/{name}/repositories
+func (s *ActionsService) ListSelectedReposForOrgVariable(ctx context.Context, org, name string, opts *ListOptions) (*SelectedReposList, *Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/variables/%v/repositories", org, name)
+	return s.listSelectedReposForVariable(ctx, url, opts)
+}
+
+func (s *ActionsService) setSelectedReposForVariable(ctx context.Context, url string, ids SelectedRepoIDs) (*Response, error) {
+	type repoIDs struct {
+		SelectedIDs SelectedRepoIDs `json:"selected_repository_ids"`
+	}
+
+	req, err := s.client.NewRequest("PUT", url, repoIDs{SelectedIDs: ids})
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// SetSelectedReposForOrgVariable sets the repositories that have access to a variable.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#set-selected-repositories-for-an-organization-variable
+//
+//meta:operation PUT /orgs/{org}/actions/variables/{name}/repositories
+func (s *ActionsService) SetSelectedReposForOrgVariable(ctx context.Context, org, name string, ids SelectedRepoIDs) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/variables/%v/repositories", org, name)
+	return s.setSelectedReposForVariable(ctx, url, ids)
+}
+
+func (s *ActionsService) addSelectedRepoToVariable(ctx context.Context, url string) (*Response, error) {
+	req, err := s.client.NewRequest("PUT", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// AddSelectedRepoToOrgVariable adds a repository to an organization variable.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#add-selected-repository-to-an-organization-variable
+//
+//meta:operation PUT /orgs/{org}/actions/variables/{name}/repositories/{repository_id}
+func (s *ActionsService) AddSelectedRepoToOrgVariable(ctx context.Context, org, name string, repo *Repository) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/variables/%v/repositories/%v", org, name, *repo.ID)
+	return s.addSelectedRepoToVariable(ctx, url)
+}
+
+func (s *ActionsService) removeSelectedRepoFromVariable(ctx context.Context, url string) (*Response, error) {
+	req, err := s.client.NewRequest("DELETE", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// RemoveSelectedRepoFromOrgVariable removes a repository from an organization variable.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/variables#remove-selected-repository-from-an-organization-variable
+//
+//meta:operation DELETE /orgs/{org}/actions/variables/{name}/repositories/{repository_id}
+func (s *ActionsService) RemoveSelectedRepoFromOrgVariable(ctx context.Context, org, name string, repo *Repository) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/actions/variables/%v/repositories/%v", org, name, *repo.ID)
+	return s.removeSelectedRepoFromVariable(ctx, url)
+}

vendor/github.com/google/go-github/v69/github/actions_workflow_jobs.go

@@ -0,0 +1,193 @@
+// Copyright 2020 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+)
+
+// TaskStep represents a single task step from a sequence of tasks of a job.
+type TaskStep struct {
+	Name        *string    `json:"name,omitempty"`
+	Status      *string    `json:"status,omitempty"`
+	Conclusion  *string    `json:"conclusion,omitempty"`
+	Number      *int64     `json:"number,omitempty"`
+	StartedAt   *Timestamp `json:"started_at,omitempty"`
+	CompletedAt *Timestamp `json:"completed_at,omitempty"`
+}
+
+// WorkflowJob represents a repository action workflow job.
+type WorkflowJob struct {
+	ID          *int64      `json:"id,omitempty"`
+	RunID       *int64      `json:"run_id,omitempty"`
+	RunURL      *string     `json:"run_url,omitempty"`
+	NodeID      *string     `json:"node_id,omitempty"`
+	HeadBranch  *string     `json:"head_branch,omitempty"`
+	HeadSHA     *string     `json:"head_sha,omitempty"`
+	URL         *string     `json:"url,omitempty"`
+	HTMLURL     *string     `json:"html_url,omitempty"`
+	Status      *string     `json:"status,omitempty"`
+	Conclusion  *string     `json:"conclusion,omitempty"`
+	CreatedAt   *Timestamp  `json:"created_at,omitempty"`
+	StartedAt   *Timestamp  `json:"started_at,omitempty"`
+	CompletedAt *Timestamp  `json:"completed_at,omitempty"`
+	Name        *string     `json:"name,omitempty"`
+	Steps       []*TaskStep `json:"steps,omitempty"`
+	CheckRunURL *string     `json:"check_run_url,omitempty"`
+	// Labels represents runner labels from the `runs-on:` key from a GitHub Actions workflow.
+	Labels          []string `json:"labels,omitempty"`
+	RunnerID        *int64   `json:"runner_id,omitempty"`
+	RunnerName      *string  `json:"runner_name,omitempty"`
+	RunnerGroupID   *int64   `json:"runner_group_id,omitempty"`
+	RunnerGroupName *string  `json:"runner_group_name,omitempty"`
+	RunAttempt      *int64   `json:"run_attempt,omitempty"`
+	WorkflowName    *string  `json:"workflow_name,omitempty"`
+}
+
+// Jobs represents a slice of repository action workflow job.
+type Jobs struct {
+	TotalCount *int           `json:"total_count,omitempty"`
+	Jobs       []*WorkflowJob `json:"jobs,omitempty"`
+}
+
+// ListWorkflowJobsOptions specifies optional parameters to ListWorkflowJobs.
+type ListWorkflowJobsOptions struct {
+	// Filter specifies how jobs should be filtered by their completed_at timestamp.
+	// Possible values are:
+	//     latest - Returns jobs from the most recent execution of the workflow run
+	//     all - Returns all jobs for a workflow run, including from old executions of the workflow run
+	//
+	// Default value is "latest".
+	Filter string `url:"filter,omitempty"`
+	ListOptions
+}
+
+// ListWorkflowJobs lists all jobs for a workflow run.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-jobs#list-jobs-for-a-workflow-run
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/runs/{run_id}/jobs
+func (s *ActionsService) ListWorkflowJobs(ctx context.Context, owner, repo string, runID int64, opts *ListWorkflowJobsOptions) (*Jobs, *Response, error) {
+	u := fmt.Sprintf("repos/%s/%s/actions/runs/%v/jobs", owner, repo, runID)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	jobs := new(Jobs)
+	resp, err := s.client.Do(ctx, req, &jobs)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return jobs, resp, nil
+}
+
+// ListWorkflowJobsAttempt lists jobs for a workflow run Attempt.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-jobs#list-jobs-for-a-workflow-run-attempt
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/jobs
+func (s *ActionsService) ListWorkflowJobsAttempt(ctx context.Context, owner, repo string, runID, attemptNumber int64, opts *ListOptions) (*Jobs, *Response, error) {
+	u := fmt.Sprintf("repos/%s/%s/actions/runs/%v/attempts/%v/jobs", owner, repo, runID, attemptNumber)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	jobs := new(Jobs)
+	resp, err := s.client.Do(ctx, req, &jobs)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return jobs, resp, nil
+}
+
+// GetWorkflowJobByID gets a specific job in a workflow run by ID.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-jobs#get-a-job-for-a-workflow-run
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/jobs/{job_id}
+func (s *ActionsService) GetWorkflowJobByID(ctx context.Context, owner, repo string, jobID int64) (*WorkflowJob, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/jobs/%v", owner, repo, jobID)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	job := new(WorkflowJob)
+	resp, err := s.client.Do(ctx, req, job)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return job, resp, nil
+}
+
+// GetWorkflowJobLogs gets a redirect URL to download a plain text file of logs for a workflow job.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-jobs#download-job-logs-for-a-workflow-run
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/jobs/{job_id}/logs
+func (s *ActionsService) GetWorkflowJobLogs(ctx context.Context, owner, repo string, jobID int64, maxRedirects int) (*url.URL, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/jobs/%v/logs", owner, repo, jobID)
+
+	if s.client.RateLimitRedirectionalEndpoints {
+		return s.getWorkflowJobLogsWithRateLimit(ctx, u, maxRedirects)
+	}
+
+	return s.getWorkflowJobLogsWithoutRateLimit(ctx, u, maxRedirects)
+}
+
+func (s *ActionsService) getWorkflowJobLogsWithoutRateLimit(ctx context.Context, u string, maxRedirects int) (*url.URL, *Response, error) {
+	resp, err := s.client.roundTripWithOptionalFollowRedirect(ctx, u, maxRedirects)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusFound {
+		return nil, newResponse(resp), fmt.Errorf("unexpected status code: %v", resp.Status)
+	}
+
+	parsedURL, err := url.Parse(resp.Header.Get("Location"))
+	return parsedURL, newResponse(resp), err
+}
+
+func (s *ActionsService) getWorkflowJobLogsWithRateLimit(ctx context.Context, u string, maxRedirects int) (*url.URL, *Response, error) {
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	url, resp, err := s.client.bareDoUntilFound(ctx, req, maxRedirects)
+	if err != nil {
+		return nil, resp, err
+	}
+	defer resp.Body.Close()
+
+	// If we didn't receive a valid Location in a 302 response
+	if url == nil {
+		return nil, resp, fmt.Errorf("unexpected status code: %v", resp.Status)
+	}
+
+	return url, resp, nil
+}

vendor/github.com/google/go-github/v69/github/actions_workflow_runs.go

@@ -0,0 +1,546 @@
+// Copyright 2020 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+)
+
+// WorkflowRun represents a repository action workflow run.
+type WorkflowRun struct {
+	ID                  *int64                `json:"id,omitempty"`
+	Name                *string               `json:"name,omitempty"`
+	NodeID              *string               `json:"node_id,omitempty"`
+	HeadBranch          *string               `json:"head_branch,omitempty"`
+	HeadSHA             *string               `json:"head_sha,omitempty"`
+	Path                *string               `json:"path,omitempty"`
+	RunNumber           *int                  `json:"run_number,omitempty"`
+	RunAttempt          *int                  `json:"run_attempt,omitempty"`
+	Event               *string               `json:"event,omitempty"`
+	DisplayTitle        *string               `json:"display_title,omitempty"`
+	Status              *string               `json:"status,omitempty"`
+	Conclusion          *string               `json:"conclusion,omitempty"`
+	WorkflowID          *int64                `json:"workflow_id,omitempty"`
+	CheckSuiteID        *int64                `json:"check_suite_id,omitempty"`
+	CheckSuiteNodeID    *string               `json:"check_suite_node_id,omitempty"`
+	URL                 *string               `json:"url,omitempty"`
+	HTMLURL             *string               `json:"html_url,omitempty"`
+	PullRequests        []*PullRequest        `json:"pull_requests,omitempty"`
+	CreatedAt           *Timestamp            `json:"created_at,omitempty"`
+	UpdatedAt           *Timestamp            `json:"updated_at,omitempty"`
+	RunStartedAt        *Timestamp            `json:"run_started_at,omitempty"`
+	JobsURL             *string               `json:"jobs_url,omitempty"`
+	LogsURL             *string               `json:"logs_url,omitempty"`
+	CheckSuiteURL       *string               `json:"check_suite_url,omitempty"`
+	ArtifactsURL        *string               `json:"artifacts_url,omitempty"`
+	CancelURL           *string               `json:"cancel_url,omitempty"`
+	RerunURL            *string               `json:"rerun_url,omitempty"`
+	PreviousAttemptURL  *string               `json:"previous_attempt_url,omitempty"`
+	HeadCommit          *HeadCommit           `json:"head_commit,omitempty"`
+	WorkflowURL         *string               `json:"workflow_url,omitempty"`
+	Repository          *Repository           `json:"repository,omitempty"`
+	HeadRepository      *Repository           `json:"head_repository,omitempty"`
+	Actor               *User                 `json:"actor,omitempty"`
+	TriggeringActor     *User                 `json:"triggering_actor,omitempty"`
+	ReferencedWorkflows []*ReferencedWorkflow `json:"referenced_workflows,omitempty"`
+}
+
+// WorkflowRuns represents a slice of repository action workflow run.
+type WorkflowRuns struct {
+	TotalCount   *int           `json:"total_count,omitempty"`
+	WorkflowRuns []*WorkflowRun `json:"workflow_runs,omitempty"`
+}
+
+// ListWorkflowRunsOptions specifies optional parameters to ListWorkflowRuns.
+type ListWorkflowRunsOptions struct {
+	Actor               string `url:"actor,omitempty"`
+	Branch              string `url:"branch,omitempty"`
+	Event               string `url:"event,omitempty"`
+	Status              string `url:"status,omitempty"`
+	Created             string `url:"created,omitempty"`
+	HeadSHA             string `url:"head_sha,omitempty"`
+	ExcludePullRequests bool   `url:"exclude_pull_requests,omitempty"`
+	CheckSuiteID        int64  `url:"check_suite_id,omitempty"`
+	ListOptions
+}
+
+// WorkflowRunUsage represents a usage of a specific workflow run.
+type WorkflowRunUsage struct {
+	Billable      *WorkflowRunBillMap `json:"billable,omitempty"`
+	RunDurationMS *int64              `json:"run_duration_ms,omitempty"`
+}
+
+// WorkflowRunBillMap represents different runner environments available for a workflow run.
+// Its key is the name of its environment, e.g. "UBUNTU", "MACOS", "WINDOWS", etc.
+type WorkflowRunBillMap map[string]*WorkflowRunBill
+
+// WorkflowRunBill specifies billable time for a specific environment in a workflow run.
+type WorkflowRunBill struct {
+	TotalMS *int64               `json:"total_ms,omitempty"`
+	Jobs    *int                 `json:"jobs,omitempty"`
+	JobRuns []*WorkflowRunJobRun `json:"job_runs,omitempty"`
+}
+
+// WorkflowRunJobRun represents a usage of individual jobs of a specific workflow run.
+type WorkflowRunJobRun struct {
+	JobID      *int   `json:"job_id,omitempty"`
+	DurationMS *int64 `json:"duration_ms,omitempty"`
+}
+
+// WorkflowRunAttemptOptions specifies optional parameters to GetWorkflowRunAttempt.
+type WorkflowRunAttemptOptions struct {
+	ExcludePullRequests *bool `url:"exclude_pull_requests,omitempty"`
+}
+
+// PendingDeploymentsRequest specifies body parameters to PendingDeployments.
+type PendingDeploymentsRequest struct {
+	EnvironmentIDs []int64 `json:"environment_ids"`
+	// State can be one of: "approved", "rejected".
+	State   string `json:"state"`
+	Comment string `json:"comment"`
+}
+
+type ReferencedWorkflow struct {
+	Path *string `json:"path,omitempty"`
+	SHA  *string `json:"sha,omitempty"`
+	Ref  *string `json:"ref,omitempty"`
+}
+
+// PendingDeployment represents the pending_deployments response.
+type PendingDeployment struct {
+	Environment           *PendingDeploymentEnvironment `json:"environment,omitempty"`
+	WaitTimer             *int64                        `json:"wait_timer,omitempty"`
+	WaitTimerStartedAt    *Timestamp                    `json:"wait_timer_started_at,omitempty"`
+	CurrentUserCanApprove *bool                         `json:"current_user_can_approve,omitempty"`
+	Reviewers             []*RequiredReviewer           `json:"reviewers,omitempty"`
+}
+
+// PendingDeploymentEnvironment represents pending deployment environment properties.
+type PendingDeploymentEnvironment struct {
+	ID      *int64  `json:"id,omitempty"`
+	NodeID  *string `json:"node_id,omitempty"`
+	Name    *string `json:"name,omitempty"`
+	URL     *string `json:"url,omitempty"`
+	HTMLURL *string `json:"html_url,omitempty"`
+}
+
+// ReviewCustomDeploymentProtectionRuleRequest specifies the parameters to ReviewCustomDeploymentProtectionRule.
+type ReviewCustomDeploymentProtectionRuleRequest struct {
+	EnvironmentName string `json:"environment_name"`
+	State           string `json:"state"`
+	Comment         string `json:"comment"`
+}
+
+func (s *ActionsService) listWorkflowRuns(ctx context.Context, endpoint string, opts *ListWorkflowRunsOptions) (*WorkflowRuns, *Response, error) {
+	u, err := addOptions(endpoint, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runs := new(WorkflowRuns)
+	resp, err := s.client.Do(ctx, req, &runs)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return runs, resp, nil
+}
+
+// ListWorkflowRunsByID lists all workflow runs by workflow ID.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#list-workflow-runs-for-a-workflow
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs
+func (s *ActionsService) ListWorkflowRunsByID(ctx context.Context, owner, repo string, workflowID int64, opts *ListWorkflowRunsOptions) (*WorkflowRuns, *Response, error) {
+	u := fmt.Sprintf("repos/%s/%s/actions/workflows/%v/runs", owner, repo, workflowID)
+	return s.listWorkflowRuns(ctx, u, opts)
+}
+
+// ListWorkflowRunsByFileName lists all workflow runs by workflow file name.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#list-workflow-runs-for-a-workflow
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/runs
+func (s *ActionsService) ListWorkflowRunsByFileName(ctx context.Context, owner, repo, workflowFileName string, opts *ListWorkflowRunsOptions) (*WorkflowRuns, *Response, error) {
+	u := fmt.Sprintf("repos/%s/%s/actions/workflows/%v/runs", owner, repo, workflowFileName)
+	return s.listWorkflowRuns(ctx, u, opts)
+}
+
+// ListRepositoryWorkflowRuns lists all workflow runs for a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#list-workflow-runs-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/runs
+func (s *ActionsService) ListRepositoryWorkflowRuns(ctx context.Context, owner, repo string, opts *ListWorkflowRunsOptions) (*WorkflowRuns, *Response, error) {
+	u := fmt.Sprintf("repos/%s/%s/actions/runs", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runs := new(WorkflowRuns)
+	resp, err := s.client.Do(ctx, req, &runs)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return runs, resp, nil
+}
+
+// GetWorkflowRunByID gets a specific workflow run by ID.
+// You can use the helper function *DeploymentProtectionRuleEvent.GetRunID() to easily retrieve the workflow run ID from a DeploymentProtectionRuleEvent.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#get-a-workflow-run
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/runs/{run_id}
+func (s *ActionsService) GetWorkflowRunByID(ctx context.Context, owner, repo string, runID int64) (*WorkflowRun, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runs/%v", owner, repo, runID)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	run := new(WorkflowRun)
+	resp, err := s.client.Do(ctx, req, run)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return run, resp, nil
+}
+
+// GetWorkflowRunAttempt gets a specific workflow run attempt.
+// You can use the helper function *DeploymentProtectionRuleEvent.GetRunID() to easily retrieve the workflow run ID from a DeploymentProtectionRuleEvent.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#get-a-workflow-run-attempt
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}
+func (s *ActionsService) GetWorkflowRunAttempt(ctx context.Context, owner, repo string, runID int64, attemptNumber int, opts *WorkflowRunAttemptOptions) (*WorkflowRun, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runs/%v/attempts/%v", owner, repo, runID, attemptNumber)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	run := new(WorkflowRun)
+	resp, err := s.client.Do(ctx, req, run)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return run, resp, nil
+}
+
+// GetWorkflowRunAttemptLogs gets a redirect URL to download a plain text file of logs for a workflow run for attempt number.
+// You can use the helper function *DeploymentProtectionRuleEvent.GetRunID() to easily retrieve a workflow run ID from the DeploymentProtectionRuleEvent.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#download-workflow-run-attempt-logs
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/runs/{run_id}/attempts/{attempt_number}/logs
+func (s *ActionsService) GetWorkflowRunAttemptLogs(ctx context.Context, owner, repo string, runID int64, attemptNumber int, maxRedirects int) (*url.URL, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runs/%v/attempts/%v/logs", owner, repo, runID, attemptNumber)
+
+	if s.client.RateLimitRedirectionalEndpoints {
+		return s.getWorkflowRunAttemptLogsWithRateLimit(ctx, u, maxRedirects)
+	}
+
+	return s.getWorkflowRunAttemptLogsWithoutRateLimit(ctx, u, maxRedirects)
+}
+
+func (s *ActionsService) getWorkflowRunAttemptLogsWithoutRateLimit(ctx context.Context, u string, maxRedirects int) (*url.URL, *Response, error) {
+	resp, err := s.client.roundTripWithOptionalFollowRedirect(ctx, u, maxRedirects)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusFound {
+		return nil, newResponse(resp), fmt.Errorf("unexpected status code: %v", resp.Status)
+	}
+
+	parsedURL, err := url.Parse(resp.Header.Get("Location"))
+	return parsedURL, newResponse(resp), err
+}
+
+func (s *ActionsService) getWorkflowRunAttemptLogsWithRateLimit(ctx context.Context, u string, maxRedirects int) (*url.URL, *Response, error) {
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	url, resp, err := s.client.bareDoUntilFound(ctx, req, maxRedirects)
+	if err != nil {
+		return nil, resp, err
+	}
+	defer resp.Body.Close()
+
+	// If we didn't receive a valid Location in a 302 response
+	if url == nil {
+		return nil, resp, fmt.Errorf("unexpected status code: %v", resp.Status)
+	}
+
+	return url, resp, nil
+}
+
+// RerunWorkflowByID re-runs a workflow by ID.
+// You can use the helper function *DeploymentProtectionRuleEvent.GetRunID() to easily retrieve the workflow run ID a the DeploymentProtectionRuleEvent.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#re-run-a-workflow
+//
+//meta:operation POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun
+func (s *ActionsService) RerunWorkflowByID(ctx context.Context, owner, repo string, runID int64) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runs/%v/rerun", owner, repo, runID)
+
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// RerunFailedJobsByID re-runs all of the failed jobs and their dependent jobs in a workflow run by ID.
+// You can use the helper function *DeploymentProtectionRuleEvent.GetRunID() to easily retrieve the workflow run ID from a DeploymentProtectionRuleEvent.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#re-run-failed-jobs-from-a-workflow-run
+//
+//meta:operation POST /repos/{owner}/{repo}/actions/runs/{run_id}/rerun-failed-jobs
+func (s *ActionsService) RerunFailedJobsByID(ctx context.Context, owner, repo string, runID int64) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runs/%v/rerun-failed-jobs", owner, repo, runID)
+
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// RerunJobByID re-runs a job and its dependent jobs in a workflow run by ID.
+//
+// You can use the helper function *DeploymentProtectionRuleEvent.GetRunID() to easily retrieve the workflow run ID from a DeploymentProtectionRuleEvent.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#re-run-a-job-from-a-workflow-run
+//
+//meta:operation POST /repos/{owner}/{repo}/actions/jobs/{job_id}/rerun
+func (s *ActionsService) RerunJobByID(ctx context.Context, owner, repo string, jobID int64) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/jobs/%v/rerun", owner, repo, jobID)
+
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// CancelWorkflowRunByID cancels a workflow run by ID.
+// You can use the helper function *DeploymentProtectionRuleEvent.GetRunID() to easily retrieve the workflow run ID from a DeploymentProtectionRuleEvent.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#cancel-a-workflow-run
+//
+//meta:operation POST /repos/{owner}/{repo}/actions/runs/{run_id}/cancel
+func (s *ActionsService) CancelWorkflowRunByID(ctx context.Context, owner, repo string, runID int64) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runs/%v/cancel", owner, repo, runID)
+
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// GetWorkflowRunLogs gets a redirect URL to download a plain text file of logs for a workflow run.
+// You can use the helper function *DeploymentProtectionRuleEvent.GetRunID() to easily retrieve the workflow run ID from a DeploymentProtectionRuleEvent.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#download-workflow-run-logs
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/runs/{run_id}/logs
+func (s *ActionsService) GetWorkflowRunLogs(ctx context.Context, owner, repo string, runID int64, maxRedirects int) (*url.URL, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runs/%v/logs", owner, repo, runID)
+
+	if s.client.RateLimitRedirectionalEndpoints {
+		return s.getWorkflowRunLogsWithRateLimit(ctx, u, maxRedirects)
+	}
+
+	return s.getWorkflowRunLogsWithoutRateLimit(ctx, u, maxRedirects)
+}
+
+func (s *ActionsService) getWorkflowRunLogsWithoutRateLimit(ctx context.Context, u string, maxRedirects int) (*url.URL, *Response, error) {
+	resp, err := s.client.roundTripWithOptionalFollowRedirect(ctx, u, maxRedirects)
+	if err != nil {
+		return nil, nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusFound {
+		return nil, newResponse(resp), fmt.Errorf("unexpected status code: %s", resp.Status)
+	}
+
+	parsedURL, err := url.Parse(resp.Header.Get("Location"))
+	return parsedURL, newResponse(resp), err
+}
+
+func (s *ActionsService) getWorkflowRunLogsWithRateLimit(ctx context.Context, u string, maxRedirects int) (*url.URL, *Response, error) {
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	url, resp, err := s.client.bareDoUntilFound(ctx, req, maxRedirects)
+	if err != nil {
+		return nil, resp, err
+	}
+	defer resp.Body.Close()
+
+	// If we didn't receive a valid Location in a 302 response
+	if url == nil {
+		return nil, resp, fmt.Errorf("unexpected status code: %v", resp.Status)
+	}
+
+	return url, resp, nil
+}
+
+// DeleteWorkflowRun deletes a workflow run by ID.
+// You can use the helper function *DeploymentProtectionRuleEvent.GetRunID() to easily retrieve the workflow run ID from a DeploymentProtectionRuleEvent.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#delete-a-workflow-run
+//
+//meta:operation DELETE /repos/{owner}/{repo}/actions/runs/{run_id}
+func (s *ActionsService) DeleteWorkflowRun(ctx context.Context, owner, repo string, runID int64) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runs/%v", owner, repo, runID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// DeleteWorkflowRunLogs deletes all logs for a workflow run.
+// You can use the helper function *DeploymentProtectionRuleEvent.GetRunID() to easily retrieve the workflow run ID from a DeploymentProtectionRuleEvent.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#delete-workflow-run-logs
+//
+//meta:operation DELETE /repos/{owner}/{repo}/actions/runs/{run_id}/logs
+func (s *ActionsService) DeleteWorkflowRunLogs(ctx context.Context, owner, repo string, runID int64) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runs/%v/logs", owner, repo, runID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// GetWorkflowRunUsageByID gets a specific workflow usage run by run ID in the unit of billable milliseconds.
+// You can use the helper function *DeploymentProtectionRuleEvent.GetRunID() to easily retrieve the workflow run ID from a DeploymentProtectionRuleEvent.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#get-workflow-run-usage
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/runs/{run_id}/timing
+func (s *ActionsService) GetWorkflowRunUsageByID(ctx context.Context, owner, repo string, runID int64) (*WorkflowRunUsage, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runs/%v/timing", owner, repo, runID)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	workflowRunUsage := new(WorkflowRunUsage)
+	resp, err := s.client.Do(ctx, req, workflowRunUsage)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return workflowRunUsage, resp, nil
+}
+
+// GetPendingDeployments get all deployment environments for a workflow run that are waiting for protection rules to pass.
+// You can use the helper function *DeploymentProtectionRuleEvent.GetRunID() to easily retrieve the workflow run ID from a DeploymentProtectionRuleEvent.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#get-pending-deployments-for-a-workflow-run
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments
+func (s *ActionsService) GetPendingDeployments(ctx context.Context, owner, repo string, runID int64) ([]*PendingDeployment, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runs/%v/pending_deployments", owner, repo, runID)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var deployments []*PendingDeployment
+	resp, err := s.client.Do(ctx, req, &deployments)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return deployments, resp, nil
+}
+
+// PendingDeployments approve or reject pending deployments that are waiting on approval by a required reviewer.
+// You can use the helper function *DeploymentProtectionRuleEvent.GetRunID() to easily retrieve the workflow run ID from a DeploymentProtectionRuleEvent.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#review-pending-deployments-for-a-workflow-run
+//
+//meta:operation POST /repos/{owner}/{repo}/actions/runs/{run_id}/pending_deployments
+func (s *ActionsService) PendingDeployments(ctx context.Context, owner, repo string, runID int64, request *PendingDeploymentsRequest) ([]*Deployment, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runs/%v/pending_deployments", owner, repo, runID)
+
+	req, err := s.client.NewRequest("POST", u, request)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var deployments []*Deployment
+	resp, err := s.client.Do(ctx, req, &deployments)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return deployments, resp, nil
+}
+
+// ReviewCustomDeploymentProtectionRule approves or rejects custom deployment protection rules provided by a GitHub App for a workflow run.
+// You can use the helper function *DeploymentProtectionRuleEvent.GetRunID() to easily retrieve the workflow run ID from a DeploymentProtectionRuleEvent.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflow-runs#review-custom-deployment-protection-rules-for-a-workflow-run
+//
+//meta:operation POST /repos/{owner}/{repo}/actions/runs/{run_id}/deployment_protection_rule
+func (s *ActionsService) ReviewCustomDeploymentProtectionRule(ctx context.Context, owner, repo string, runID int64, request *ReviewCustomDeploymentProtectionRuleRequest) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runs/%v/deployment_protection_rule", owner, repo, runID)
+
+	req, err := s.client.NewRequest("POST", u, request)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	return resp, err
+}

vendor/github.com/google/go-github/v69/github/actions_workflows.go

@@ -0,0 +1,237 @@
+// Copyright 2020 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// Workflow represents a repository action workflow.
+type Workflow struct {
+	ID        *int64     `json:"id,omitempty"`
+	NodeID    *string    `json:"node_id,omitempty"`
+	Name      *string    `json:"name,omitempty"`
+	Path      *string    `json:"path,omitempty"`
+	State     *string    `json:"state,omitempty"`
+	CreatedAt *Timestamp `json:"created_at,omitempty"`
+	UpdatedAt *Timestamp `json:"updated_at,omitempty"`
+	URL       *string    `json:"url,omitempty"`
+	HTMLURL   *string    `json:"html_url,omitempty"`
+	BadgeURL  *string    `json:"badge_url,omitempty"`
+}
+
+// Workflows represents a slice of repository action workflows.
+type Workflows struct {
+	TotalCount *int        `json:"total_count,omitempty"`
+	Workflows  []*Workflow `json:"workflows,omitempty"`
+}
+
+// WorkflowUsage represents a usage of a specific workflow.
+type WorkflowUsage struct {
+	Billable *WorkflowBillMap `json:"billable,omitempty"`
+}
+
+// WorkflowBillMap represents different runner environments available for a workflow.
+// Its key is the name of its environment, e.g. "UBUNTU", "MACOS", "WINDOWS", etc.
+type WorkflowBillMap map[string]*WorkflowBill
+
+// WorkflowBill specifies billable time for a specific environment in a workflow.
+type WorkflowBill struct {
+	TotalMS *int64 `json:"total_ms,omitempty"`
+}
+
+// CreateWorkflowDispatchEventRequest represents a request to create a workflow dispatch event.
+type CreateWorkflowDispatchEventRequest struct {
+	// Ref represents the reference of the workflow run.
+	// The reference can be a branch or a tag.
+	// Ref is required when creating a workflow dispatch event.
+	Ref string `json:"ref"`
+	// Inputs represents input keys and values configured in the workflow file.
+	// The maximum number of properties is 10.
+	// Default: Any default properties configured in the workflow file will be used when `inputs` are omitted.
+	Inputs map[string]interface{} `json:"inputs,omitempty"`
+}
+
+// ListWorkflows lists all workflows in a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflows#list-repository-workflows
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/workflows
+func (s *ActionsService) ListWorkflows(ctx context.Context, owner, repo string, opts *ListOptions) (*Workflows, *Response, error) {
+	u := fmt.Sprintf("repos/%s/%s/actions/workflows", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	workflows := new(Workflows)
+	resp, err := s.client.Do(ctx, req, &workflows)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return workflows, resp, nil
+}
+
+// GetWorkflowByID gets a specific workflow by ID.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflows#get-a-workflow
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}
+func (s *ActionsService) GetWorkflowByID(ctx context.Context, owner, repo string, workflowID int64) (*Workflow, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/workflows/%v", owner, repo, workflowID)
+
+	return s.getWorkflow(ctx, u)
+}
+
+// GetWorkflowByFileName gets a specific workflow by file name.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflows#get-a-workflow
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}
+func (s *ActionsService) GetWorkflowByFileName(ctx context.Context, owner, repo, workflowFileName string) (*Workflow, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/workflows/%v", owner, repo, workflowFileName)
+
+	return s.getWorkflow(ctx, u)
+}
+
+func (s *ActionsService) getWorkflow(ctx context.Context, url string) (*Workflow, *Response, error) {
+	req, err := s.client.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	workflow := new(Workflow)
+	resp, err := s.client.Do(ctx, req, workflow)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return workflow, resp, nil
+}
+
+// GetWorkflowUsageByID gets a specific workflow usage by ID in the unit of billable milliseconds.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflows#get-workflow-usage
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing
+func (s *ActionsService) GetWorkflowUsageByID(ctx context.Context, owner, repo string, workflowID int64) (*WorkflowUsage, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/workflows/%v/timing", owner, repo, workflowID)
+
+	return s.getWorkflowUsage(ctx, u)
+}
+
+// GetWorkflowUsageByFileName gets a specific workflow usage by file name in the unit of billable milliseconds.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflows#get-workflow-usage
+//
+//meta:operation GET /repos/{owner}/{repo}/actions/workflows/{workflow_id}/timing
+func (s *ActionsService) GetWorkflowUsageByFileName(ctx context.Context, owner, repo, workflowFileName string) (*WorkflowUsage, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/workflows/%v/timing", owner, repo, workflowFileName)
+
+	return s.getWorkflowUsage(ctx, u)
+}
+
+func (s *ActionsService) getWorkflowUsage(ctx context.Context, url string) (*WorkflowUsage, *Response, error) {
+	req, err := s.client.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	workflowUsage := new(WorkflowUsage)
+	resp, err := s.client.Do(ctx, req, workflowUsage)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return workflowUsage, resp, nil
+}
+
+// CreateWorkflowDispatchEventByID manually triggers a GitHub Actions workflow run.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflows#create-a-workflow-dispatch-event
+//
+//meta:operation POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches
+func (s *ActionsService) CreateWorkflowDispatchEventByID(ctx context.Context, owner, repo string, workflowID int64, event CreateWorkflowDispatchEventRequest) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/workflows/%v/dispatches", owner, repo, workflowID)
+
+	return s.createWorkflowDispatchEvent(ctx, u, &event)
+}
+
+// CreateWorkflowDispatchEventByFileName manually triggers a GitHub Actions workflow run.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflows#create-a-workflow-dispatch-event
+//
+//meta:operation POST /repos/{owner}/{repo}/actions/workflows/{workflow_id}/dispatches
+func (s *ActionsService) CreateWorkflowDispatchEventByFileName(ctx context.Context, owner, repo, workflowFileName string, event CreateWorkflowDispatchEventRequest) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/workflows/%v/dispatches", owner, repo, workflowFileName)
+
+	return s.createWorkflowDispatchEvent(ctx, u, &event)
+}
+
+func (s *ActionsService) createWorkflowDispatchEvent(ctx context.Context, url string, event *CreateWorkflowDispatchEventRequest) (*Response, error) {
+	req, err := s.client.NewRequest("POST", url, event)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// EnableWorkflowByID enables a workflow and sets the state of the workflow to "active".
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflows#enable-a-workflow
+//
+//meta:operation PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/enable
+func (s *ActionsService) EnableWorkflowByID(ctx context.Context, owner, repo string, workflowID int64) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/workflows/%v/enable", owner, repo, workflowID)
+	return s.doNewPutRequest(ctx, u)
+}
+
+// EnableWorkflowByFileName enables a workflow and sets the state of the workflow to "active".
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflows#enable-a-workflow
+//
+//meta:operation PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/enable
+func (s *ActionsService) EnableWorkflowByFileName(ctx context.Context, owner, repo, workflowFileName string) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/workflows/%v/enable", owner, repo, workflowFileName)
+	return s.doNewPutRequest(ctx, u)
+}
+
+// DisableWorkflowByID disables a workflow and sets the state of the workflow to "disabled_manually".
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflows#disable-a-workflow
+//
+//meta:operation PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/disable
+func (s *ActionsService) DisableWorkflowByID(ctx context.Context, owner, repo string, workflowID int64) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/workflows/%v/disable", owner, repo, workflowID)
+	return s.doNewPutRequest(ctx, u)
+}
+
+// DisableWorkflowByFileName disables a workflow and sets the state of the workflow to "disabled_manually".
+//
+// GitHub API docs: https://docs.github.com/rest/actions/workflows#disable-a-workflow
+//
+//meta:operation PUT /repos/{owner}/{repo}/actions/workflows/{workflow_id}/disable
+func (s *ActionsService) DisableWorkflowByFileName(ctx context.Context, owner, repo, workflowFileName string) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/workflows/%v/disable", owner, repo, workflowFileName)
+	return s.doNewPutRequest(ctx, u)
+}
+
+func (s *ActionsService) doNewPutRequest(ctx context.Context, url string) (*Response, error) {
+	req, err := s.client.NewRequest("PUT", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/activity.go

@@ -0,0 +1,77 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import "context"
+
+// ActivityService handles communication with the activity related
+// methods of the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/
+type ActivityService service
+
+// FeedLink represents a link to a related resource.
+type FeedLink struct {
+	HRef *string `json:"href,omitempty"`
+	Type *string `json:"type,omitempty"`
+}
+
+// Feeds represents timeline resources in Atom format.
+type Feeds struct {
+	TimelineURL                 *string    `json:"timeline_url,omitempty"`
+	UserURL                     *string    `json:"user_url,omitempty"`
+	CurrentUserPublicURL        *string    `json:"current_user_public_url,omitempty"`
+	CurrentUserURL              *string    `json:"current_user_url,omitempty"`
+	CurrentUserActorURL         *string    `json:"current_user_actor_url,omitempty"`
+	CurrentUserOrganizationURL  *string    `json:"current_user_organization_url,omitempty"`
+	CurrentUserOrganizationURLs []string   `json:"current_user_organization_urls,omitempty"`
+	Links                       *FeedLinks `json:"_links,omitempty"`
+}
+
+// FeedLinks represents the links in a Feed.
+type FeedLinks struct {
+	Timeline                 *FeedLink   `json:"timeline,omitempty"`
+	User                     *FeedLink   `json:"user,omitempty"`
+	CurrentUserPublic        *FeedLink   `json:"current_user_public,omitempty"`
+	CurrentUser              *FeedLink   `json:"current_user,omitempty"`
+	CurrentUserActor         *FeedLink   `json:"current_user_actor,omitempty"`
+	CurrentUserOrganization  *FeedLink   `json:"current_user_organization,omitempty"`
+	CurrentUserOrganizations []*FeedLink `json:"current_user_organizations,omitempty"`
+}
+
+// ListFeeds lists all the feeds available to the authenticated user.
+//
+// GitHub provides several timeline resources in Atom format:
+//
+//	Timeline: The GitHub global public timeline
+//	User: The public timeline for any user, using URI template
+//	Current user public: The public timeline for the authenticated user
+//	Current user: The private timeline for the authenticated user
+//	Current user actor: The private timeline for activity created by the
+//	    authenticated user
+//	Current user organizations: The private timeline for the organizations
+//	    the authenticated user is a member of.
+//
+// Note: Private feeds are only returned when authenticating via Basic Auth
+// since current feed URIs use the older, non revocable auth tokens.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/feeds#get-feeds
+//
+//meta:operation GET /feeds
+func (s *ActivityService) ListFeeds(ctx context.Context) (*Feeds, *Response, error) {
+	req, err := s.client.NewRequest("GET", "feeds", nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	f := &Feeds{}
+	resp, err := s.client.Do(ctx, req, f)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return f, resp, nil
+}

vendor/github.com/google/go-github/v69/github/activity_events.go

@@ -0,0 +1,235 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ListEvents drinks from the firehose of all public events across GitHub.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/events#list-public-events
+//
+//meta:operation GET /events
+func (s *ActivityService) ListEvents(ctx context.Context, opts *ListOptions) ([]*Event, *Response, error) {
+	u, err := addOptions("events", opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var events []*Event
+	resp, err := s.client.Do(ctx, req, &events)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return events, resp, nil
+}
+
+// ListRepositoryEvents lists events for a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/events#list-repository-events
+//
+//meta:operation GET /repos/{owner}/{repo}/events
+func (s *ActivityService) ListRepositoryEvents(ctx context.Context, owner, repo string, opts *ListOptions) ([]*Event, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/events", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var events []*Event
+	resp, err := s.client.Do(ctx, req, &events)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return events, resp, nil
+}
+
+// ListIssueEventsForRepository lists issue events for a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/events#list-issue-events-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/issues/events
+func (s *ActivityService) ListIssueEventsForRepository(ctx context.Context, owner, repo string, opts *ListOptions) ([]*IssueEvent, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/events", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var events []*IssueEvent
+	resp, err := s.client.Do(ctx, req, &events)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return events, resp, nil
+}
+
+// ListEventsForRepoNetwork lists public events for a network of repositories.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/events#list-public-events-for-a-network-of-repositories
+//
+//meta:operation GET /networks/{owner}/{repo}/events
+func (s *ActivityService) ListEventsForRepoNetwork(ctx context.Context, owner, repo string, opts *ListOptions) ([]*Event, *Response, error) {
+	u := fmt.Sprintf("networks/%v/%v/events", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var events []*Event
+	resp, err := s.client.Do(ctx, req, &events)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return events, resp, nil
+}
+
+// ListEventsForOrganization lists public events for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/events#list-public-organization-events
+//
+//meta:operation GET /orgs/{org}/events
+func (s *ActivityService) ListEventsForOrganization(ctx context.Context, org string, opts *ListOptions) ([]*Event, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/events", org)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var events []*Event
+	resp, err := s.client.Do(ctx, req, &events)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return events, resp, nil
+}
+
+// ListEventsPerformedByUser lists the events performed by a user. If publicOnly is
+// true, only public events will be returned.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/events#list-events-for-the-authenticated-user
+// GitHub API docs: https://docs.github.com/rest/activity/events#list-public-events-for-a-user
+//
+//meta:operation GET /users/{username}/events
+//meta:operation GET /users/{username}/events/public
+func (s *ActivityService) ListEventsPerformedByUser(ctx context.Context, user string, publicOnly bool, opts *ListOptions) ([]*Event, *Response, error) {
+	var u string
+	if publicOnly {
+		u = fmt.Sprintf("users/%v/events/public", user)
+	} else {
+		u = fmt.Sprintf("users/%v/events", user)
+	}
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var events []*Event
+	resp, err := s.client.Do(ctx, req, &events)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return events, resp, nil
+}
+
+// ListEventsReceivedByUser lists the events received by a user. If publicOnly is
+// true, only public events will be returned.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/events#list-events-received-by-the-authenticated-user
+// GitHub API docs: https://docs.github.com/rest/activity/events#list-public-events-received-by-a-user
+//
+//meta:operation GET /users/{username}/received_events
+//meta:operation GET /users/{username}/received_events/public
+func (s *ActivityService) ListEventsReceivedByUser(ctx context.Context, user string, publicOnly bool, opts *ListOptions) ([]*Event, *Response, error) {
+	var u string
+	if publicOnly {
+		u = fmt.Sprintf("users/%v/received_events/public", user)
+	} else {
+		u = fmt.Sprintf("users/%v/received_events", user)
+	}
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var events []*Event
+	resp, err := s.client.Do(ctx, req, &events)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return events, resp, nil
+}
+
+// ListUserEventsForOrganization provides the user’s organization dashboard. You
+// must be authenticated as the user to view this.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/events#list-organization-events-for-the-authenticated-user
+//
+//meta:operation GET /users/{username}/events/orgs/{org}
+func (s *ActivityService) ListUserEventsForOrganization(ctx context.Context, org, user string, opts *ListOptions) ([]*Event, *Response, error) {
+	u := fmt.Sprintf("users/%v/events/orgs/%v", user, org)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var events []*Event
+	resp, err := s.client.Do(ctx, req, &events)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return events, resp, nil
+}

vendor/github.com/google/go-github/v69/github/activity_notifications.go

@@ -0,0 +1,258 @@
+// Copyright 2014 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+// Notification identifies a GitHub notification for a user.
+type Notification struct {
+	ID         *string              `json:"id,omitempty"`
+	Repository *Repository          `json:"repository,omitempty"`
+	Subject    *NotificationSubject `json:"subject,omitempty"`
+
+	// Reason identifies the event that triggered the notification.
+	//
+	// GitHub API docs: https://docs.github.com/rest/activity#notification-reasons
+	Reason *string `json:"reason,omitempty"`
+
+	Unread     *bool      `json:"unread,omitempty"`
+	UpdatedAt  *Timestamp `json:"updated_at,omitempty"`
+	LastReadAt *Timestamp `json:"last_read_at,omitempty"`
+	URL        *string    `json:"url,omitempty"`
+}
+
+// NotificationSubject identifies the subject of a notification.
+type NotificationSubject struct {
+	Title            *string `json:"title,omitempty"`
+	URL              *string `json:"url,omitempty"`
+	LatestCommentURL *string `json:"latest_comment_url,omitempty"`
+	Type             *string `json:"type,omitempty"`
+}
+
+// NotificationListOptions specifies the optional parameters to the
+// ActivityService.ListNotifications method.
+type NotificationListOptions struct {
+	All           bool      `url:"all,omitempty"`
+	Participating bool      `url:"participating,omitempty"`
+	Since         time.Time `url:"since,omitempty"`
+	Before        time.Time `url:"before,omitempty"`
+
+	ListOptions
+}
+
+// ListNotifications lists all notifications for the authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/notifications#list-notifications-for-the-authenticated-user
+//
+//meta:operation GET /notifications
+func (s *ActivityService) ListNotifications(ctx context.Context, opts *NotificationListOptions) ([]*Notification, *Response, error) {
+	u := "notifications"
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var notifications []*Notification
+	resp, err := s.client.Do(ctx, req, &notifications)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return notifications, resp, nil
+}
+
+// ListRepositoryNotifications lists all notifications in a given repository
+// for the authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/notifications#list-repository-notifications-for-the-authenticated-user
+//
+//meta:operation GET /repos/{owner}/{repo}/notifications
+func (s *ActivityService) ListRepositoryNotifications(ctx context.Context, owner, repo string, opts *NotificationListOptions) ([]*Notification, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/notifications", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var notifications []*Notification
+	resp, err := s.client.Do(ctx, req, &notifications)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return notifications, resp, nil
+}
+
+type markReadOptions struct {
+	LastReadAt Timestamp `json:"last_read_at,omitempty"`
+}
+
+// MarkNotificationsRead marks all notifications up to lastRead as read.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/notifications#mark-notifications-as-read
+//
+//meta:operation PUT /notifications
+func (s *ActivityService) MarkNotificationsRead(ctx context.Context, lastRead Timestamp) (*Response, error) {
+	opts := &markReadOptions{
+		LastReadAt: lastRead,
+	}
+	req, err := s.client.NewRequest("PUT", "notifications", opts)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// MarkRepositoryNotificationsRead marks all notifications up to lastRead in
+// the specified repository as read.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/notifications#mark-repository-notifications-as-read
+//
+//meta:operation PUT /repos/{owner}/{repo}/notifications
+func (s *ActivityService) MarkRepositoryNotificationsRead(ctx context.Context, owner, repo string, lastRead Timestamp) (*Response, error) {
+	opts := &markReadOptions{
+		LastReadAt: lastRead,
+	}
+	u := fmt.Sprintf("repos/%v/%v/notifications", owner, repo)
+	req, err := s.client.NewRequest("PUT", u, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// GetThread gets the specified notification thread.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/notifications#get-a-thread
+//
+//meta:operation GET /notifications/threads/{thread_id}
+func (s *ActivityService) GetThread(ctx context.Context, id string) (*Notification, *Response, error) {
+	u := fmt.Sprintf("notifications/threads/%v", id)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	notification := new(Notification)
+	resp, err := s.client.Do(ctx, req, notification)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return notification, resp, nil
+}
+
+// MarkThreadRead marks the specified thread as read.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/notifications#mark-a-thread-as-read
+//
+//meta:operation PATCH /notifications/threads/{thread_id}
+func (s *ActivityService) MarkThreadRead(ctx context.Context, id string) (*Response, error) {
+	u := fmt.Sprintf("notifications/threads/%v", id)
+
+	req, err := s.client.NewRequest("PATCH", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// MarkThreadDone marks the specified thread as done.
+// Marking a thread as "done" is equivalent to marking a notification in your notification inbox on GitHub as done.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/notifications#mark-a-thread-as-done
+//
+//meta:operation DELETE /notifications/threads/{thread_id}
+func (s *ActivityService) MarkThreadDone(ctx context.Context, id int64) (*Response, error) {
+	u := fmt.Sprintf("notifications/threads/%v", id)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// GetThreadSubscription checks to see if the authenticated user is subscribed
+// to a thread.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/notifications#get-a-thread-subscription-for-the-authenticated-user
+//
+//meta:operation GET /notifications/threads/{thread_id}/subscription
+func (s *ActivityService) GetThreadSubscription(ctx context.Context, id string) (*Subscription, *Response, error) {
+	u := fmt.Sprintf("notifications/threads/%v/subscription", id)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	sub := new(Subscription)
+	resp, err := s.client.Do(ctx, req, sub)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return sub, resp, nil
+}
+
+// SetThreadSubscription sets the subscription for the specified thread for the
+// authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/notifications#set-a-thread-subscription
+//
+//meta:operation PUT /notifications/threads/{thread_id}/subscription
+func (s *ActivityService) SetThreadSubscription(ctx context.Context, id string, subscription *Subscription) (*Subscription, *Response, error) {
+	u := fmt.Sprintf("notifications/threads/%v/subscription", id)
+
+	req, err := s.client.NewRequest("PUT", u, subscription)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	sub := new(Subscription)
+	resp, err := s.client.Do(ctx, req, sub)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return sub, resp, nil
+}
+
+// DeleteThreadSubscription deletes the subscription for the specified thread
+// for the authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/notifications#delete-a-thread-subscription
+//
+//meta:operation DELETE /notifications/threads/{thread_id}/subscription
+func (s *ActivityService) DeleteThreadSubscription(ctx context.Context, id string) (*Response, error) {
+	u := fmt.Sprintf("notifications/threads/%v/subscription", id)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/activity_star.go

@@ -0,0 +1,152 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+	"strings"
+)
+
+// StarredRepository is returned by ListStarred.
+type StarredRepository struct {
+	StarredAt  *Timestamp  `json:"starred_at,omitempty"`
+	Repository *Repository `json:"repo,omitempty"`
+}
+
+// Stargazer represents a user that has starred a repository.
+type Stargazer struct {
+	StarredAt *Timestamp `json:"starred_at,omitempty"`
+	User      *User      `json:"user,omitempty"`
+}
+
+// ListStargazers lists people who have starred the specified repo.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/starring#list-stargazers
+//
+//meta:operation GET /repos/{owner}/{repo}/stargazers
+func (s *ActivityService) ListStargazers(ctx context.Context, owner, repo string, opts *ListOptions) ([]*Stargazer, *Response, error) {
+	u := fmt.Sprintf("repos/%s/%s/stargazers", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches
+	req.Header.Set("Accept", mediaTypeStarringPreview)
+
+	var stargazers []*Stargazer
+	resp, err := s.client.Do(ctx, req, &stargazers)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return stargazers, resp, nil
+}
+
+// ActivityListStarredOptions specifies the optional parameters to the
+// ActivityService.ListStarred method.
+type ActivityListStarredOptions struct {
+	// How to sort the repository list. Possible values are: created, updated,
+	// pushed, full_name. Default is "full_name".
+	Sort string `url:"sort,omitempty"`
+
+	// Direction in which to sort repositories. Possible values are: asc, desc.
+	// Default is "asc" when sort is "full_name", otherwise default is "desc".
+	Direction string `url:"direction,omitempty"`
+
+	ListOptions
+}
+
+// ListStarred lists all the repos starred by a user. Passing the empty string
+// will list the starred repositories for the authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/starring#list-repositories-starred-by-a-user
+// GitHub API docs: https://docs.github.com/rest/activity/starring#list-repositories-starred-by-the-authenticated-user
+//
+//meta:operation GET /user/starred
+//meta:operation GET /users/{username}/starred
+func (s *ActivityService) ListStarred(ctx context.Context, user string, opts *ActivityListStarredOptions) ([]*StarredRepository, *Response, error) {
+	var u string
+	if user != "" {
+		u = fmt.Sprintf("users/%v/starred", user)
+	} else {
+		u = "user/starred"
+	}
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when APIs fully launch
+	acceptHeaders := []string{mediaTypeStarringPreview, mediaTypeTopicsPreview}
+	req.Header.Set("Accept", strings.Join(acceptHeaders, ", "))
+
+	var repos []*StarredRepository
+	resp, err := s.client.Do(ctx, req, &repos)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return repos, resp, nil
+}
+
+// IsStarred checks if a repository is starred by authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/starring#check-if-a-repository-is-starred-by-the-authenticated-user
+//
+//meta:operation GET /user/starred/{owner}/{repo}
+func (s *ActivityService) IsStarred(ctx context.Context, owner, repo string) (bool, *Response, error) {
+	u := fmt.Sprintf("user/starred/%v/%v", owner, repo)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return false, nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	starred, err := parseBoolResponse(err)
+	return starred, resp, err
+}
+
+// Star a repository as the authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/starring#star-a-repository-for-the-authenticated-user
+//
+//meta:operation PUT /user/starred/{owner}/{repo}
+func (s *ActivityService) Star(ctx context.Context, owner, repo string) (*Response, error) {
+	u := fmt.Sprintf("user/starred/%v/%v", owner, repo)
+	req, err := s.client.NewRequest("PUT", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// Unstar a repository as the authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/starring#unstar-a-repository-for-the-authenticated-user
+//
+//meta:operation DELETE /user/starred/{owner}/{repo}
+func (s *ActivityService) Unstar(ctx context.Context, owner, repo string) (*Response, error) {
+	u := fmt.Sprintf("user/starred/%v/%v", owner, repo)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/activity_watching.go

@@ -0,0 +1,158 @@
+// Copyright 2014 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// Subscription identifies a repository or thread subscription.
+type Subscription struct {
+	Subscribed *bool      `json:"subscribed,omitempty"`
+	Ignored    *bool      `json:"ignored,omitempty"`
+	Reason     *string    `json:"reason,omitempty"`
+	CreatedAt  *Timestamp `json:"created_at,omitempty"`
+	URL        *string    `json:"url,omitempty"`
+
+	// only populated for repository subscriptions
+	RepositoryURL *string `json:"repository_url,omitempty"`
+
+	// only populated for thread subscriptions
+	ThreadURL *string `json:"thread_url,omitempty"`
+}
+
+// ListWatchers lists watchers of a particular repo.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/watching#list-watchers
+//
+//meta:operation GET /repos/{owner}/{repo}/subscribers
+func (s *ActivityService) ListWatchers(ctx context.Context, owner, repo string, opts *ListOptions) ([]*User, *Response, error) {
+	u := fmt.Sprintf("repos/%s/%s/subscribers", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var watchers []*User
+	resp, err := s.client.Do(ctx, req, &watchers)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return watchers, resp, nil
+}
+
+// ListWatched lists the repositories the specified user is watching. Passing
+// the empty string will fetch watched repos for the authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/watching#list-repositories-watched-by-a-user
+// GitHub API docs: https://docs.github.com/rest/activity/watching#list-repositories-watched-by-the-authenticated-user
+//
+//meta:operation GET /user/subscriptions
+//meta:operation GET /users/{username}/subscriptions
+func (s *ActivityService) ListWatched(ctx context.Context, user string, opts *ListOptions) ([]*Repository, *Response, error) {
+	var u string
+	if user != "" {
+		u = fmt.Sprintf("users/%v/subscriptions", user)
+	} else {
+		u = "user/subscriptions"
+	}
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var watched []*Repository
+	resp, err := s.client.Do(ctx, req, &watched)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return watched, resp, nil
+}
+
+// GetRepositorySubscription returns the subscription for the specified
+// repository for the authenticated user. If the authenticated user is not
+// watching the repository, a nil Subscription is returned.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/watching#get-a-repository-subscription
+//
+//meta:operation GET /repos/{owner}/{repo}/subscription
+func (s *ActivityService) GetRepositorySubscription(ctx context.Context, owner, repo string) (*Subscription, *Response, error) {
+	u := fmt.Sprintf("repos/%s/%s/subscription", owner, repo)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	sub := new(Subscription)
+	resp, err := s.client.Do(ctx, req, sub)
+	if err != nil {
+		// if it's just a 404, don't return that as an error
+		_, err = parseBoolResponse(err)
+		return nil, resp, err
+	}
+
+	return sub, resp, nil
+}
+
+// SetRepositorySubscription sets the subscription for the specified repository
+// for the authenticated user.
+//
+// To watch a repository, set subscription.Subscribed to true.
+// To ignore notifications made within a repository, set subscription.Ignored to true.
+// To stop watching a repository, use DeleteRepositorySubscription.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/watching#set-a-repository-subscription
+//
+//meta:operation PUT /repos/{owner}/{repo}/subscription
+func (s *ActivityService) SetRepositorySubscription(ctx context.Context, owner, repo string, subscription *Subscription) (*Subscription, *Response, error) {
+	u := fmt.Sprintf("repos/%s/%s/subscription", owner, repo)
+
+	req, err := s.client.NewRequest("PUT", u, subscription)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	sub := new(Subscription)
+	resp, err := s.client.Do(ctx, req, sub)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return sub, resp, nil
+}
+
+// DeleteRepositorySubscription deletes the subscription for the specified
+// repository for the authenticated user.
+//
+// This is used to stop watching a repository. To control whether or not to
+// receive notifications from a repository, use SetRepositorySubscription.
+//
+// GitHub API docs: https://docs.github.com/rest/activity/watching#delete-a-repository-subscription
+//
+//meta:operation DELETE /repos/{owner}/{repo}/subscription
+func (s *ActivityService) DeleteRepositorySubscription(ctx context.Context, owner, repo string) (*Response, error) {
+	u := fmt.Sprintf("repos/%s/%s/subscription", owner, repo)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/admin.go

@@ -0,0 +1,123 @@
+// Copyright 2016 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// AdminService handles communication with the admin related methods of the
+// GitHub API. These API routes are normally only accessible for GitHub
+// Enterprise installations.
+//
+// GitHub API docs: https://docs.github.com/rest/enterprise-admin
+type AdminService service
+
+// TeamLDAPMapping represents the mapping between a GitHub team and an LDAP group.
+type TeamLDAPMapping struct {
+	ID          *int64  `json:"id,omitempty"`
+	LDAPDN      *string `json:"ldap_dn,omitempty"`
+	URL         *string `json:"url,omitempty"`
+	Name        *string `json:"name,omitempty"`
+	Slug        *string `json:"slug,omitempty"`
+	Description *string `json:"description,omitempty"`
+	Privacy     *string `json:"privacy,omitempty"`
+	Permission  *string `json:"permission,omitempty"`
+
+	MembersURL      *string `json:"members_url,omitempty"`
+	RepositoriesURL *string `json:"repositories_url,omitempty"`
+}
+
+func (m TeamLDAPMapping) String() string {
+	return Stringify(m)
+}
+
+// UserLDAPMapping represents the mapping between a GitHub user and an LDAP user.
+type UserLDAPMapping struct {
+	ID         *int64  `json:"id,omitempty"`
+	LDAPDN     *string `json:"ldap_dn,omitempty"`
+	Login      *string `json:"login,omitempty"`
+	AvatarURL  *string `json:"avatar_url,omitempty"`
+	GravatarID *string `json:"gravatar_id,omitempty"`
+	Type       *string `json:"type,omitempty"`
+	SiteAdmin  *bool   `json:"site_admin,omitempty"`
+
+	URL               *string `json:"url,omitempty"`
+	EventsURL         *string `json:"events_url,omitempty"`
+	FollowingURL      *string `json:"following_url,omitempty"`
+	FollowersURL      *string `json:"followers_url,omitempty"`
+	GistsURL          *string `json:"gists_url,omitempty"`
+	OrganizationsURL  *string `json:"organizations_url,omitempty"`
+	ReceivedEventsURL *string `json:"received_events_url,omitempty"`
+	ReposURL          *string `json:"repos_url,omitempty"`
+	StarredURL        *string `json:"starred_url,omitempty"`
+	SubscriptionsURL  *string `json:"subscriptions_url,omitempty"`
+}
+
+func (m UserLDAPMapping) String() string {
+	return Stringify(m)
+}
+
+// Enterprise represents the GitHub enterprise profile.
+type Enterprise struct {
+	ID          *int       `json:"id,omitempty"`
+	Slug        *string    `json:"slug,omitempty"`
+	Name        *string    `json:"name,omitempty"`
+	NodeID      *string    `json:"node_id,omitempty"`
+	AvatarURL   *string    `json:"avatar_url,omitempty"`
+	Description *string    `json:"description,omitempty"`
+	WebsiteURL  *string    `json:"website_url,omitempty"`
+	HTMLURL     *string    `json:"html_url,omitempty"`
+	CreatedAt   *Timestamp `json:"created_at,omitempty"`
+	UpdatedAt   *Timestamp `json:"updated_at,omitempty"`
+}
+
+func (m Enterprise) String() string {
+	return Stringify(m)
+}
+
+// UpdateUserLDAPMapping updates the mapping between a GitHub user and an LDAP user.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/ldap#update-ldap-mapping-for-a-user
+//
+//meta:operation PATCH /admin/ldap/users/{username}/mapping
+func (s *AdminService) UpdateUserLDAPMapping(ctx context.Context, user string, mapping *UserLDAPMapping) (*UserLDAPMapping, *Response, error) {
+	u := fmt.Sprintf("admin/ldap/users/%v/mapping", user)
+	req, err := s.client.NewRequest("PATCH", u, mapping)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	m := new(UserLDAPMapping)
+	resp, err := s.client.Do(ctx, req, m)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return m, resp, nil
+}
+
+// UpdateTeamLDAPMapping updates the mapping between a GitHub team and an LDAP group.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/ldap#update-ldap-mapping-for-a-team
+//
+//meta:operation PATCH /admin/ldap/teams/{team_id}/mapping
+func (s *AdminService) UpdateTeamLDAPMapping(ctx context.Context, team int64, mapping *TeamLDAPMapping) (*TeamLDAPMapping, *Response, error) {
+	u := fmt.Sprintf("admin/ldap/teams/%v/mapping", team)
+	req, err := s.client.NewRequest("PATCH", u, mapping)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	m := new(TeamLDAPMapping)
+	resp, err := s.client.Do(ctx, req, m)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return m, resp, nil
+}

vendor/github.com/google/go-github/v69/github/admin_orgs.go

@@ -0,0 +1,95 @@
+// Copyright 2019 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// createOrgRequest is a subset of Organization and is used internally
+// by CreateOrg to pass only the known fields for the endpoint.
+type createOrgRequest struct {
+	Login *string `json:"login,omitempty"`
+	Admin *string `json:"admin,omitempty"`
+}
+
+// CreateOrg creates a new organization in GitHub Enterprise.
+//
+// Note that only a subset of the org fields are used and org must
+// not be nil.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/orgs#create-an-organization
+//
+//meta:operation POST /admin/organizations
+func (s *AdminService) CreateOrg(ctx context.Context, org *Organization, admin string) (*Organization, *Response, error) {
+	u := "admin/organizations"
+
+	orgReq := &createOrgRequest{
+		Login: org.Login,
+		Admin: &admin,
+	}
+
+	req, err := s.client.NewRequest("POST", u, orgReq)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	o := new(Organization)
+	resp, err := s.client.Do(ctx, req, o)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return o, resp, nil
+}
+
+// renameOrgRequest is a subset of Organization and is used internally
+// by RenameOrg and RenameOrgByName to pass only the known fields for the endpoint.
+type renameOrgRequest struct {
+	Login *string `json:"login,omitempty"`
+}
+
+// RenameOrgResponse is the response given when renaming an Organization.
+type RenameOrgResponse struct {
+	Message *string `json:"message,omitempty"`
+	URL     *string `json:"url,omitempty"`
+}
+
+// RenameOrg renames an organization in GitHub Enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/orgs#update-an-organization-name
+//
+//meta:operation PATCH /admin/organizations/{org}
+func (s *AdminService) RenameOrg(ctx context.Context, org *Organization, newName string) (*RenameOrgResponse, *Response, error) {
+	return s.RenameOrgByName(ctx, *org.Login, newName)
+}
+
+// RenameOrgByName renames an organization in GitHub Enterprise using its current name.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/orgs#update-an-organization-name
+//
+//meta:operation PATCH /admin/organizations/{org}
+func (s *AdminService) RenameOrgByName(ctx context.Context, org, newName string) (*RenameOrgResponse, *Response, error) {
+	u := fmt.Sprintf("admin/organizations/%v", org)
+
+	orgReq := &renameOrgRequest{
+		Login: &newName,
+	}
+
+	req, err := s.client.NewRequest("PATCH", u, orgReq)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	o := new(RenameOrgResponse)
+	resp, err := s.client.Do(ctx, req, o)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return o, resp, nil
+}

vendor/github.com/google/go-github/v69/github/admin_stats.go

@@ -0,0 +1,172 @@
+// Copyright 2017 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+)
+
+// AdminStats represents a variety of stats of a GitHub Enterprise
+// installation.
+type AdminStats struct {
+	Issues     *IssueStats     `json:"issues,omitempty"`
+	Hooks      *HookStats      `json:"hooks,omitempty"`
+	Milestones *MilestoneStats `json:"milestones,omitempty"`
+	Orgs       *OrgStats       `json:"orgs,omitempty"`
+	Comments   *CommentStats   `json:"comments,omitempty"`
+	Pages      *PageStats      `json:"pages,omitempty"`
+	Users      *UserStats      `json:"users,omitempty"`
+	Gists      *GistStats      `json:"gists,omitempty"`
+	Pulls      *PullStats      `json:"pulls,omitempty"`
+	Repos      *RepoStats      `json:"repos,omitempty"`
+}
+
+func (s AdminStats) String() string {
+	return Stringify(s)
+}
+
+// IssueStats represents the number of total, open and closed issues.
+type IssueStats struct {
+	TotalIssues  *int `json:"total_issues,omitempty"`
+	OpenIssues   *int `json:"open_issues,omitempty"`
+	ClosedIssues *int `json:"closed_issues,omitempty"`
+}
+
+func (s IssueStats) String() string {
+	return Stringify(s)
+}
+
+// HookStats represents the number of total, active and inactive hooks.
+type HookStats struct {
+	TotalHooks    *int `json:"total_hooks,omitempty"`
+	ActiveHooks   *int `json:"active_hooks,omitempty"`
+	InactiveHooks *int `json:"inactive_hooks,omitempty"`
+}
+
+func (s HookStats) String() string {
+	return Stringify(s)
+}
+
+// MilestoneStats represents the number of total, open and close milestones.
+type MilestoneStats struct {
+	TotalMilestones  *int `json:"total_milestones,omitempty"`
+	OpenMilestones   *int `json:"open_milestones,omitempty"`
+	ClosedMilestones *int `json:"closed_milestones,omitempty"`
+}
+
+func (s MilestoneStats) String() string {
+	return Stringify(s)
+}
+
+// OrgStats represents the number of total, disabled organizations and the team
+// and team member count.
+type OrgStats struct {
+	TotalOrgs        *int `json:"total_orgs,omitempty"`
+	DisabledOrgs     *int `json:"disabled_orgs,omitempty"`
+	TotalTeams       *int `json:"total_teams,omitempty"`
+	TotalTeamMembers *int `json:"total_team_members,omitempty"`
+}
+
+func (s OrgStats) String() string {
+	return Stringify(s)
+}
+
+// CommentStats represents the number of total comments on commits, gists, issues
+// and pull requests.
+type CommentStats struct {
+	TotalCommitComments      *int `json:"total_commit_comments,omitempty"`
+	TotalGistComments        *int `json:"total_gist_comments,omitempty"`
+	TotalIssueComments       *int `json:"total_issue_comments,omitempty"`
+	TotalPullRequestComments *int `json:"total_pull_request_comments,omitempty"`
+}
+
+func (s CommentStats) String() string {
+	return Stringify(s)
+}
+
+// PageStats represents the total number of github pages.
+type PageStats struct {
+	TotalPages *int `json:"total_pages,omitempty"`
+}
+
+func (s PageStats) String() string {
+	return Stringify(s)
+}
+
+// UserStats represents the number of total, admin and suspended users.
+type UserStats struct {
+	TotalUsers     *int `json:"total_users,omitempty"`
+	AdminUsers     *int `json:"admin_users,omitempty"`
+	SuspendedUsers *int `json:"suspended_users,omitempty"`
+}
+
+func (s UserStats) String() string {
+	return Stringify(s)
+}
+
+// GistStats represents the number of total, private and public gists.
+type GistStats struct {
+	TotalGists   *int `json:"total_gists,omitempty"`
+	PrivateGists *int `json:"private_gists,omitempty"`
+	PublicGists  *int `json:"public_gists,omitempty"`
+}
+
+func (s GistStats) String() string {
+	return Stringify(s)
+}
+
+// PullStats represents the number of total, merged, mergeable and unmergeable
+// pull-requests.
+type PullStats struct {
+	TotalPulls       *int `json:"total_pulls,omitempty"`
+	MergedPulls      *int `json:"merged_pulls,omitempty"`
+	MergeablePulls   *int `json:"mergeable_pulls,omitempty"`
+	UnmergeablePulls *int `json:"unmergeable_pulls,omitempty"`
+}
+
+func (s PullStats) String() string {
+	return Stringify(s)
+}
+
+// RepoStats represents the number of total, root, fork, organization repositories
+// together with the total number of pushes and wikis.
+type RepoStats struct {
+	TotalRepos  *int `json:"total_repos,omitempty"`
+	RootRepos   *int `json:"root_repos,omitempty"`
+	ForkRepos   *int `json:"fork_repos,omitempty"`
+	OrgRepos    *int `json:"org_repos,omitempty"`
+	TotalPushes *int `json:"total_pushes,omitempty"`
+	TotalWikis  *int `json:"total_wikis,omitempty"`
+}
+
+func (s RepoStats) String() string {
+	return Stringify(s)
+}
+
+// GetAdminStats returns a variety of metrics about a GitHub Enterprise
+// installation.
+//
+// Please note that this is only available to site administrators,
+// otherwise it will error with a 404 not found (instead of 401 or 403).
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/admin-stats#get-all-statistics
+//
+//meta:operation GET /enterprise/stats/all
+func (s *AdminService) GetAdminStats(ctx context.Context) (*AdminStats, *Response, error) {
+	u := "enterprise/stats/all"
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	m := new(AdminStats)
+	resp, err := s.client.Do(ctx, req, m)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return m, resp, nil
+}

vendor/github.com/google/go-github/v69/github/admin_users.go

@@ -0,0 +1,137 @@
+// Copyright 2019 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// CreateUserRequest represents the fields sent to the `CreateUser` endpoint.
+// Note that `Login` is a required field.
+type CreateUserRequest struct {
+	Login     string  `json:"login"`
+	Email     *string `json:"email,omitempty"`
+	Suspended *bool   `json:"suspended,omitempty"`
+}
+
+// CreateUser creates a new user in GitHub Enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/users#create-a-user
+//
+//meta:operation POST /admin/users
+func (s *AdminService) CreateUser(ctx context.Context, userReq CreateUserRequest) (*User, *Response, error) {
+	u := "admin/users"
+
+	req, err := s.client.NewRequest("POST", u, userReq)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var user User
+	resp, err := s.client.Do(ctx, req, &user)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return &user, resp, nil
+}
+
+// DeleteUser deletes a user in GitHub Enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/users#delete-a-user
+//
+//meta:operation DELETE /admin/users/{username}
+func (s *AdminService) DeleteUser(ctx context.Context, username string) (*Response, error) {
+	u := "admin/users/" + username
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// ImpersonateUserOptions represents the scoping for the OAuth token.
+type ImpersonateUserOptions struct {
+	Scopes []string `json:"scopes,omitempty"`
+}
+
+// OAuthAPP represents the GitHub Site Administrator OAuth app.
+type OAuthAPP struct {
+	URL      *string `json:"url,omitempty"`
+	Name     *string `json:"name,omitempty"`
+	ClientID *string `json:"client_id,omitempty"`
+}
+
+func (s OAuthAPP) String() string {
+	return Stringify(s)
+}
+
+// UserAuthorization represents the impersonation response.
+type UserAuthorization struct {
+	ID             *int64     `json:"id,omitempty"`
+	URL            *string    `json:"url,omitempty"`
+	Scopes         []string   `json:"scopes,omitempty"`
+	Token          *string    `json:"token,omitempty"`
+	TokenLastEight *string    `json:"token_last_eight,omitempty"`
+	HashedToken    *string    `json:"hashed_token,omitempty"`
+	App            *OAuthAPP  `json:"app,omitempty"`
+	Note           *string    `json:"note,omitempty"`
+	NoteURL        *string    `json:"note_url,omitempty"`
+	UpdatedAt      *Timestamp `json:"updated_at,omitempty"`
+	CreatedAt      *Timestamp `json:"created_at,omitempty"`
+	Fingerprint    *string    `json:"fingerprint,omitempty"`
+}
+
+// CreateUserImpersonation creates an impersonation OAuth token.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/users#create-an-impersonation-oauth-token
+//
+//meta:operation POST /admin/users/{username}/authorizations
+func (s *AdminService) CreateUserImpersonation(ctx context.Context, username string, opts *ImpersonateUserOptions) (*UserAuthorization, *Response, error) {
+	u := fmt.Sprintf("admin/users/%s/authorizations", username)
+
+	req, err := s.client.NewRequest("POST", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	a := new(UserAuthorization)
+	resp, err := s.client.Do(ctx, req, a)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return a, resp, nil
+}
+
+// DeleteUserImpersonation deletes an impersonation OAuth token.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/users#delete-an-impersonation-oauth-token
+//
+//meta:operation DELETE /admin/users/{username}/authorizations
+func (s *AdminService) DeleteUserImpersonation(ctx context.Context, username string) (*Response, error) {
+	u := fmt.Sprintf("admin/users/%s/authorizations", username)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}

vendor/github.com/google/go-github/v69/github/apps.go

@@ -0,0 +1,495 @@
+// Copyright 2016 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// AppsService provides access to the installation related functions
+// in the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/
+type AppsService service
+
+// App represents a GitHub App.
+type App struct {
+	ID                 *int64                   `json:"id,omitempty"`
+	Slug               *string                  `json:"slug,omitempty"`
+	NodeID             *string                  `json:"node_id,omitempty"`
+	Owner              *User                    `json:"owner,omitempty"`
+	Name               *string                  `json:"name,omitempty"`
+	Description        *string                  `json:"description,omitempty"`
+	ExternalURL        *string                  `json:"external_url,omitempty"`
+	HTMLURL            *string                  `json:"html_url,omitempty"`
+	CreatedAt          *Timestamp               `json:"created_at,omitempty"`
+	UpdatedAt          *Timestamp               `json:"updated_at,omitempty"`
+	Permissions        *InstallationPermissions `json:"permissions,omitempty"`
+	Events             []string                 `json:"events,omitempty"`
+	InstallationsCount *int                     `json:"installations_count,omitempty"`
+}
+
+// InstallationToken represents an installation token.
+type InstallationToken struct {
+	Token        *string                  `json:"token,omitempty"`
+	ExpiresAt    *Timestamp               `json:"expires_at,omitempty"`
+	Permissions  *InstallationPermissions `json:"permissions,omitempty"`
+	Repositories []*Repository            `json:"repositories,omitempty"`
+}
+
+// InstallationTokenOptions allow restricting a token's access to specific repositories.
+type InstallationTokenOptions struct {
+	// The IDs of the repositories that the installation token can access.
+	// Providing repository IDs restricts the access of an installation token to specific repositories.
+	RepositoryIDs []int64 `json:"repository_ids,omitempty"`
+
+	// The names of the repositories that the installation token can access.
+	// Providing repository names restricts the access of an installation token to specific repositories.
+	Repositories []string `json:"repositories,omitempty"`
+
+	// The permissions granted to the access token.
+	// The permissions object includes the permission names and their access type.
+	Permissions *InstallationPermissions `json:"permissions,omitempty"`
+}
+
+type InstallationTokenListRepoOptions struct {
+	// The IDs of the repositories that the installation token can access.
+	// Providing repository IDs restricts the access of an installation token to specific repositories.
+	RepositoryIDs []int64 `json:"repository_ids"`
+
+	// The names of the repositories that the installation token can access.
+	// Providing repository names restricts the access of an installation token to specific repositories.
+	Repositories []string `json:"repositories,omitempty"`
+
+	// The permissions granted to the access token.
+	// The permissions object includes the permission names and their access type.
+	Permissions *InstallationPermissions `json:"permissions,omitempty"`
+}
+
+// InstallationPermissions lists the repository and organization permissions for an installation.
+//
+// Permission names taken from:
+//
+//	https://docs.github.com/enterprise-server@3.0/rest/apps#create-an-installation-access-token-for-an-app
+//	https://docs.github.com/rest/apps#create-an-installation-access-token-for-an-app
+type InstallationPermissions struct {
+	Actions                                 *string `json:"actions,omitempty"`
+	ActionsVariables                        *string `json:"actions_variables,omitempty"`
+	Administration                          *string `json:"administration,omitempty"`
+	Attestations                            *string `json:"attestations,omitempty"`
+	Blocking                                *string `json:"blocking,omitempty"`
+	Checks                                  *string `json:"checks,omitempty"`
+	Codespaces                              *string `json:"codespaces,omitempty"`
+	CodespacesLifecycleAdmin                *string `json:"codespaces_lifecycle_admin,omitempty"`
+	CodespacesMetadata                      *string `json:"codespaces_metadata,omitempty"`
+	CodespacesSecrets                       *string `json:"codespaces_secrets,omitempty"`
+	CodespacesUserSecrets                   *string `json:"codespaces_user_secrets,omitempty"`
+	Contents                                *string `json:"contents,omitempty"`
+	ContentReferences                       *string `json:"content_references,omitempty"`
+	CopilotMessages                         *string `json:"copilot_messages,omitempty"`
+	DependabotSecrets                       *string `json:"dependabot_secrets,omitempty"`
+	Deployments                             *string `json:"deployments,omitempty"`
+	Discussions                             *string `json:"discussions,omitempty"`
+	Emails                                  *string `json:"emails,omitempty"`
+	Environments                            *string `json:"environments,omitempty"`
+	Followers                               *string `json:"followers,omitempty"`
+	Gists                                   *string `json:"gists,omitempty"`
+	GitSigningSSHPublicKeys                 *string `json:"git_signing_ssh_public_keys,omitempty"`
+	GPGKeys                                 *string `json:"gpg_keys,omitempty"`
+	InteractionLimits                       *string `json:"interaction_limits,omitempty"`
+	Issues                                  *string `json:"issues,omitempty"`
+	Keys                                    *string `json:"keys,omitempty"`
+	Metadata                                *string `json:"metadata,omitempty"`
+	Members                                 *string `json:"members,omitempty"`
+	MergeQueues                             *string `json:"merge_queues,omitempty"`
+	OrganizationActionsVariables            *string `json:"organization_actions_variables,omitempty"`
+	OrganizationAdministration              *string `json:"organization_administration,omitempty"`
+	OrganizationAnnouncementBanners         *string `json:"organization_announcement_banners,omitempty"`
+	OrganizationAPIInsights                 *string `json:"organization_api_insights,omitempty"`
+	OrganizationCodespaces                  *string `json:"organization_codespaces,omitempty"`
+	OrganizationCodespacesSecrets           *string `json:"organization_codespaces_secrets,omitempty"`
+	OrganizationCodespacesSettings          *string `json:"organization_codespaces_settings,omitempty"`
+	OrganizationCopilotSeatManagement       *string `json:"organization_copilot_seat_management,omitempty"`
+	OrganizationCustomProperties            *string `json:"organization_custom_properties,omitempty"`
+	OrganizationCustomRoles                 *string `json:"organization_custom_roles,omitempty"`
+	OrganizationCustomOrgRoles              *string `json:"organization_custom_org_roles,omitempty"`
+	OrganizationDependabotSecrets           *string `json:"organization_dependabot_secrets,omitempty"`
+	OrganizationEvents                      *string `json:"organization_events,omitempty"`
+	OrganizationHooks                       *string `json:"organization_hooks,omitempty"`
+	OrganizationKnowledgeBases              *string `json:"organization_knowledge_bases,omitempty"`
+	OrganizationPackages                    *string `json:"organization_packages,omitempty"`
+	OrganizationPersonalAccessTokens        *string `json:"organization_personal_access_tokens,omitempty"`
+	OrganizationPersonalAccessTokenRequests *string `json:"organization_personal_access_token_requests,omitempty"`
+	OrganizationPlan                        *string `json:"organization_plan,omitempty"`
+	OrganizationPreReceiveHooks             *string `json:"organization_pre_receive_hooks,omitempty"`
+	OrganizationProjects                    *string `json:"organization_projects,omitempty"`
+	OrganizationSecrets                     *string `json:"organization_secrets,omitempty"`
+	OrganizationSelfHostedRunners           *string `json:"organization_self_hosted_runners,omitempty"`
+	OrganizationUserBlocking                *string `json:"organization_user_blocking,omitempty"`
+	Packages                                *string `json:"packages,omitempty"`
+	Pages                                   *string `json:"pages,omitempty"`
+	Plan                                    *string `json:"plan,omitempty"`
+	Profile                                 *string `json:"profile,omitempty"`
+	PullRequests                            *string `json:"pull_requests,omitempty"`
+	RepositoryAdvisories                    *string `json:"repository_advisories,omitempty"`
+	RepositoryCustomProperties              *string `json:"repository_custom_properties,omitempty"`
+	RepositoryHooks                         *string `json:"repository_hooks,omitempty"`
+	RepositoryProjects                      *string `json:"repository_projects,omitempty"`
+	RepositoryPreReceiveHooks               *string `json:"repository_pre_receive_hooks,omitempty"`
+	Secrets                                 *string `json:"secrets,omitempty"`
+	SecretScanningAlerts                    *string `json:"secret_scanning_alerts,omitempty"`
+	SecurityEvents                          *string `json:"security_events,omitempty"`
+	SingleFile                              *string `json:"single_file,omitempty"`
+	Starring                                *string `json:"starring,omitempty"`
+	Statuses                                *string `json:"statuses,omitempty"`
+	TeamDiscussions                         *string `json:"team_discussions,omitempty"`
+	UserEvents                              *string `json:"user_events,omitempty"`
+	VulnerabilityAlerts                     *string `json:"vulnerability_alerts,omitempty"`
+	Watching                                *string `json:"watching,omitempty"`
+	Workflows                               *string `json:"workflows,omitempty"`
+}
+
+// InstallationRequest represents a pending GitHub App installation request.
+type InstallationRequest struct {
+	ID        *int64     `json:"id,omitempty"`
+	NodeID    *string    `json:"node_id,omitempty"`
+	Account   *User      `json:"account,omitempty"`
+	Requester *User      `json:"requester,omitempty"`
+	CreatedAt *Timestamp `json:"created_at,omitempty"`
+}
+
+// Installation represents a GitHub Apps installation.
+type Installation struct {
+	ID                     *int64                   `json:"id,omitempty"`
+	NodeID                 *string                  `json:"node_id,omitempty"`
+	AppID                  *int64                   `json:"app_id,omitempty"`
+	AppSlug                *string                  `json:"app_slug,omitempty"`
+	TargetID               *int64                   `json:"target_id,omitempty"`
+	Account                *User                    `json:"account,omitempty"`
+	AccessTokensURL        *string                  `json:"access_tokens_url,omitempty"`
+	RepositoriesURL        *string                  `json:"repositories_url,omitempty"`
+	HTMLURL                *string                  `json:"html_url,omitempty"`
+	TargetType             *string                  `json:"target_type,omitempty"`
+	SingleFileName         *string                  `json:"single_file_name,omitempty"`
+	RepositorySelection    *string                  `json:"repository_selection,omitempty"`
+	Events                 []string                 `json:"events,omitempty"`
+	SingleFilePaths        []string                 `json:"single_file_paths,omitempty"`
+	Permissions            *InstallationPermissions `json:"permissions,omitempty"`
+	CreatedAt              *Timestamp               `json:"created_at,omitempty"`
+	UpdatedAt              *Timestamp               `json:"updated_at,omitempty"`
+	HasMultipleSingleFiles *bool                    `json:"has_multiple_single_files,omitempty"`
+	SuspendedBy            *User                    `json:"suspended_by,omitempty"`
+	SuspendedAt            *Timestamp               `json:"suspended_at,omitempty"`
+}
+
+// Attachment represents a GitHub Apps attachment.
+type Attachment struct {
+	ID    *int64  `json:"id,omitempty"`
+	Title *string `json:"title,omitempty"`
+	Body  *string `json:"body,omitempty"`
+}
+
+// ContentReference represents a reference to a URL in an issue or pull request.
+type ContentReference struct {
+	ID        *int64  `json:"id,omitempty"`
+	NodeID    *string `json:"node_id,omitempty"`
+	Reference *string `json:"reference,omitempty"`
+}
+
+func (i Installation) String() string {
+	return Stringify(i)
+}
+
+// Get a single GitHub App. Passing the empty string will get
+// the authenticated GitHub App.
+//
+// Note: appSlug is just the URL-friendly name of your GitHub App.
+// You can find this on the settings page for your GitHub App
+// (e.g., https://github.com/settings/apps/:app_slug).
+//
+// GitHub API docs: https://docs.github.com/rest/apps/apps#get-an-app
+// GitHub API docs: https://docs.github.com/rest/apps/apps#get-the-authenticated-app
+//
+//meta:operation GET /app
+//meta:operation GET /apps/{app_slug}
+func (s *AppsService) Get(ctx context.Context, appSlug string) (*App, *Response, error) {
+	var u string
+	if appSlug != "" {
+		u = fmt.Sprintf("apps/%v", appSlug)
+	} else {
+		u = "app"
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	app := new(App)
+	resp, err := s.client.Do(ctx, req, app)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return app, resp, nil
+}
+
+// ListInstallationRequests lists the pending installation requests that the current GitHub App has.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/apps#list-installation-requests-for-the-authenticated-app
+//
+//meta:operation GET /app/installation-requests
+func (s *AppsService) ListInstallationRequests(ctx context.Context, opts *ListOptions) ([]*InstallationRequest, *Response, error) {
+	u, err := addOptions("app/installation-requests", opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var i []*InstallationRequest
+	resp, err := s.client.Do(ctx, req, &i)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return i, resp, nil
+}
+
+// ListInstallations lists the installations that the current GitHub App has.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/apps#list-installations-for-the-authenticated-app
+//
+//meta:operation GET /app/installations
+func (s *AppsService) ListInstallations(ctx context.Context, opts *ListOptions) ([]*Installation, *Response, error) {
+	u, err := addOptions("app/installations", opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var i []*Installation
+	resp, err := s.client.Do(ctx, req, &i)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return i, resp, nil
+}
+
+// GetInstallation returns the specified installation.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/apps#get-an-installation-for-the-authenticated-app
+//
+//meta:operation GET /app/installations/{installation_id}
+func (s *AppsService) GetInstallation(ctx context.Context, id int64) (*Installation, *Response, error) {
+	return s.getInstallation(ctx, fmt.Sprintf("app/installations/%v", id))
+}
+
+// ListUserInstallations lists installations that are accessible to the authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/installations#list-app-installations-accessible-to-the-user-access-token
+//
+//meta:operation GET /user/installations
+func (s *AppsService) ListUserInstallations(ctx context.Context, opts *ListOptions) ([]*Installation, *Response, error) {
+	u, err := addOptions("user/installations", opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var i struct {
+		Installations []*Installation `json:"installations"`
+	}
+	resp, err := s.client.Do(ctx, req, &i)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return i.Installations, resp, nil
+}
+
+// SuspendInstallation suspends the specified installation.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/apps#suspend-an-app-installation
+//
+//meta:operation PUT /app/installations/{installation_id}/suspended
+func (s *AppsService) SuspendInstallation(ctx context.Context, id int64) (*Response, error) {
+	u := fmt.Sprintf("app/installations/%v/suspended", id)
+
+	req, err := s.client.NewRequest("PUT", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// UnsuspendInstallation unsuspends the specified installation.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/apps#unsuspend-an-app-installation
+//
+//meta:operation DELETE /app/installations/{installation_id}/suspended
+func (s *AppsService) UnsuspendInstallation(ctx context.Context, id int64) (*Response, error) {
+	u := fmt.Sprintf("app/installations/%v/suspended", id)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// DeleteInstallation deletes the specified installation.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/apps#delete-an-installation-for-the-authenticated-app
+//
+//meta:operation DELETE /app/installations/{installation_id}
+func (s *AppsService) DeleteInstallation(ctx context.Context, id int64) (*Response, error) {
+	u := fmt.Sprintf("app/installations/%v", id)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// CreateInstallationToken creates a new installation token.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/apps#create-an-installation-access-token-for-an-app
+//
+//meta:operation POST /app/installations/{installation_id}/access_tokens
+func (s *AppsService) CreateInstallationToken(ctx context.Context, id int64, opts *InstallationTokenOptions) (*InstallationToken, *Response, error) {
+	u := fmt.Sprintf("app/installations/%v/access_tokens", id)
+
+	req, err := s.client.NewRequest("POST", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	t := new(InstallationToken)
+	resp, err := s.client.Do(ctx, req, t)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return t, resp, nil
+}
+
+// CreateInstallationTokenListRepos creates a new installation token with a list of all repositories in an installation which is not possible with CreateInstallationToken.
+//
+// It differs from CreateInstallationToken by taking InstallationTokenListRepoOptions as a parameter which does not omit RepositoryIDs if that field is nil or an empty array.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/apps#create-an-installation-access-token-for-an-app
+//
+//meta:operation POST /app/installations/{installation_id}/access_tokens
+func (s *AppsService) CreateInstallationTokenListRepos(ctx context.Context, id int64, opts *InstallationTokenListRepoOptions) (*InstallationToken, *Response, error) {
+	u := fmt.Sprintf("app/installations/%v/access_tokens", id)
+
+	req, err := s.client.NewRequest("POST", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	t := new(InstallationToken)
+	resp, err := s.client.Do(ctx, req, t)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return t, resp, nil
+}
+
+// CreateAttachment creates a new attachment on user comment containing a url.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.3/rest/reference/apps#create-a-content-attachment
+//
+//meta:operation POST /repos/{owner}/{repo}/content_references/{content_reference_id}/attachments
+func (s *AppsService) CreateAttachment(ctx context.Context, contentReferenceID int64, title, body string) (*Attachment, *Response, error) {
+	u := fmt.Sprintf("content_references/%v/attachments", contentReferenceID)
+	payload := &Attachment{Title: Ptr(title), Body: Ptr(body)}
+	req, err := s.client.NewRequest("POST", u, payload)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept headers when APIs fully launch.
+	req.Header.Set("Accept", mediaTypeContentAttachmentsPreview)
+
+	m := &Attachment{}
+	resp, err := s.client.Do(ctx, req, m)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return m, resp, nil
+}
+
+// FindOrganizationInstallation finds the organization's installation information.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/apps#get-an-organization-installation-for-the-authenticated-app
+//
+//meta:operation GET /orgs/{org}/installation
+func (s *AppsService) FindOrganizationInstallation(ctx context.Context, org string) (*Installation, *Response, error) {
+	return s.getInstallation(ctx, fmt.Sprintf("orgs/%v/installation", org))
+}
+
+// FindRepositoryInstallation finds the repository's installation information.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/apps#get-a-repository-installation-for-the-authenticated-app
+//
+//meta:operation GET /repos/{owner}/{repo}/installation
+func (s *AppsService) FindRepositoryInstallation(ctx context.Context, owner, repo string) (*Installation, *Response, error) {
+	return s.getInstallation(ctx, fmt.Sprintf("repos/%v/%v/installation", owner, repo))
+}
+
+// FindRepositoryInstallationByID finds the repository's installation information.
+//
+// Note: FindRepositoryInstallationByID uses the undocumented GitHub API endpoint "GET /repositories/{repository_id}/installation".
+//
+//meta:operation GET /repositories/{repository_id}/installation
+func (s *AppsService) FindRepositoryInstallationByID(ctx context.Context, id int64) (*Installation, *Response, error) {
+	return s.getInstallation(ctx, fmt.Sprintf("repositories/%d/installation", id))
+}
+
+// FindUserInstallation finds the user's installation information.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/apps#get-a-user-installation-for-the-authenticated-app
+//
+//meta:operation GET /users/{username}/installation
+func (s *AppsService) FindUserInstallation(ctx context.Context, user string) (*Installation, *Response, error) {
+	return s.getInstallation(ctx, fmt.Sprintf("users/%v/installation", user))
+}
+
+func (s *AppsService) getInstallation(ctx context.Context, url string) (*Installation, *Response, error) {
+	req, err := s.client.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	i := new(Installation)
+	resp, err := s.client.Do(ctx, req, i)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return i, resp, nil
+}

vendor/github.com/google/go-github/v69/github/apps_hooks.go

@@ -0,0 +1,52 @@
+// Copyright 2021 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+)
+
+// GetHookConfig returns the webhook configuration for a GitHub App.
+// The underlying transport must be authenticated as an app.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/webhooks#get-a-webhook-configuration-for-an-app
+//
+//meta:operation GET /app/hook/config
+func (s *AppsService) GetHookConfig(ctx context.Context) (*HookConfig, *Response, error) {
+	req, err := s.client.NewRequest("GET", "app/hook/config", nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	config := new(HookConfig)
+	resp, err := s.client.Do(ctx, req, &config)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return config, resp, nil
+}
+
+// UpdateHookConfig updates the webhook configuration for a GitHub App.
+// The underlying transport must be authenticated as an app.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/webhooks#update-a-webhook-configuration-for-an-app
+//
+//meta:operation PATCH /app/hook/config
+func (s *AppsService) UpdateHookConfig(ctx context.Context, config *HookConfig) (*HookConfig, *Response, error) {
+	req, err := s.client.NewRequest("PATCH", "app/hook/config", config)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	c := new(HookConfig)
+	resp, err := s.client.Do(ctx, req, c)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return c, resp, nil
+}

vendor/github.com/google/go-github/v69/github/apps_hooks_deliveries.go

@@ -0,0 +1,78 @@
+// Copyright 2021 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ListHookDeliveries lists deliveries of an App webhook.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/webhooks#list-deliveries-for-an-app-webhook
+//
+//meta:operation GET /app/hook/deliveries
+func (s *AppsService) ListHookDeliveries(ctx context.Context, opts *ListCursorOptions) ([]*HookDelivery, *Response, error) {
+	u, err := addOptions("app/hook/deliveries", opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	deliveries := []*HookDelivery{}
+	resp, err := s.client.Do(ctx, req, &deliveries)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return deliveries, resp, nil
+}
+
+// GetHookDelivery returns the App webhook delivery with the specified ID.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/webhooks#get-a-delivery-for-an-app-webhook
+//
+//meta:operation GET /app/hook/deliveries/{delivery_id}
+func (s *AppsService) GetHookDelivery(ctx context.Context, deliveryID int64) (*HookDelivery, *Response, error) {
+	u := fmt.Sprintf("app/hook/deliveries/%v", deliveryID)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	h := new(HookDelivery)
+	resp, err := s.client.Do(ctx, req, h)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return h, resp, nil
+}
+
+// RedeliverHookDelivery redelivers a delivery for an App webhook.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/webhooks#redeliver-a-delivery-for-an-app-webhook
+//
+//meta:operation POST /app/hook/deliveries/{delivery_id}/attempts
+func (s *AppsService) RedeliverHookDelivery(ctx context.Context, deliveryID int64) (*HookDelivery, *Response, error) {
+	u := fmt.Sprintf("app/hook/deliveries/%v/attempts", deliveryID)
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	h := new(HookDelivery)
+	resp, err := s.client.Do(ctx, req, h)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return h, resp, nil
+}

vendor/github.com/google/go-github/v69/github/apps_installation.go

@@ -0,0 +1,138 @@
+// Copyright 2016 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+	"strings"
+)
+
+// ListRepositories represents the response from the list repos endpoints.
+type ListRepositories struct {
+	TotalCount   *int          `json:"total_count,omitempty"`
+	Repositories []*Repository `json:"repositories"`
+}
+
+// ListRepos lists the repositories that are accessible to the authenticated installation.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/installations#list-repositories-accessible-to-the-app-installation
+//
+//meta:operation GET /installation/repositories
+func (s *AppsService) ListRepos(ctx context.Context, opts *ListOptions) (*ListRepositories, *Response, error) {
+	u, err := addOptions("installation/repositories", opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept headers when APIs fully launch.
+	acceptHeaders := []string{
+		mediaTypeTopicsPreview,
+		mediaTypeRepositoryVisibilityPreview,
+		mediaTypeRepositoryTemplatePreview,
+	}
+	req.Header.Set("Accept", strings.Join(acceptHeaders, ", "))
+
+	var r *ListRepositories
+
+	resp, err := s.client.Do(ctx, req, &r)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return r, resp, nil
+}
+
+// ListUserRepos lists repositories that are accessible
+// to the authenticated user for an installation.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/installations#list-repositories-accessible-to-the-user-access-token
+//
+//meta:operation GET /user/installations/{installation_id}/repositories
+func (s *AppsService) ListUserRepos(ctx context.Context, id int64, opts *ListOptions) (*ListRepositories, *Response, error) {
+	u := fmt.Sprintf("user/installations/%v/repositories", id)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept headers when APIs fully launch.
+	acceptHeaders := []string{
+		mediaTypeTopicsPreview,
+		mediaTypeRepositoryVisibilityPreview,
+		mediaTypeRepositoryTemplatePreview,
+	}
+	req.Header.Set("Accept", strings.Join(acceptHeaders, ", "))
+
+	var r *ListRepositories
+	resp, err := s.client.Do(ctx, req, &r)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return r, resp, nil
+}
+
+// AddRepository adds a single repository to an installation.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/installations#add-a-repository-to-an-app-installation
+//
+//meta:operation PUT /user/installations/{installation_id}/repositories/{repository_id}
+func (s *AppsService) AddRepository(ctx context.Context, instID, repoID int64) (*Repository, *Response, error) {
+	u := fmt.Sprintf("user/installations/%v/repositories/%v", instID, repoID)
+	req, err := s.client.NewRequest("PUT", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	r := new(Repository)
+	resp, err := s.client.Do(ctx, req, r)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return r, resp, nil
+}
+
+// RemoveRepository removes a single repository from an installation.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/installations#remove-a-repository-from-an-app-installation
+//
+//meta:operation DELETE /user/installations/{installation_id}/repositories/{repository_id}
+func (s *AppsService) RemoveRepository(ctx context.Context, instID, repoID int64) (*Response, error) {
+	u := fmt.Sprintf("user/installations/%v/repositories/%v", instID, repoID)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// RevokeInstallationToken revokes an installation token.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/installations#revoke-an-installation-access-token
+//
+//meta:operation DELETE /installation/token
+func (s *AppsService) RevokeInstallationToken(ctx context.Context) (*Response, error) {
+	u := "installation/token"
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/apps_manifest.go

@@ -0,0 +1,51 @@
+// Copyright 2019 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// AppConfig describes the configuration of a GitHub App.
+type AppConfig struct {
+	ID            *int64     `json:"id,omitempty"`
+	Slug          *string    `json:"slug,omitempty"`
+	NodeID        *string    `json:"node_id,omitempty"`
+	Owner         *User      `json:"owner,omitempty"`
+	Name          *string    `json:"name,omitempty"`
+	Description   *string    `json:"description,omitempty"`
+	ExternalURL   *string    `json:"external_url,omitempty"`
+	HTMLURL       *string    `json:"html_url,omitempty"`
+	CreatedAt     *Timestamp `json:"created_at,omitempty"`
+	UpdatedAt     *Timestamp `json:"updated_at,omitempty"`
+	ClientID      *string    `json:"client_id,omitempty"`
+	ClientSecret  *string    `json:"client_secret,omitempty"`
+	WebhookSecret *string    `json:"webhook_secret,omitempty"`
+	PEM           *string    `json:"pem,omitempty"`
+}
+
+// CompleteAppManifest completes the App manifest handshake flow for the given
+// code.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/apps#create-a-github-app-from-a-manifest
+//
+//meta:operation POST /app-manifests/{code}/conversions
+func (s *AppsService) CompleteAppManifest(ctx context.Context, code string) (*AppConfig, *Response, error) {
+	u := fmt.Sprintf("app-manifests/%s/conversions", code)
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	cfg := new(AppConfig)
+	resp, err := s.client.Do(ctx, req, cfg)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return cfg, resp, nil
+}

vendor/github.com/google/go-github/v69/github/apps_marketplace.go

@@ -0,0 +1,207 @@
+// Copyright 2017 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// MarketplaceService handles communication with the marketplace related
+// methods of the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/apps#marketplace
+type MarketplaceService struct {
+	client *Client
+	// Stubbed controls whether endpoints that return stubbed data are used
+	// instead of production endpoints. Stubbed data is fake data that's useful
+	// for testing your GitHub Apps. Stubbed data is hard-coded and will not
+	// change based on actual subscriptions.
+	//
+	// GitHub API docs: https://docs.github.com/rest/apps#testing-with-stubbed-endpoints
+	Stubbed bool
+}
+
+// MarketplacePlan represents a GitHub Apps Marketplace Listing Plan.
+type MarketplacePlan struct {
+	URL                 *string `json:"url,omitempty"`
+	AccountsURL         *string `json:"accounts_url,omitempty"`
+	ID                  *int64  `json:"id,omitempty"`
+	Number              *int    `json:"number,omitempty"`
+	Name                *string `json:"name,omitempty"`
+	Description         *string `json:"description,omitempty"`
+	MonthlyPriceInCents *int    `json:"monthly_price_in_cents,omitempty"`
+	YearlyPriceInCents  *int    `json:"yearly_price_in_cents,omitempty"`
+	// The pricing model for this listing.  Can be one of "flat-rate", "per-unit", or "free".
+	PriceModel *string   `json:"price_model,omitempty"`
+	UnitName   *string   `json:"unit_name,omitempty"`
+	Bullets    *[]string `json:"bullets,omitempty"`
+	// State can be one of the values "draft" or "published".
+	State        *string `json:"state,omitempty"`
+	HasFreeTrial *bool   `json:"has_free_trial,omitempty"`
+}
+
+// MarketplacePurchase represents a GitHub Apps Marketplace Purchase.
+type MarketplacePurchase struct {
+	Account *MarketplacePurchaseAccount `json:"account,omitempty"`
+	// BillingCycle can be one of the values "yearly", "monthly" or nil.
+	BillingCycle    *string          `json:"billing_cycle,omitempty"`
+	NextBillingDate *Timestamp       `json:"next_billing_date,omitempty"`
+	UnitCount       *int             `json:"unit_count,omitempty"`
+	Plan            *MarketplacePlan `json:"plan,omitempty"`
+	OnFreeTrial     *bool            `json:"on_free_trial,omitempty"`
+	FreeTrialEndsOn *Timestamp       `json:"free_trial_ends_on,omitempty"`
+	UpdatedAt       *Timestamp       `json:"updated_at,omitempty"`
+}
+
+// MarketplacePendingChange represents a pending change to a GitHub Apps Marketplace Plan.
+type MarketplacePendingChange struct {
+	EffectiveDate *Timestamp       `json:"effective_date,omitempty"`
+	UnitCount     *int             `json:"unit_count,omitempty"`
+	ID            *int64           `json:"id,omitempty"`
+	Plan          *MarketplacePlan `json:"plan,omitempty"`
+}
+
+// MarketplacePlanAccount represents a GitHub Account (user or organization) on a specific plan.
+type MarketplacePlanAccount struct {
+	URL                      *string                   `json:"url,omitempty"`
+	Type                     *string                   `json:"type,omitempty"`
+	ID                       *int64                    `json:"id,omitempty"`
+	Login                    *string                   `json:"login,omitempty"`
+	OrganizationBillingEmail *string                   `json:"organization_billing_email,omitempty"`
+	MarketplacePurchase      *MarketplacePurchase      `json:"marketplace_purchase,omitempty"`
+	MarketplacePendingChange *MarketplacePendingChange `json:"marketplace_pending_change,omitempty"`
+}
+
+// MarketplacePurchaseAccount represents a GitHub Account (user or organization) for a Purchase.
+type MarketplacePurchaseAccount struct {
+	URL                      *string `json:"url,omitempty"`
+	Type                     *string `json:"type,omitempty"`
+	ID                       *int64  `json:"id,omitempty"`
+	Login                    *string `json:"login,omitempty"`
+	OrganizationBillingEmail *string `json:"organization_billing_email,omitempty"`
+	Email                    *string `json:"email,omitempty"`
+	NodeID                   *string `json:"node_id,omitempty"`
+}
+
+// ListPlans lists all plans for your Marketplace listing.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/marketplace#list-plans
+// GitHub API docs: https://docs.github.com/rest/apps/marketplace#list-plans-stubbed
+//
+//meta:operation GET /marketplace_listing/plans
+//meta:operation GET /marketplace_listing/stubbed/plans
+func (s *MarketplaceService) ListPlans(ctx context.Context, opts *ListOptions) ([]*MarketplacePlan, *Response, error) {
+	uri := s.marketplaceURI("plans")
+	u, err := addOptions(uri, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var plans []*MarketplacePlan
+	resp, err := s.client.Do(ctx, req, &plans)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return plans, resp, nil
+}
+
+// ListPlanAccountsForPlan lists all GitHub accounts (user or organization) on a specific plan.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/marketplace#list-accounts-for-a-plan
+// GitHub API docs: https://docs.github.com/rest/apps/marketplace#list-accounts-for-a-plan-stubbed
+//
+//meta:operation GET /marketplace_listing/plans/{plan_id}/accounts
+//meta:operation GET /marketplace_listing/stubbed/plans/{plan_id}/accounts
+func (s *MarketplaceService) ListPlanAccountsForPlan(ctx context.Context, planID int64, opts *ListOptions) ([]*MarketplacePlanAccount, *Response, error) {
+	uri := s.marketplaceURI(fmt.Sprintf("plans/%v/accounts", planID))
+	u, err := addOptions(uri, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var accounts []*MarketplacePlanAccount
+	resp, err := s.client.Do(ctx, req, &accounts)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return accounts, resp, nil
+}
+
+// GetPlanAccountForAccount get GitHub account (user or organization) associated with an account.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/marketplace#get-a-subscription-plan-for-an-account
+// GitHub API docs: https://docs.github.com/rest/apps/marketplace#get-a-subscription-plan-for-an-account-stubbed
+//
+//meta:operation GET /marketplace_listing/accounts/{account_id}
+//meta:operation GET /marketplace_listing/stubbed/accounts/{account_id}
+func (s *MarketplaceService) GetPlanAccountForAccount(ctx context.Context, accountID int64) (*MarketplacePlanAccount, *Response, error) {
+	uri := s.marketplaceURI(fmt.Sprintf("accounts/%v", accountID))
+
+	req, err := s.client.NewRequest("GET", uri, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var account *MarketplacePlanAccount
+	resp, err := s.client.Do(ctx, req, &account)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return account, resp, nil
+}
+
+// ListMarketplacePurchasesForUser lists all GitHub marketplace purchases made by a user.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/marketplace#list-subscriptions-for-the-authenticated-user
+// GitHub API docs: https://docs.github.com/rest/apps/marketplace#list-subscriptions-for-the-authenticated-user-stubbed
+//
+//meta:operation GET /user/marketplace_purchases
+//meta:operation GET /user/marketplace_purchases/stubbed
+func (s *MarketplaceService) ListMarketplacePurchasesForUser(ctx context.Context, opts *ListOptions) ([]*MarketplacePurchase, *Response, error) {
+	uri := "user/marketplace_purchases"
+	if s.Stubbed {
+		uri = "user/marketplace_purchases/stubbed"
+	}
+
+	u, err := addOptions(uri, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var purchases []*MarketplacePurchase
+	resp, err := s.client.Do(ctx, req, &purchases)
+	if err != nil {
+		return nil, resp, err
+	}
+	return purchases, resp, nil
+}
+
+func (s *MarketplaceService) marketplaceURI(endpoint string) string {
+	url := "marketplace_listing"
+	if s.Stubbed {
+		url = "marketplace_listing/stubbed"
+	}
+	return url + "/" + endpoint
+}

vendor/github.com/google/go-github/v69/github/attestations.go

@@ -0,0 +1,27 @@
+// Copyright 2024 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"encoding/json"
+)
+
+// Attestation represents an artifact attestation associated with a repository.
+// The provided bundle can be used to verify the provenance of artifacts.
+//
+// https://docs.github.com/en/actions/security-for-github-actions/using-artifact-attestations/using-artifact-attestations-to-establish-provenance-for-builds
+type Attestation struct {
+	// The attestation's Sigstore Bundle.
+	// Refer to the sigstore bundle specification for more info:
+	// https://github.com/sigstore/protobuf-specs/blob/main/protos/sigstore_bundle.proto
+	Bundle       json.RawMessage `json:"bundle"`
+	RepositoryID int64           `json:"repository_id"`
+}
+
+// AttestationsResponse represents a collection of artifact attestations.
+type AttestationsResponse struct {
+	Attestations []*Attestation `json:"attestations"`
+}

vendor/github.com/google/go-github/v69/github/authorizations.go

@@ -0,0 +1,293 @@
+// Copyright 2015 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// Scope models a GitHub authorization scope.
+//
+// GitHub API docs: https://docs.github.com/rest/oauth/#scopes
+type Scope string
+
+// This is the set of scopes for GitHub API V3.
+const (
+	ScopeNone           Scope = "(no scope)" // REVISIT: is this actually returned, or just a documentation artifact?
+	ScopeUser           Scope = "user"
+	ScopeUserEmail      Scope = "user:email"
+	ScopeUserFollow     Scope = "user:follow"
+	ScopePublicRepo     Scope = "public_repo"
+	ScopeRepo           Scope = "repo"
+	ScopeRepoDeployment Scope = "repo_deployment"
+	ScopeRepoStatus     Scope = "repo:status"
+	ScopeDeleteRepo     Scope = "delete_repo"
+	ScopeNotifications  Scope = "notifications"
+	ScopeGist           Scope = "gist"
+	ScopeReadRepoHook   Scope = "read:repo_hook"
+	ScopeWriteRepoHook  Scope = "write:repo_hook"
+	ScopeAdminRepoHook  Scope = "admin:repo_hook"
+	ScopeAdminOrgHook   Scope = "admin:org_hook"
+	ScopeReadOrg        Scope = "read:org"
+	ScopeWriteOrg       Scope = "write:org"
+	ScopeAdminOrg       Scope = "admin:org"
+	ScopeReadPublicKey  Scope = "read:public_key"
+	ScopeWritePublicKey Scope = "write:public_key"
+	ScopeAdminPublicKey Scope = "admin:public_key"
+	ScopeReadGPGKey     Scope = "read:gpg_key"
+	ScopeWriteGPGKey    Scope = "write:gpg_key"
+	ScopeAdminGPGKey    Scope = "admin:gpg_key"
+	ScopeSecurityEvents Scope = "security_events"
+)
+
+// AuthorizationsService handles communication with the authorization related
+// methods of the GitHub API.
+//
+// This service requires HTTP Basic Authentication; it cannot be accessed using
+// an OAuth token.
+//
+// GitHub API docs: https://docs.github.com/rest/oauth-authorizations
+type AuthorizationsService service
+
+// Authorization represents an individual GitHub authorization.
+type Authorization struct {
+	ID             *int64            `json:"id,omitempty"`
+	URL            *string           `json:"url,omitempty"`
+	Scopes         []Scope           `json:"scopes,omitempty"`
+	Token          *string           `json:"token,omitempty"`
+	TokenLastEight *string           `json:"token_last_eight,omitempty"`
+	HashedToken    *string           `json:"hashed_token,omitempty"`
+	App            *AuthorizationApp `json:"app,omitempty"`
+	Note           *string           `json:"note,omitempty"`
+	NoteURL        *string           `json:"note_url,omitempty"`
+	UpdatedAt      *Timestamp        `json:"updated_at,omitempty"`
+	CreatedAt      *Timestamp        `json:"created_at,omitempty"`
+	Fingerprint    *string           `json:"fingerprint,omitempty"`
+
+	// User is only populated by the Check and Reset methods.
+	User *User `json:"user,omitempty"`
+}
+
+func (a Authorization) String() string {
+	return Stringify(a)
+}
+
+// AuthorizationApp represents an individual GitHub app (in the context of authorization).
+type AuthorizationApp struct {
+	URL      *string `json:"url,omitempty"`
+	Name     *string `json:"name,omitempty"`
+	ClientID *string `json:"client_id,omitempty"`
+}
+
+func (a AuthorizationApp) String() string {
+	return Stringify(a)
+}
+
+// Grant represents an OAuth application that has been granted access to an account.
+type Grant struct {
+	ID        *int64            `json:"id,omitempty"`
+	URL       *string           `json:"url,omitempty"`
+	App       *AuthorizationApp `json:"app,omitempty"`
+	CreatedAt *Timestamp        `json:"created_at,omitempty"`
+	UpdatedAt *Timestamp        `json:"updated_at,omitempty"`
+	Scopes    []string          `json:"scopes,omitempty"`
+}
+
+func (g Grant) String() string {
+	return Stringify(g)
+}
+
+// AuthorizationRequest represents a request to create an authorization.
+type AuthorizationRequest struct {
+	Scopes       []Scope `json:"scopes,omitempty"`
+	Note         *string `json:"note,omitempty"`
+	NoteURL      *string `json:"note_url,omitempty"`
+	ClientID     *string `json:"client_id,omitempty"`
+	ClientSecret *string `json:"client_secret,omitempty"`
+	Fingerprint  *string `json:"fingerprint,omitempty"`
+}
+
+func (a AuthorizationRequest) String() string {
+	return Stringify(a)
+}
+
+// AuthorizationUpdateRequest represents a request to update an authorization.
+//
+// Note that for any one update, you must only provide one of the "scopes"
+// fields. That is, you may provide only one of "Scopes", or "AddScopes", or
+// "RemoveScopes".
+//
+// GitHub API docs: https://docs.github.com/rest/oauth-authorizations#update-an-existing-authorization
+type AuthorizationUpdateRequest struct {
+	Scopes       []string `json:"scopes,omitempty"`
+	AddScopes    []string `json:"add_scopes,omitempty"`
+	RemoveScopes []string `json:"remove_scopes,omitempty"`
+	Note         *string  `json:"note,omitempty"`
+	NoteURL      *string  `json:"note_url,omitempty"`
+	Fingerprint  *string  `json:"fingerprint,omitempty"`
+}
+
+func (a AuthorizationUpdateRequest) String() string {
+	return Stringify(a)
+}
+
+// Check if an OAuth token is valid for a specific app.
+//
+// Note that this operation requires the use of BasicAuth, but where the
+// username is the OAuth application clientID, and the password is its
+// clientSecret. Invalid tokens will return a 404 Not Found.
+//
+// The returned Authorization.User field will be populated.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/oauth-applications#check-a-token
+//
+//meta:operation POST /applications/{client_id}/token
+func (s *AuthorizationsService) Check(ctx context.Context, clientID, accessToken string) (*Authorization, *Response, error) {
+	u := fmt.Sprintf("applications/%v/token", clientID)
+
+	reqBody := &struct {
+		AccessToken string `json:"access_token"`
+	}{AccessToken: accessToken}
+
+	req, err := s.client.NewRequest("POST", u, reqBody)
+	if err != nil {
+		return nil, nil, err
+	}
+	req.Header.Set("Accept", mediaTypeOAuthAppPreview)
+
+	a := new(Authorization)
+	resp, err := s.client.Do(ctx, req, a)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return a, resp, nil
+}
+
+// Reset is used to reset a valid OAuth token without end user involvement.
+// Applications must save the "token" property in the response, because changes
+// take effect immediately.
+//
+// Note that this operation requires the use of BasicAuth, but where the
+// username is the OAuth application clientID, and the password is its
+// clientSecret. Invalid tokens will return a 404 Not Found.
+//
+// The returned Authorization.User field will be populated.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/oauth-applications#reset-a-token
+//
+//meta:operation PATCH /applications/{client_id}/token
+func (s *AuthorizationsService) Reset(ctx context.Context, clientID, accessToken string) (*Authorization, *Response, error) {
+	u := fmt.Sprintf("applications/%v/token", clientID)
+
+	reqBody := &struct {
+		AccessToken string `json:"access_token"`
+	}{AccessToken: accessToken}
+
+	req, err := s.client.NewRequest("PATCH", u, reqBody)
+	if err != nil {
+		return nil, nil, err
+	}
+	req.Header.Set("Accept", mediaTypeOAuthAppPreview)
+
+	a := new(Authorization)
+	resp, err := s.client.Do(ctx, req, a)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return a, resp, nil
+}
+
+// Revoke an authorization for an application.
+//
+// Note that this operation requires the use of BasicAuth, but where the
+// username is the OAuth application clientID, and the password is its
+// clientSecret. Invalid tokens will return a 404 Not Found.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/oauth-applications#delete-an-app-token
+//
+//meta:operation DELETE /applications/{client_id}/token
+func (s *AuthorizationsService) Revoke(ctx context.Context, clientID, accessToken string) (*Response, error) {
+	u := fmt.Sprintf("applications/%v/token", clientID)
+
+	reqBody := &struct {
+		AccessToken string `json:"access_token"`
+	}{AccessToken: accessToken}
+
+	req, err := s.client.NewRequest("DELETE", u, reqBody)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Accept", mediaTypeOAuthAppPreview)
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// DeleteGrant deletes an OAuth application grant. Deleting an application's
+// grant will also delete all OAuth tokens associated with the application for
+// the user.
+//
+// GitHub API docs: https://docs.github.com/rest/apps/oauth-applications#delete-an-app-authorization
+//
+//meta:operation DELETE /applications/{client_id}/grant
+func (s *AuthorizationsService) DeleteGrant(ctx context.Context, clientID, accessToken string) (*Response, error) {
+	u := fmt.Sprintf("applications/%v/grant", clientID)
+
+	reqBody := &struct {
+		AccessToken string `json:"access_token"`
+	}{AccessToken: accessToken}
+
+	req, err := s.client.NewRequest("DELETE", u, reqBody)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Accept", mediaTypeOAuthAppPreview)
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// CreateImpersonation creates an impersonation OAuth token.
+//
+// This requires admin permissions. With the returned Authorization.Token
+// you can e.g. create or delete a user's public SSH key. NOTE: creating a
+// new token automatically revokes an existing one.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/users#create-an-impersonation-oauth-token
+//
+//meta:operation POST /admin/users/{username}/authorizations
+func (s *AuthorizationsService) CreateImpersonation(ctx context.Context, username string, authReq *AuthorizationRequest) (*Authorization, *Response, error) {
+	u := fmt.Sprintf("admin/users/%v/authorizations", username)
+	req, err := s.client.NewRequest("POST", u, authReq)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	a := new(Authorization)
+	resp, err := s.client.Do(ctx, req, a)
+	if err != nil {
+		return nil, resp, err
+	}
+	return a, resp, nil
+}
+
+// DeleteImpersonation deletes an impersonation OAuth token.
+//
+// NOTE: there can be only one at a time.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/users#delete-an-impersonation-oauth-token
+//
+//meta:operation DELETE /admin/users/{username}/authorizations
+func (s *AuthorizationsService) DeleteImpersonation(ctx context.Context, username string) (*Response, error) {
+	u := fmt.Sprintf("admin/users/%v/authorizations", username)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/billing.go

@@ -0,0 +1,218 @@
+// Copyright 2021 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// BillingService provides access to the billing related functions
+// in the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/billing
+type BillingService service
+
+// ActionBilling represents a GitHub Action billing.
+type ActionBilling struct {
+	TotalMinutesUsed     float64              `json:"total_minutes_used"`
+	TotalPaidMinutesUsed float64              `json:"total_paid_minutes_used"`
+	IncludedMinutes      float64              `json:"included_minutes"`
+	MinutesUsedBreakdown MinutesUsedBreakdown `json:"minutes_used_breakdown"`
+}
+
+// MinutesUsedBreakdown counts the actions minutes used by machine type (e.g. UBUNTU, WINDOWS, MACOS).
+type MinutesUsedBreakdown = map[string]int
+
+// PackageBilling represents a GitHub Package billing.
+type PackageBilling struct {
+	TotalGigabytesBandwidthUsed     int     `json:"total_gigabytes_bandwidth_used"`
+	TotalPaidGigabytesBandwidthUsed int     `json:"total_paid_gigabytes_bandwidth_used"`
+	IncludedGigabytesBandwidth      float64 `json:"included_gigabytes_bandwidth"`
+}
+
+// StorageBilling represents a GitHub Storage billing.
+type StorageBilling struct {
+	DaysLeftInBillingCycle       int     `json:"days_left_in_billing_cycle"`
+	EstimatedPaidStorageForMonth float64 `json:"estimated_paid_storage_for_month"`
+	EstimatedStorageForMonth     float64 `json:"estimated_storage_for_month"`
+}
+
+// ActiveCommitters represents the total active committers across all repositories in an Organization.
+type ActiveCommitters struct {
+	TotalAdvancedSecurityCommitters     int                           `json:"total_advanced_security_committers"`
+	TotalCount                          int                           `json:"total_count"`
+	MaximumAdvancedSecurityCommitters   int                           `json:"maximum_advanced_security_committers"`
+	PurchasedAdvancedSecurityCommitters int                           `json:"purchased_advanced_security_committers"`
+	Repositories                        []*RepositoryActiveCommitters `json:"repositories,omitempty"`
+}
+
+// RepositoryActiveCommitters represents active committers on each repository.
+type RepositoryActiveCommitters struct {
+	Name                                *string                                `json:"name,omitempty"`
+	AdvancedSecurityCommitters          *int                                   `json:"advanced_security_committers,omitempty"`
+	AdvancedSecurityCommittersBreakdown []*AdvancedSecurityCommittersBreakdown `json:"advanced_security_committers_breakdown,omitempty"`
+}
+
+// AdvancedSecurityCommittersBreakdown represents the user activity breakdown for ActiveCommitters.
+type AdvancedSecurityCommittersBreakdown struct {
+	UserLogin      *string `json:"user_login,omitempty"`
+	LastPushedDate *string `json:"last_pushed_date,omitempty"`
+}
+
+// GetActionsBillingOrg returns the summary of the free and paid GitHub Actions minutes used for an Org.
+//
+// GitHub API docs: https://docs.github.com/rest/billing/billing#get-github-actions-billing-for-an-organization
+//
+//meta:operation GET /orgs/{org}/settings/billing/actions
+func (s *BillingService) GetActionsBillingOrg(ctx context.Context, org string) (*ActionBilling, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/settings/billing/actions", org)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	actionsOrgBilling := new(ActionBilling)
+	resp, err := s.client.Do(ctx, req, actionsOrgBilling)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return actionsOrgBilling, resp, nil
+}
+
+// GetPackagesBillingOrg returns the free and paid storage used for GitHub Packages in gigabytes for an Org.
+//
+// GitHub API docs: https://docs.github.com/rest/billing/billing#get-github-packages-billing-for-an-organization
+//
+//meta:operation GET /orgs/{org}/settings/billing/packages
+func (s *BillingService) GetPackagesBillingOrg(ctx context.Context, org string) (*PackageBilling, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/settings/billing/packages", org)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	packagesOrgBilling := new(PackageBilling)
+	resp, err := s.client.Do(ctx, req, packagesOrgBilling)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return packagesOrgBilling, resp, nil
+}
+
+// GetStorageBillingOrg returns the estimated paid and estimated total storage used for GitHub Actions
+// and GitHub Packages in gigabytes for an Org.
+//
+// GitHub API docs: https://docs.github.com/rest/billing/billing#get-shared-storage-billing-for-an-organization
+//
+//meta:operation GET /orgs/{org}/settings/billing/shared-storage
+func (s *BillingService) GetStorageBillingOrg(ctx context.Context, org string) (*StorageBilling, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/settings/billing/shared-storage", org)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	storageOrgBilling := new(StorageBilling)
+	resp, err := s.client.Do(ctx, req, storageOrgBilling)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return storageOrgBilling, resp, nil
+}
+
+// GetAdvancedSecurityActiveCommittersOrg returns the GitHub Advanced Security active committers for an organization per repository.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/billing/billing#get-github-advanced-security-active-committers-for-an-organization
+//
+//meta:operation GET /orgs/{org}/settings/billing/advanced-security
+func (s *BillingService) GetAdvancedSecurityActiveCommittersOrg(ctx context.Context, org string, opts *ListOptions) (*ActiveCommitters, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/settings/billing/advanced-security", org)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	activeOrgCommitters := new(ActiveCommitters)
+	resp, err := s.client.Do(ctx, req, activeOrgCommitters)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return activeOrgCommitters, resp, nil
+}
+
+// GetActionsBillingUser returns the summary of the free and paid GitHub Actions minutes used for a user.
+//
+// GitHub API docs: https://docs.github.com/rest/billing/billing#get-github-actions-billing-for-a-user
+//
+//meta:operation GET /users/{username}/settings/billing/actions
+func (s *BillingService) GetActionsBillingUser(ctx context.Context, user string) (*ActionBilling, *Response, error) {
+	u := fmt.Sprintf("users/%v/settings/billing/actions", user)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	actionsUserBilling := new(ActionBilling)
+	resp, err := s.client.Do(ctx, req, actionsUserBilling)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return actionsUserBilling, resp, nil
+}
+
+// GetPackagesBillingUser returns the free and paid storage used for GitHub Packages in gigabytes for a user.
+//
+// GitHub API docs: https://docs.github.com/rest/billing/billing#get-github-packages-billing-for-a-user
+//
+//meta:operation GET /users/{username}/settings/billing/packages
+func (s *BillingService) GetPackagesBillingUser(ctx context.Context, user string) (*PackageBilling, *Response, error) {
+	u := fmt.Sprintf("users/%v/settings/billing/packages", user)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	packagesUserBilling := new(PackageBilling)
+	resp, err := s.client.Do(ctx, req, packagesUserBilling)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return packagesUserBilling, resp, nil
+}
+
+// GetStorageBillingUser returns the estimated paid and estimated total storage used for GitHub Actions
+// and GitHub Packages in gigabytes for a user.
+//
+// GitHub API docs: https://docs.github.com/rest/billing/billing#get-shared-storage-billing-for-a-user
+//
+//meta:operation GET /users/{username}/settings/billing/shared-storage
+func (s *BillingService) GetStorageBillingUser(ctx context.Context, user string) (*StorageBilling, *Response, error) {
+	u := fmt.Sprintf("users/%v/settings/billing/shared-storage", user)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	storageUserBilling := new(StorageBilling)
+	resp, err := s.client.Do(ctx, req, storageUserBilling)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return storageUserBilling, resp, nil
+}

vendor/github.com/google/go-github/v69/github/checks.go

@@ -0,0 +1,478 @@
+// Copyright 2018 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ChecksService provides access to the Checks API in the
+// GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/checks/
+type ChecksService service
+
+// CheckRun represents a GitHub check run on a repository associated with a GitHub app.
+type CheckRun struct {
+	ID           *int64          `json:"id,omitempty"`
+	NodeID       *string         `json:"node_id,omitempty"`
+	HeadSHA      *string         `json:"head_sha,omitempty"`
+	ExternalID   *string         `json:"external_id,omitempty"`
+	URL          *string         `json:"url,omitempty"`
+	HTMLURL      *string         `json:"html_url,omitempty"`
+	DetailsURL   *string         `json:"details_url,omitempty"`
+	Status       *string         `json:"status,omitempty"`
+	Conclusion   *string         `json:"conclusion,omitempty"`
+	StartedAt    *Timestamp      `json:"started_at,omitempty"`
+	CompletedAt  *Timestamp      `json:"completed_at,omitempty"`
+	Output       *CheckRunOutput `json:"output,omitempty"`
+	Name         *string         `json:"name,omitempty"`
+	CheckSuite   *CheckSuite     `json:"check_suite,omitempty"`
+	App          *App            `json:"app,omitempty"`
+	PullRequests []*PullRequest  `json:"pull_requests,omitempty"`
+}
+
+// CheckRunOutput represents the output of a CheckRun.
+type CheckRunOutput struct {
+	Title            *string               `json:"title,omitempty"`
+	Summary          *string               `json:"summary,omitempty"`
+	Text             *string               `json:"text,omitempty"`
+	AnnotationsCount *int                  `json:"annotations_count,omitempty"`
+	AnnotationsURL   *string               `json:"annotations_url,omitempty"`
+	Annotations      []*CheckRunAnnotation `json:"annotations,omitempty"`
+	Images           []*CheckRunImage      `json:"images,omitempty"`
+}
+
+// CheckRunAnnotation represents an annotation object for a CheckRun output.
+type CheckRunAnnotation struct {
+	Path            *string `json:"path,omitempty"`
+	StartLine       *int    `json:"start_line,omitempty"`
+	EndLine         *int    `json:"end_line,omitempty"`
+	StartColumn     *int    `json:"start_column,omitempty"`
+	EndColumn       *int    `json:"end_column,omitempty"`
+	AnnotationLevel *string `json:"annotation_level,omitempty"`
+	Message         *string `json:"message,omitempty"`
+	Title           *string `json:"title,omitempty"`
+	RawDetails      *string `json:"raw_details,omitempty"`
+}
+
+// CheckRunImage represents an image object for a CheckRun output.
+type CheckRunImage struct {
+	Alt      *string `json:"alt,omitempty"`
+	ImageURL *string `json:"image_url,omitempty"`
+	Caption  *string `json:"caption,omitempty"`
+}
+
+// CheckSuite represents a suite of check runs.
+type CheckSuite struct {
+	ID           *int64         `json:"id,omitempty"`
+	NodeID       *string        `json:"node_id,omitempty"`
+	HeadBranch   *string        `json:"head_branch,omitempty"`
+	HeadSHA      *string        `json:"head_sha,omitempty"`
+	URL          *string        `json:"url,omitempty"`
+	BeforeSHA    *string        `json:"before,omitempty"`
+	AfterSHA     *string        `json:"after,omitempty"`
+	Status       *string        `json:"status,omitempty"`
+	Conclusion   *string        `json:"conclusion,omitempty"`
+	CreatedAt    *Timestamp     `json:"created_at,omitempty"`
+	UpdatedAt    *Timestamp     `json:"updated_at,omitempty"`
+	App          *App           `json:"app,omitempty"`
+	Repository   *Repository    `json:"repository,omitempty"`
+	PullRequests []*PullRequest `json:"pull_requests,omitempty"`
+
+	// The following fields are only populated by Webhook events.
+	HeadCommit           *Commit `json:"head_commit,omitempty"`
+	LatestCheckRunsCount *int64  `json:"latest_check_runs_count,omitempty"`
+	Rerequestable        *bool   `json:"rerequestable,omitempty"`
+	RunsRerequestable    *bool   `json:"runs_rerequestable,omitempty"`
+}
+
+func (c CheckRun) String() string {
+	return Stringify(c)
+}
+
+func (c CheckSuite) String() string {
+	return Stringify(c)
+}
+
+// GetCheckRun gets a check-run for a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/checks/runs#get-a-check-run
+//
+//meta:operation GET /repos/{owner}/{repo}/check-runs/{check_run_id}
+func (s *ChecksService) GetCheckRun(ctx context.Context, owner, repo string, checkRunID int64) (*CheckRun, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/check-runs/%v", owner, repo, checkRunID)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
+
+	checkRun := new(CheckRun)
+	resp, err := s.client.Do(ctx, req, checkRun)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return checkRun, resp, nil
+}
+
+// GetCheckSuite gets a single check suite.
+//
+// GitHub API docs: https://docs.github.com/rest/checks/suites#get-a-check-suite
+//
+//meta:operation GET /repos/{owner}/{repo}/check-suites/{check_suite_id}
+func (s *ChecksService) GetCheckSuite(ctx context.Context, owner, repo string, checkSuiteID int64) (*CheckSuite, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/check-suites/%v", owner, repo, checkSuiteID)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
+
+	checkSuite := new(CheckSuite)
+	resp, err := s.client.Do(ctx, req, checkSuite)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return checkSuite, resp, nil
+}
+
+// CreateCheckRunOptions sets up parameters needed to create a CheckRun.
+type CreateCheckRunOptions struct {
+	Name        string            `json:"name"`                   // The name of the check (e.g., "code-coverage"). (Required.)
+	HeadSHA     string            `json:"head_sha"`               // The SHA of the commit. (Required.)
+	DetailsURL  *string           `json:"details_url,omitempty"`  // The URL of the integrator's site that has the full details of the check. (Optional.)
+	ExternalID  *string           `json:"external_id,omitempty"`  // A reference for the run on the integrator's system. (Optional.)
+	Status      *string           `json:"status,omitempty"`       // The current status. Can be one of "queued", "in_progress", or "completed". Default: "queued". (Optional.)
+	Conclusion  *string           `json:"conclusion,omitempty"`   // Can be one of "success", "failure", "neutral", "cancelled", "skipped", "timed_out", or "action_required". (Optional. Required if you provide a status of "completed".)
+	StartedAt   *Timestamp        `json:"started_at,omitempty"`   // The time that the check run began. (Optional.)
+	CompletedAt *Timestamp        `json:"completed_at,omitempty"` // The time the check completed. (Optional. Required if you provide conclusion.)
+	Output      *CheckRunOutput   `json:"output,omitempty"`       // Provide descriptive details about the run. (Optional)
+	Actions     []*CheckRunAction `json:"actions,omitempty"`      // Possible further actions the integrator can perform, which a user may trigger. (Optional.)
+}
+
+// CheckRunAction exposes further actions the integrator can perform, which a user may trigger.
+type CheckRunAction struct {
+	Label       string `json:"label"`       // The text to be displayed on a button in the web UI. The maximum size is 20 characters. (Required.)
+	Description string `json:"description"` // A short explanation of what this action would do. The maximum size is 40 characters. (Required.)
+	Identifier  string `json:"identifier"`  // A reference for the action on the integrator's system. The maximum size is 20 characters. (Required.)
+}
+
+// CreateCheckRun creates a check run for repository.
+//
+// GitHub API docs: https://docs.github.com/rest/checks/runs#create-a-check-run
+//
+//meta:operation POST /repos/{owner}/{repo}/check-runs
+func (s *ChecksService) CreateCheckRun(ctx context.Context, owner, repo string, opts CreateCheckRunOptions) (*CheckRun, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/check-runs", owner, repo)
+	req, err := s.client.NewRequest("POST", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
+
+	checkRun := new(CheckRun)
+	resp, err := s.client.Do(ctx, req, checkRun)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return checkRun, resp, nil
+}
+
+// UpdateCheckRunOptions sets up parameters needed to update a CheckRun.
+type UpdateCheckRunOptions struct {
+	Name        string            `json:"name"`                   // The name of the check (e.g., "code-coverage"). (Required.)
+	DetailsURL  *string           `json:"details_url,omitempty"`  // The URL of the integrator's site that has the full details of the check. (Optional.)
+	ExternalID  *string           `json:"external_id,omitempty"`  // A reference for the run on the integrator's system. (Optional.)
+	Status      *string           `json:"status,omitempty"`       // The current status. Can be one of "queued", "in_progress", or "completed". Default: "queued". (Optional.)
+	Conclusion  *string           `json:"conclusion,omitempty"`   // Can be one of "success", "failure", "neutral", "cancelled", "skipped", "timed_out", or "action_required". (Optional. Required if you provide a status of "completed".)
+	CompletedAt *Timestamp        `json:"completed_at,omitempty"` // The time the check completed. (Optional. Required if you provide conclusion.)
+	Output      *CheckRunOutput   `json:"output,omitempty"`       // Provide descriptive details about the run. (Optional)
+	Actions     []*CheckRunAction `json:"actions,omitempty"`      // Possible further actions the integrator can perform, which a user may trigger. (Optional.)
+}
+
+// UpdateCheckRun updates a check run for a specific commit in a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/checks/runs#update-a-check-run
+//
+//meta:operation PATCH /repos/{owner}/{repo}/check-runs/{check_run_id}
+func (s *ChecksService) UpdateCheckRun(ctx context.Context, owner, repo string, checkRunID int64, opts UpdateCheckRunOptions) (*CheckRun, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/check-runs/%v", owner, repo, checkRunID)
+	req, err := s.client.NewRequest("PATCH", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
+
+	checkRun := new(CheckRun)
+	resp, err := s.client.Do(ctx, req, checkRun)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return checkRun, resp, nil
+}
+
+// ListCheckRunAnnotations lists the annotations for a check run.
+//
+// GitHub API docs: https://docs.github.com/rest/checks/runs#list-check-run-annotations
+//
+//meta:operation GET /repos/{owner}/{repo}/check-runs/{check_run_id}/annotations
+func (s *ChecksService) ListCheckRunAnnotations(ctx context.Context, owner, repo string, checkRunID int64, opts *ListOptions) ([]*CheckRunAnnotation, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/check-runs/%v/annotations", owner, repo, checkRunID)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
+
+	var checkRunAnnotations []*CheckRunAnnotation
+	resp, err := s.client.Do(ctx, req, &checkRunAnnotations)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return checkRunAnnotations, resp, nil
+}
+
+// ListCheckRunsOptions represents parameters to list check runs.
+type ListCheckRunsOptions struct {
+	CheckName *string `url:"check_name,omitempty"` // Returns check runs with the specified name.
+	Status    *string `url:"status,omitempty"`     // Returns check runs with the specified status. Can be one of "queued", "in_progress", or "completed".
+	Filter    *string `url:"filter,omitempty"`     // Filters check runs by their completed_at timestamp. Can be one of "latest" (returning the most recent check runs) or "all". Default: "latest"
+	AppID     *int64  `url:"app_id,omitempty"`     // Filters check runs by GitHub App ID.
+
+	ListOptions
+}
+
+// ListCheckRunsResults represents the result of a check run list.
+type ListCheckRunsResults struct {
+	Total     *int        `json:"total_count,omitempty"`
+	CheckRuns []*CheckRun `json:"check_runs,omitempty"`
+}
+
+// ListCheckRunsForRef lists check runs for a specific ref.
+//
+// GitHub API docs: https://docs.github.com/rest/checks/runs#list-check-runs-for-a-git-reference
+//
+//meta:operation GET /repos/{owner}/{repo}/commits/{ref}/check-runs
+func (s *ChecksService) ListCheckRunsForRef(ctx context.Context, owner, repo, ref string, opts *ListCheckRunsOptions) (*ListCheckRunsResults, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/commits/%v/check-runs", owner, repo, refURLEscape(ref))
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
+
+	var checkRunResults *ListCheckRunsResults
+	resp, err := s.client.Do(ctx, req, &checkRunResults)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return checkRunResults, resp, nil
+}
+
+// ListCheckRunsCheckSuite lists check runs for a check suite.
+//
+// GitHub API docs: https://docs.github.com/rest/checks/runs#list-check-runs-in-a-check-suite
+//
+//meta:operation GET /repos/{owner}/{repo}/check-suites/{check_suite_id}/check-runs
+func (s *ChecksService) ListCheckRunsCheckSuite(ctx context.Context, owner, repo string, checkSuiteID int64, opts *ListCheckRunsOptions) (*ListCheckRunsResults, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/check-suites/%v/check-runs", owner, repo, checkSuiteID)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
+
+	var checkRunResults *ListCheckRunsResults
+	resp, err := s.client.Do(ctx, req, &checkRunResults)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return checkRunResults, resp, nil
+}
+
+// ReRequestCheckRun triggers GitHub to rerequest an existing check run.
+//
+// GitHub API docs: https://docs.github.com/rest/checks/runs#rerequest-a-check-run
+//
+//meta:operation POST /repos/{owner}/{repo}/check-runs/{check_run_id}/rerequest
+func (s *ChecksService) ReRequestCheckRun(ctx context.Context, owner, repo string, checkRunID int64) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/check-runs/%v/rerequest", owner, repo, checkRunID)
+
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// ListCheckSuiteOptions represents parameters to list check suites.
+type ListCheckSuiteOptions struct {
+	CheckName *string `url:"check_name,omitempty"` // Filters checks suites by the name of the check run.
+	AppID     *int    `url:"app_id,omitempty"`     // Filters check suites by GitHub App id.
+
+	ListOptions
+}
+
+// ListCheckSuiteResults represents the result of a check run list.
+type ListCheckSuiteResults struct {
+	Total       *int          `json:"total_count,omitempty"`
+	CheckSuites []*CheckSuite `json:"check_suites,omitempty"`
+}
+
+// ListCheckSuitesForRef lists check suite for a specific ref.
+//
+// GitHub API docs: https://docs.github.com/rest/checks/suites#list-check-suites-for-a-git-reference
+//
+//meta:operation GET /repos/{owner}/{repo}/commits/{ref}/check-suites
+func (s *ChecksService) ListCheckSuitesForRef(ctx context.Context, owner, repo, ref string, opts *ListCheckSuiteOptions) (*ListCheckSuiteResults, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/commits/%v/check-suites", owner, repo, refURLEscape(ref))
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
+
+	var checkSuiteResults *ListCheckSuiteResults
+	resp, err := s.client.Do(ctx, req, &checkSuiteResults)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return checkSuiteResults, resp, nil
+}
+
+// AutoTriggerCheck enables or disables automatic creation of CheckSuite events upon pushes to the repository.
+type AutoTriggerCheck struct {
+	AppID   *int64 `json:"app_id,omitempty"`  // The id of the GitHub App. (Required.)
+	Setting *bool  `json:"setting,omitempty"` // Set to "true" to enable automatic creation of CheckSuite events upon pushes to the repository, or "false" to disable them. Default: "true" (Required.)
+}
+
+// CheckSuitePreferenceOptions set options for check suite preferences for a repository.
+type CheckSuitePreferenceOptions struct {
+	AutoTriggerChecks []*AutoTriggerCheck `json:"auto_trigger_checks,omitempty"` // A slice of auto trigger checks that can be set for a check suite in a repository.
+}
+
+// CheckSuitePreferenceResults represents the results of the preference set operation.
+type CheckSuitePreferenceResults struct {
+	Preferences *PreferenceList `json:"preferences,omitempty"`
+	Repository  *Repository     `json:"repository,omitempty"`
+}
+
+// PreferenceList represents a list of auto trigger checks for repository.
+type PreferenceList struct {
+	AutoTriggerChecks []*AutoTriggerCheck `json:"auto_trigger_checks,omitempty"` // A slice of auto trigger checks that can be set for a check suite in a repository.
+}
+
+// SetCheckSuitePreferences changes the default automatic flow when creating check suites.
+//
+// GitHub API docs: https://docs.github.com/rest/checks/suites#update-repository-preferences-for-check-suites
+//
+//meta:operation PATCH /repos/{owner}/{repo}/check-suites/preferences
+func (s *ChecksService) SetCheckSuitePreferences(ctx context.Context, owner, repo string, opts CheckSuitePreferenceOptions) (*CheckSuitePreferenceResults, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/check-suites/preferences", owner, repo)
+	req, err := s.client.NewRequest("PATCH", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
+
+	var checkSuitePrefResults *CheckSuitePreferenceResults
+	resp, err := s.client.Do(ctx, req, &checkSuitePrefResults)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return checkSuitePrefResults, resp, nil
+}
+
+// CreateCheckSuiteOptions sets up parameters to manually create a check suites.
+type CreateCheckSuiteOptions struct {
+	HeadSHA    string  `json:"head_sha"`              // The sha of the head commit. (Required.)
+	HeadBranch *string `json:"head_branch,omitempty"` // The name of the head branch where the code changes are implemented.
+}
+
+// CreateCheckSuite manually creates a check suite for a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/checks/suites#create-a-check-suite
+//
+//meta:operation POST /repos/{owner}/{repo}/check-suites
+func (s *ChecksService) CreateCheckSuite(ctx context.Context, owner, repo string, opts CreateCheckSuiteOptions) (*CheckSuite, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/check-suites", owner, repo)
+	req, err := s.client.NewRequest("POST", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
+
+	checkSuite := new(CheckSuite)
+	resp, err := s.client.Do(ctx, req, checkSuite)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return checkSuite, resp, nil
+}
+
+// ReRequestCheckSuite triggers GitHub to rerequest an existing check suite, without pushing new code to a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/checks/suites#rerequest-a-check-suite
+//
+//meta:operation POST /repos/{owner}/{repo}/check-suites/{check_suite_id}/rerequest
+func (s *ChecksService) ReRequestCheckSuite(ctx context.Context, owner, repo string, checkSuiteID int64) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/check-suites/%v/rerequest", owner, repo, checkSuiteID)
+
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Accept", mediaTypeCheckRunsPreview)
+
+	resp, err := s.client.Do(ctx, req, nil)
+	return resp, err
+}

vendor/github.com/google/go-github/v69/github/code_scanning.go

@@ -0,0 +1,673 @@
+// Copyright 2020 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// CodeScanningService handles communication with the code scanning related
+// methods of the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning
+type CodeScanningService service
+
+// Rule represents the complete details of GitHub Code Scanning alert type.
+type Rule struct {
+	ID                    *string  `json:"id,omitempty"`
+	Severity              *string  `json:"severity,omitempty"`
+	Description           *string  `json:"description,omitempty"`
+	Name                  *string  `json:"name,omitempty"`
+	SecuritySeverityLevel *string  `json:"security_severity_level,omitempty"`
+	FullDescription       *string  `json:"full_description,omitempty"`
+	Tags                  []string `json:"tags,omitempty"`
+	Help                  *string  `json:"help,omitempty"`
+}
+
+// Location represents the exact location of the GitHub Code Scanning Alert in the scanned project.
+type Location struct {
+	Path        *string `json:"path,omitempty"`
+	StartLine   *int    `json:"start_line,omitempty"`
+	EndLine     *int    `json:"end_line,omitempty"`
+	StartColumn *int    `json:"start_column,omitempty"`
+	EndColumn   *int    `json:"end_column,omitempty"`
+}
+
+// Message is a part of MostRecentInstance struct which provides the appropriate message when any action is performed on the analysis object.
+type Message struct {
+	Text *string `json:"text,omitempty"`
+}
+
+// MostRecentInstance provides details of the most recent instance of this alert for the default branch or for the specified Git reference.
+type MostRecentInstance struct {
+	Ref             *string   `json:"ref,omitempty"`
+	AnalysisKey     *string   `json:"analysis_key,omitempty"`
+	Category        *string   `json:"category,omitempty"`
+	Environment     *string   `json:"environment,omitempty"`
+	State           *string   `json:"state,omitempty"`
+	CommitSHA       *string   `json:"commit_sha,omitempty"`
+	Message         *Message  `json:"message,omitempty"`
+	Location        *Location `json:"location,omitempty"`
+	HTMLURL         *string   `json:"html_url,omitempty"`
+	Classifications []string  `json:"classifications,omitempty"`
+}
+
+// Tool represents the tool used to generate a GitHub Code Scanning Alert.
+type Tool struct {
+	Name    *string `json:"name,omitempty"`
+	GUID    *string `json:"guid,omitempty"`
+	Version *string `json:"version,omitempty"`
+}
+
+// Alert represents an individual GitHub Code Scanning Alert on a single repository.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning
+type Alert struct {
+	Number             *int                  `json:"number,omitempty"`
+	Repository         *Repository           `json:"repository,omitempty"`
+	RuleID             *string               `json:"rule_id,omitempty"`
+	RuleSeverity       *string               `json:"rule_severity,omitempty"`
+	RuleDescription    *string               `json:"rule_description,omitempty"`
+	Rule               *Rule                 `json:"rule,omitempty"`
+	Tool               *Tool                 `json:"tool,omitempty"`
+	CreatedAt          *Timestamp            `json:"created_at,omitempty"`
+	UpdatedAt          *Timestamp            `json:"updated_at,omitempty"`
+	FixedAt            *Timestamp            `json:"fixed_at,omitempty"`
+	State              *string               `json:"state,omitempty"`
+	ClosedBy           *User                 `json:"closed_by,omitempty"`
+	ClosedAt           *Timestamp            `json:"closed_at,omitempty"`
+	URL                *string               `json:"url,omitempty"`
+	HTMLURL            *string               `json:"html_url,omitempty"`
+	MostRecentInstance *MostRecentInstance   `json:"most_recent_instance,omitempty"`
+	Instances          []*MostRecentInstance `json:"instances,omitempty"`
+	DismissedBy        *User                 `json:"dismissed_by,omitempty"`
+	DismissedAt        *Timestamp            `json:"dismissed_at,omitempty"`
+	DismissedReason    *string               `json:"dismissed_reason,omitempty"`
+	DismissedComment   *string               `json:"dismissed_comment,omitempty"`
+	InstancesURL       *string               `json:"instances_url,omitempty"`
+}
+
+// ID returns the ID associated with an alert. It is the number at the end of the security alert's URL.
+func (a *Alert) ID() int64 {
+	if a == nil {
+		return 0
+	}
+
+	s := a.GetHTMLURL()
+
+	// Check for an ID to parse at the end of the url
+	if i := strings.LastIndex(s, "/"); i >= 0 {
+		s = s[i+1:]
+	}
+
+	// Return the alert ID as a 64-bit integer. Unable to convert or out of range returns 0.
+	id, err := strconv.ParseInt(s, 10, 64)
+	if err != nil {
+		return 0
+	}
+
+	return id
+}
+
+// AlertInstancesListOptions specifies optional parameters to the CodeScanningService.ListAlertInstances method.
+type AlertInstancesListOptions struct {
+	// Return code scanning alert instances for a specific branch reference.
+	// The ref can be formatted as refs/heads/<branch name> or simply <branch name>. To reference a pull request use refs/pull/<number>/merge
+	Ref string `url:"ref,omitempty"`
+
+	ListOptions
+}
+
+// AlertListOptions specifies optional parameters to the CodeScanningService.ListAlerts method.
+type AlertListOptions struct {
+	// State of the code scanning alerts to list. Set to closed to list only closed code scanning alerts. Default: open
+	State string `url:"state,omitempty"`
+
+	// Return code scanning alerts for a specific branch reference.
+	// The ref can be formatted as refs/heads/<branch name> or simply <branch name>. To reference a pull request use refs/pull/<number>/merge
+	Ref string `url:"ref,omitempty"`
+
+	// If specified, only code scanning alerts with this severity will be returned. Possible values are: critical, high, medium, low, warning, note, error.
+	Severity string `url:"severity,omitempty"`
+
+	// The name of a code scanning tool. Only results by this tool will be listed.
+	ToolName string `url:"tool_name,omitempty"`
+
+	// The GUID of a code scanning tool. Only results by this tool will be listed.
+	ToolGUID string `url:"tool_guid,omitempty"`
+
+	// The direction to sort the results by. Possible values are: asc, desc. Default: desc.
+	Direction string `url:"direction,omitempty"`
+
+	// The property by which to sort the results. Possible values are: created, updated. Default: created.
+	Sort string `url:"sort,omitempty"`
+
+	ListCursorOptions
+
+	// Add ListOptions so offset pagination with integer type "page" query parameter is accepted
+	// since ListCursorOptions accepts "page" as string only.
+	ListOptions
+}
+
+// AnalysesListOptions specifies optional parameters to the CodeScanningService.ListAnalysesForRepo method.
+type AnalysesListOptions struct {
+	// Return code scanning analyses belonging to the same SARIF upload.
+	SarifID *string `url:"sarif_id,omitempty"`
+
+	// Return code scanning analyses for a specific branch reference.
+	// The ref can be formatted as refs/heads/<branch name> or simply <branch name>. To reference a pull request use refs/pull/<number>/merge
+	Ref *string `url:"ref,omitempty"`
+
+	ListOptions
+}
+
+// CodeQLDatabase represents a metadata about the CodeQL database.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning
+type CodeQLDatabase struct {
+	ID          *int64     `json:"id,omitempty"`
+	Name        *string    `json:"name,omitempty"`
+	Language    *string    `json:"language,omitempty"`
+	Uploader    *User      `json:"uploader,omitempty"`
+	ContentType *string    `json:"content_type,omitempty"`
+	Size        *int64     `json:"size,omitempty"`
+	CreatedAt   *Timestamp `json:"created_at,omitempty"`
+	UpdatedAt   *Timestamp `json:"updated_at,omitempty"`
+	URL         *string    `json:"url,omitempty"`
+}
+
+// ScanningAnalysis represents an individual GitHub Code Scanning ScanningAnalysis on a single repository.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning
+type ScanningAnalysis struct {
+	ID           *int64     `json:"id,omitempty"`
+	Ref          *string    `json:"ref,omitempty"`
+	CommitSHA    *string    `json:"commit_sha,omitempty"`
+	AnalysisKey  *string    `json:"analysis_key,omitempty"`
+	Environment  *string    `json:"environment,omitempty"`
+	Error        *string    `json:"error,omitempty"`
+	Category     *string    `json:"category,omitempty"`
+	CreatedAt    *Timestamp `json:"created_at,omitempty"`
+	ResultsCount *int       `json:"results_count,omitempty"`
+	RulesCount   *int       `json:"rules_count,omitempty"`
+	URL          *string    `json:"url,omitempty"`
+	SarifID      *string    `json:"sarif_id,omitempty"`
+	Tool         *Tool      `json:"tool,omitempty"`
+	Deletable    *bool      `json:"deletable,omitempty"`
+	Warning      *string    `json:"warning,omitempty"`
+}
+
+// SarifAnalysis specifies the results of a code scanning job.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning
+type SarifAnalysis struct {
+	CommitSHA   *string    `json:"commit_sha,omitempty"`
+	Ref         *string    `json:"ref,omitempty"`
+	Sarif       *string    `json:"sarif,omitempty"`
+	CheckoutURI *string    `json:"checkout_uri,omitempty"`
+	StartedAt   *Timestamp `json:"started_at,omitempty"`
+	ToolName    *string    `json:"tool_name,omitempty"`
+}
+
+// CodeScanningAlertState specifies the state of a code scanning alert.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning
+type CodeScanningAlertState struct {
+	// State sets the state of the code scanning alert and is a required field.
+	// You must also provide DismissedReason when you set the state to "dismissed".
+	// State can be one of: "open", "dismissed".
+	State string `json:"state"`
+	// DismissedReason represents the reason for dismissing or closing the alert.
+	// It is required when the state is "dismissed".
+	// It can be one of: "false positive", "won't fix", "used in tests".
+	DismissedReason *string `json:"dismissed_reason,omitempty"`
+	// DismissedComment is associated with the dismissal of the alert.
+	DismissedComment *string `json:"dismissed_comment,omitempty"`
+}
+
+// SarifID identifies a sarif analysis upload.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning
+type SarifID struct {
+	ID  *string `json:"id,omitempty"`
+	URL *string `json:"url,omitempty"`
+}
+
+// ListAlertsForOrg lists code scanning alerts for an org.
+//
+// You must use an access token with the security_events scope to use this endpoint. GitHub Apps must have the security_events
+// read permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning/code-scanning#list-code-scanning-alerts-for-an-organization
+//
+//meta:operation GET /orgs/{org}/code-scanning/alerts
+func (s *CodeScanningService) ListAlertsForOrg(ctx context.Context, org string, opts *AlertListOptions) ([]*Alert, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/code-scanning/alerts", org)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var alerts []*Alert
+	resp, err := s.client.Do(ctx, req, &alerts)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return alerts, resp, nil
+}
+
+// ListAlertsForRepo lists code scanning alerts for a repository.
+//
+// Lists all open code scanning alerts for the default branch (usually master) and protected branches in a repository.
+// You must use an access token with the security_events scope to use this endpoint. GitHub Apps must have the security_events
+// read permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning/code-scanning#list-code-scanning-alerts-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/code-scanning/alerts
+func (s *CodeScanningService) ListAlertsForRepo(ctx context.Context, owner, repo string, opts *AlertListOptions) ([]*Alert, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/code-scanning/alerts", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var alerts []*Alert
+	resp, err := s.client.Do(ctx, req, &alerts)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return alerts, resp, nil
+}
+
+// GetAlert gets a single code scanning alert for a repository.
+//
+// You must use an access token with the security_events scope to use this endpoint.
+// GitHub Apps must have the security_events read permission to use this endpoint.
+//
+// The security alert_id is the number at the end of the security alert's URL.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning/code-scanning#get-a-code-scanning-alert
+//
+//meta:operation GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}
+func (s *CodeScanningService) GetAlert(ctx context.Context, owner, repo string, id int64) (*Alert, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/code-scanning/alerts/%v", owner, repo, id)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	a := new(Alert)
+	resp, err := s.client.Do(ctx, req, a)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return a, resp, nil
+}
+
+// UpdateAlert updates the state of a single code scanning alert for a repository.
+//
+// You must use an access token with the security_events scope to use this endpoint.
+// GitHub Apps must have the security_events read permission to use this endpoint.
+//
+// The security alert_id is the number at the end of the security alert's URL.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning/code-scanning#update-a-code-scanning-alert
+//
+//meta:operation PATCH /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}
+func (s *CodeScanningService) UpdateAlert(ctx context.Context, owner, repo string, id int64, stateInfo *CodeScanningAlertState) (*Alert, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/code-scanning/alerts/%v", owner, repo, id)
+
+	req, err := s.client.NewRequest("PATCH", u, stateInfo)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	a := new(Alert)
+	resp, err := s.client.Do(ctx, req, a)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return a, resp, nil
+}
+
+// ListAlertInstances lists instances of a code scanning alert.
+//
+// You must use an access token with the security_events scope to use this endpoint.
+// GitHub Apps must have the security_events read permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning/code-scanning#list-instances-of-a-code-scanning-alert
+//
+//meta:operation GET /repos/{owner}/{repo}/code-scanning/alerts/{alert_number}/instances
+func (s *CodeScanningService) ListAlertInstances(ctx context.Context, owner, repo string, id int64, opts *AlertInstancesListOptions) ([]*MostRecentInstance, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/code-scanning/alerts/%v/instances", owner, repo, id)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var alertInstances []*MostRecentInstance
+	resp, err := s.client.Do(ctx, req, &alertInstances)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return alertInstances, resp, nil
+}
+
+// UploadSarif uploads the result of code scanning job to GitHub.
+//
+// For the parameter sarif, you must first compress your SARIF file using gzip and then translate the contents of the file into a Base64 encoding string.
+// You must use an access token with the security_events scope to use this endpoint. GitHub Apps must have the security_events
+// write permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning/code-scanning#upload-an-analysis-as-sarif-data
+//
+//meta:operation POST /repos/{owner}/{repo}/code-scanning/sarifs
+func (s *CodeScanningService) UploadSarif(ctx context.Context, owner, repo string, sarif *SarifAnalysis) (*SarifID, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/code-scanning/sarifs", owner, repo)
+
+	req, err := s.client.NewRequest("POST", u, sarif)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// This will always return an error without unmarshaling the data
+	resp, err := s.client.Do(ctx, req, nil)
+	// Even though there was an error, we still return the response
+	// in case the caller wants to inspect it further.
+	// However, if the error is AcceptedError, decode it below before
+	// returning from this function and closing the response body.
+	var acceptedError *AcceptedError
+	if !errors.As(err, &acceptedError) {
+		return nil, resp, err
+	}
+	sarifID := new(SarifID)
+	decErr := json.Unmarshal(acceptedError.Raw, sarifID)
+	if decErr != nil {
+		return nil, resp, decErr
+	}
+
+	return sarifID, resp, nil
+}
+
+// SARIFUpload represents information about a SARIF upload.
+type SARIFUpload struct {
+	// `pending` files have not yet been processed, while `complete` means results from the SARIF have been stored.
+	// `failed` files have either not been processed at all, or could only be partially processed.
+	ProcessingStatus *string `json:"processing_status,omitempty"`
+	// The REST API URL for getting the analyses associated with the upload.
+	AnalysesURL *string `json:"analyses_url,omitempty"`
+}
+
+// GetSARIF gets information about a SARIF upload.
+//
+// You must use an access token with the security_events scope to use this endpoint.
+// GitHub Apps must have the security_events read permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning/code-scanning#get-information-about-a-sarif-upload
+//
+//meta:operation GET /repos/{owner}/{repo}/code-scanning/sarifs/{sarif_id}
+func (s *CodeScanningService) GetSARIF(ctx context.Context, owner, repo, sarifID string) (*SARIFUpload, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/code-scanning/sarifs/%v", owner, repo, sarifID)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	sarifUpload := new(SARIFUpload)
+	resp, err := s.client.Do(ctx, req, sarifUpload)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return sarifUpload, resp, nil
+}
+
+// ListAnalysesForRepo lists code scanning analyses for a repository.
+//
+// Lists the details of all code scanning analyses for a repository, starting with the most recent.
+// You must use an access token with the security_events scope to use this endpoint.
+// GitHub Apps must have the security_events read permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning/code-scanning#list-code-scanning-analyses-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/code-scanning/analyses
+func (s *CodeScanningService) ListAnalysesForRepo(ctx context.Context, owner, repo string, opts *AnalysesListOptions) ([]*ScanningAnalysis, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/code-scanning/analyses", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var analyses []*ScanningAnalysis
+	resp, err := s.client.Do(ctx, req, &analyses)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return analyses, resp, nil
+}
+
+// GetAnalysis gets a single code scanning analysis for a repository.
+//
+// You must use an access token with the security_events scope to use this endpoint.
+// GitHub Apps must have the security_events read permission to use this endpoint.
+//
+// The security analysis_id is the ID of the analysis, as returned from the ListAnalysesForRepo operation.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning/code-scanning#get-a-code-scanning-analysis-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}
+func (s *CodeScanningService) GetAnalysis(ctx context.Context, owner, repo string, id int64) (*ScanningAnalysis, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/code-scanning/analyses/%v", owner, repo, id)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	analysis := new(ScanningAnalysis)
+	resp, err := s.client.Do(ctx, req, analysis)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return analysis, resp, nil
+}
+
+// DeleteAnalysis represents a successful deletion of a code scanning analysis.
+type DeleteAnalysis struct {
+	// Next deletable analysis in chain, without last analysis deletion confirmation
+	NextAnalysisURL *string `json:"next_analysis_url,omitempty"`
+	// Next deletable analysis in chain, with last analysis deletion confirmation
+	ConfirmDeleteURL *string `json:"confirm_delete_url,omitempty"`
+}
+
+// DeleteAnalysis deletes a single code scanning analysis from a repository.
+//
+// You must use an access token with the repo scope to use this endpoint.
+// GitHub Apps must have the security_events read permission to use this endpoint.
+//
+// The security analysis_id is the ID of the analysis, as returned from the ListAnalysesForRepo operation.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning/code-scanning#delete-a-code-scanning-analysis-from-a-repository
+//
+//meta:operation DELETE /repos/{owner}/{repo}/code-scanning/analyses/{analysis_id}
+func (s *CodeScanningService) DeleteAnalysis(ctx context.Context, owner, repo string, id int64) (*DeleteAnalysis, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/code-scanning/analyses/%v", owner, repo, id)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	deleteAnalysis := new(DeleteAnalysis)
+	resp, err := s.client.Do(ctx, req, deleteAnalysis)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return deleteAnalysis, resp, nil
+}
+
+// ListCodeQLDatabases lists the CodeQL databases that are available in a repository.
+//
+// You must use an access token with the security_events scope to use this endpoint.
+// GitHub Apps must have the contents read permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning/code-scanning#list-codeql-databases-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/code-scanning/codeql/databases
+func (s *CodeScanningService) ListCodeQLDatabases(ctx context.Context, owner, repo string) ([]*CodeQLDatabase, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/code-scanning/codeql/databases", owner, repo)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var codeqlDatabases []*CodeQLDatabase
+	resp, err := s.client.Do(ctx, req, &codeqlDatabases)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return codeqlDatabases, resp, nil
+}
+
+// GetCodeQLDatabase gets a CodeQL database for a language in a repository.
+//
+// You must use an access token with the security_events scope to use this endpoint.
+// GitHub Apps must have the contents read permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning/code-scanning#get-a-codeql-database-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/code-scanning/codeql/databases/{language}
+func (s *CodeScanningService) GetCodeQLDatabase(ctx context.Context, owner, repo, language string) (*CodeQLDatabase, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/code-scanning/codeql/databases/%v", owner, repo, language)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	codeqlDatabase := new(CodeQLDatabase)
+	resp, err := s.client.Do(ctx, req, codeqlDatabase)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return codeqlDatabase, resp, nil
+}
+
+// DefaultSetupConfiguration represents a code scanning default setup configuration.
+type DefaultSetupConfiguration struct {
+	State      *string    `json:"state,omitempty"`
+	Languages  []string   `json:"languages,omitempty"`
+	QuerySuite *string    `json:"query_suite,omitempty"`
+	UpdatedAt  *Timestamp `json:"updated_at,omitempty"`
+}
+
+// GetDefaultSetupConfiguration gets a code scanning default setup configuration.
+//
+// You must use an access token with the repo scope to use this
+// endpoint with private repos or the public_repo scope for public repos. GitHub Apps must have the repo write
+// permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning/code-scanning#get-a-code-scanning-default-setup-configuration
+//
+//meta:operation GET /repos/{owner}/{repo}/code-scanning/default-setup
+func (s *CodeScanningService) GetDefaultSetupConfiguration(ctx context.Context, owner, repo string) (*DefaultSetupConfiguration, *Response, error) {
+	u := fmt.Sprintf("repos/%s/%s/code-scanning/default-setup", owner, repo)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	cfg := new(DefaultSetupConfiguration)
+	resp, err := s.client.Do(ctx, req, cfg)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return cfg, resp, nil
+}
+
+// UpdateDefaultSetupConfigurationOptions specifies parameters to the CodeScanningService.UpdateDefaultSetupConfiguration
+// method.
+type UpdateDefaultSetupConfigurationOptions struct {
+	State      string   `json:"state"`
+	QuerySuite *string  `json:"query_suite,omitempty"`
+	Languages  []string `json:"languages,omitempty"`
+}
+
+// UpdateDefaultSetupConfigurationResponse represents a response from updating a code scanning default setup configuration.
+type UpdateDefaultSetupConfigurationResponse struct {
+	RunID  *int64  `json:"run_id,omitempty"`
+	RunURL *string `json:"run_url,omitempty"`
+}
+
+// UpdateDefaultSetupConfiguration updates a code scanning default setup configuration.
+//
+// You must use an access token with the repo scope to use this
+// endpoint with private repos or the public_repo scope for public repos. GitHub Apps must have the repo write
+// permission to use this endpoint.
+//
+// This method might return an AcceptedError and a status code of 202. This is because this is the status that GitHub
+// returns to signify that it has now scheduled the update of the pull request branch in a background task.
+//
+// GitHub API docs: https://docs.github.com/rest/code-scanning/code-scanning#update-a-code-scanning-default-setup-configuration
+//
+//meta:operation PATCH /repos/{owner}/{repo}/code-scanning/default-setup
+func (s *CodeScanningService) UpdateDefaultSetupConfiguration(ctx context.Context, owner, repo string, options *UpdateDefaultSetupConfigurationOptions) (*UpdateDefaultSetupConfigurationResponse, *Response, error) {
+	u := fmt.Sprintf("repos/%s/%s/code-scanning/default-setup", owner, repo)
+
+	req, err := s.client.NewRequest("PATCH", u, options)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	a := new(UpdateDefaultSetupConfigurationResponse)
+	resp, err := s.client.Do(ctx, req, a)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return a, resp, nil
+}

vendor/github.com/google/go-github/v69/github/codesofconduct.go

@@ -0,0 +1,87 @@
+// Copyright 2023 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// CodesOfConductService provides access to code-of-conduct-related functions in the GitHub API.
+type CodesOfConductService service
+
+// CodeOfConduct represents a code of conduct.
+type CodeOfConduct struct {
+	Name *string `json:"name,omitempty"`
+	Key  *string `json:"key,omitempty"`
+	URL  *string `json:"url,omitempty"`
+	Body *string `json:"body,omitempty"`
+}
+
+func (c *CodeOfConduct) String() string {
+	return Stringify(c)
+}
+
+// List returns all codes of conduct.
+//
+// GitHub API docs: https://docs.github.com/rest/codes-of-conduct/codes-of-conduct#get-all-codes-of-conduct
+//
+//meta:operation GET /codes_of_conduct
+func (s *CodesOfConductService) List(ctx context.Context) ([]*CodeOfConduct, *Response, error) {
+	req, err := s.client.NewRequest("GET", "codes_of_conduct", nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeCodesOfConductPreview)
+
+	var cs []*CodeOfConduct
+	resp, err := s.client.Do(ctx, req, &cs)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return cs, resp, nil
+}
+
+// ListCodesOfConduct returns all codes of conduct.
+//
+// Deprecated: Use CodesOfConductService.List instead.
+func (c *Client) ListCodesOfConduct(ctx context.Context) ([]*CodeOfConduct, *Response, error) {
+	return c.CodesOfConduct.List(ctx)
+}
+
+// Get returns an individual code of conduct.
+//
+// GitHub API docs: https://docs.github.com/rest/codes-of-conduct/codes-of-conduct#get-a-code-of-conduct
+//
+//meta:operation GET /codes_of_conduct/{key}
+func (s *CodesOfConductService) Get(ctx context.Context, key string) (*CodeOfConduct, *Response, error) {
+	u := fmt.Sprintf("codes_of_conduct/%s", key)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeCodesOfConductPreview)
+
+	coc := new(CodeOfConduct)
+	resp, err := s.client.Do(ctx, req, coc)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return coc, resp, nil
+}
+
+// GetCodeOfConduct returns an individual code of conduct.
+//
+// Deprecated: Use CodesOfConductService.Get instead.
+func (c *Client) GetCodeOfConduct(ctx context.Context, key string) (*CodeOfConduct, *Response, error) {
+	return c.CodesOfConduct.Get(ctx, key)
+}

vendor/github.com/google/go-github/v69/github/codespaces.go

@@ -0,0 +1,266 @@
+// Copyright 2023 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// CodespacesService handles communication with the Codespaces related
+// methods of the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/
+type CodespacesService service
+
+// Codespace represents a codespace.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces
+type Codespace struct {
+	ID                             *int64                        `json:"id,omitempty"`
+	Name                           *string                       `json:"name,omitempty"`
+	DisplayName                    *string                       `json:"display_name,omitempty"`
+	EnvironmentID                  *string                       `json:"environment_id,omitempty"`
+	Owner                          *User                         `json:"owner,omitempty"`
+	BillableOwner                  *User                         `json:"billable_owner,omitempty"`
+	Repository                     *Repository                   `json:"repository,omitempty"`
+	Machine                        *CodespacesMachine            `json:"machine,omitempty"`
+	DevcontainerPath               *string                       `json:"devcontainer_path,omitempty"`
+	Prebuild                       *bool                         `json:"prebuild,omitempty"`
+	CreatedAt                      *Timestamp                    `json:"created_at,omitempty"`
+	UpdatedAt                      *Timestamp                    `json:"updated_at,omitempty"`
+	LastUsedAt                     *Timestamp                    `json:"last_used_at,omitempty"`
+	State                          *string                       `json:"state,omitempty"`
+	URL                            *string                       `json:"url,omitempty"`
+	GitStatus                      *CodespacesGitStatus          `json:"git_status,omitempty"`
+	Location                       *string                       `json:"location,omitempty"`
+	IdleTimeoutMinutes             *int                          `json:"idle_timeout_minutes,omitempty"`
+	WebURL                         *string                       `json:"web_url,omitempty"`
+	MachinesURL                    *string                       `json:"machines_url,omitempty"`
+	StartURL                       *string                       `json:"start_url,omitempty"`
+	StopURL                        *string                       `json:"stop_url,omitempty"`
+	PullsURL                       *string                       `json:"pulls_url,omitempty"`
+	RecentFolders                  []string                      `json:"recent_folders,omitempty"`
+	RuntimeConstraints             *CodespacesRuntimeConstraints `json:"runtime_constraints,omitempty"`
+	PendingOperation               *bool                         `json:"pending_operation,omitempty"`
+	PendingOperationDisabledReason *string                       `json:"pending_operation_disabled_reason,omitempty"`
+	IdleTimeoutNotice              *string                       `json:"idle_timeout_notice,omitempty"`
+	RetentionPeriodMinutes         *int                          `json:"retention_period_minutes,omitempty"`
+	RetentionExpiresAt             *Timestamp                    `json:"retention_expires_at,omitempty"`
+	LastKnownStopNotice            *string                       `json:"last_known_stop_notice,omitempty"`
+}
+
+// CodespacesGitStatus represents the git status of a codespace.
+type CodespacesGitStatus struct {
+	Ahead                 *int    `json:"ahead,omitempty"`
+	Behind                *int    `json:"behind,omitempty"`
+	HasUnpushedChanges    *bool   `json:"has_unpushed_changes,omitempty"`
+	HasUncommittedChanges *bool   `json:"has_uncommitted_changes,omitempty"`
+	Ref                   *string `json:"ref,omitempty"`
+}
+
+// CodespacesMachine represents the machine type of a codespace.
+type CodespacesMachine struct {
+	Name                 *string `json:"name,omitempty"`
+	DisplayName          *string `json:"display_name,omitempty"`
+	OperatingSystem      *string `json:"operating_system,omitempty"`
+	StorageInBytes       *int64  `json:"storage_in_bytes,omitempty"`
+	MemoryInBytes        *int64  `json:"memory_in_bytes,omitempty"`
+	CPUs                 *int    `json:"cpus,omitempty"`
+	PrebuildAvailability *string `json:"prebuild_availability,omitempty"`
+}
+
+// CodespacesRuntimeConstraints represents the runtime constraints of a codespace.
+type CodespacesRuntimeConstraints struct {
+	AllowedPortPrivacySettings []string `json:"allowed_port_privacy_settings,omitempty"`
+}
+
+// ListCodespaces represents the response from the list codespaces endpoints.
+type ListCodespaces struct {
+	TotalCount *int         `json:"total_count,omitempty"`
+	Codespaces []*Codespace `json:"codespaces"`
+}
+
+// ListInRepo lists codespaces for a user in a repository.
+//
+// Lists the codespaces associated with a specified repository and the authenticated user.
+// You must authenticate using an access token with the codespace scope to use this endpoint.
+// GitHub Apps must have read access to the codespaces repository permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/codespaces#list-codespaces-in-a-repository-for-the-authenticated-user
+//
+//meta:operation GET /repos/{owner}/{repo}/codespaces
+func (s *CodespacesService) ListInRepo(ctx context.Context, owner, repo string, opts *ListOptions) (*ListCodespaces, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/codespaces", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var codespaces *ListCodespaces
+	resp, err := s.client.Do(ctx, req, &codespaces)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return codespaces, resp, nil
+}
+
+// ListCodespacesOptions represents the options for listing codespaces for a user.
+type ListCodespacesOptions struct {
+	ListOptions
+	RepositoryID int64 `url:"repository_id,omitempty"`
+}
+
+// List lists codespaces for an authenticated user.
+//
+// Lists the authenticated user's codespaces.
+// You must authenticate using an access token with the codespace scope to use this endpoint.
+// GitHub Apps must have read access to the codespaces repository permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/codespaces#list-codespaces-for-the-authenticated-user
+//
+//meta:operation GET /user/codespaces
+func (s *CodespacesService) List(ctx context.Context, opts *ListCodespacesOptions) (*ListCodespaces, *Response, error) {
+	u := "user/codespaces"
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var codespaces *ListCodespaces
+	resp, err := s.client.Do(ctx, req, &codespaces)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return codespaces, resp, nil
+}
+
+// CreateCodespaceOptions represents options for the creation of a codespace in a repository.
+type CreateCodespaceOptions struct {
+	Ref *string `json:"ref,omitempty"`
+	// Geo represents the geographic area for this codespace.
+	// If not specified, the value is assigned by IP.
+	// This property replaces location, which is being deprecated.
+	// Geo can be one of: `EuropeWest`, `SoutheastAsia`, `UsEast`, `UsWest`.
+	Geo                        *string `json:"geo,omitempty"`
+	ClientIP                   *string `json:"client_ip,omitempty"`
+	Machine                    *string `json:"machine,omitempty"`
+	DevcontainerPath           *string `json:"devcontainer_path,omitempty"`
+	MultiRepoPermissionsOptOut *bool   `json:"multi_repo_permissions_opt_out,omitempty"`
+	WorkingDirectory           *string `json:"working_directory,omitempty"`
+	IdleTimeoutMinutes         *int    `json:"idle_timeout_minutes,omitempty"`
+	DisplayName                *string `json:"display_name,omitempty"`
+	// RetentionPeriodMinutes represents the duration in minutes after codespace has gone idle in which it will be deleted.
+	// Must be integer minutes between 0 and 43200 (30 days).
+	RetentionPeriodMinutes *int `json:"retention_period_minutes,omitempty"`
+}
+
+// CreateInRepo creates a codespace in a repository.
+//
+// Creates a codespace owned by the authenticated user in the specified repository.
+// You must authenticate using an access token with the codespace scope to use this endpoint.
+// GitHub Apps must have write access to the codespaces repository permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/codespaces#create-a-codespace-in-a-repository
+//
+//meta:operation POST /repos/{owner}/{repo}/codespaces
+func (s *CodespacesService) CreateInRepo(ctx context.Context, owner, repo string, request *CreateCodespaceOptions) (*Codespace, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/codespaces", owner, repo)
+
+	req, err := s.client.NewRequest("POST", u, request)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var codespace *Codespace
+	resp, err := s.client.Do(ctx, req, &codespace)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return codespace, resp, nil
+}
+
+// Start starts a codespace.
+//
+// You must authenticate using an access token with the codespace scope to use this endpoint.
+// GitHub Apps must have write access to the codespaces_lifecycle_admin repository permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/codespaces#start-a-codespace-for-the-authenticated-user
+//
+//meta:operation POST /user/codespaces/{codespace_name}/start
+func (s *CodespacesService) Start(ctx context.Context, codespaceName string) (*Codespace, *Response, error) {
+	u := fmt.Sprintf("user/codespaces/%v/start", codespaceName)
+
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var codespace *Codespace
+	resp, err := s.client.Do(ctx, req, &codespace)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return codespace, resp, nil
+}
+
+// Stop stops a codespace.
+//
+// You must authenticate using an access token with the codespace scope to use this endpoint.
+// GitHub Apps must have write access to the codespaces_lifecycle_admin repository permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/codespaces#stop-a-codespace-for-the-authenticated-user
+//
+//meta:operation POST /user/codespaces/{codespace_name}/stop
+func (s *CodespacesService) Stop(ctx context.Context, codespaceName string) (*Codespace, *Response, error) {
+	u := fmt.Sprintf("user/codespaces/%v/stop", codespaceName)
+
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var codespace *Codespace
+	resp, err := s.client.Do(ctx, req, &codespace)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return codespace, resp, nil
+}
+
+// Delete deletes a codespace.
+//
+// You must authenticate using an access token with the codespace scope to use this endpoint.
+// GitHub Apps must have write access to the codespaces repository permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/codespaces#delete-a-codespace-for-the-authenticated-user
+//
+//meta:operation DELETE /user/codespaces/{codespace_name}
+func (s *CodespacesService) Delete(ctx context.Context, codespaceName string) (*Response, error) {
+	u := fmt.Sprintf("user/codespaces/%v", codespaceName)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/codespaces_secrets.go

@@ -0,0 +1,451 @@
+// Copyright 2023 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ListUserSecrets list all secrets available for a users codespace
+//
+// Lists all secrets available for a user's Codespaces without revealing their encrypted values
+// You must authenticate using an access token with the codespace or codespace:secrets scope to use this endpoint. User must have Codespaces access to use this endpoint
+// GitHub Apps must have read access to the codespaces_user_secrets user permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/secrets#list-secrets-for-the-authenticated-user
+//
+//meta:operation GET /user/codespaces/secrets
+func (s *CodespacesService) ListUserSecrets(ctx context.Context, opts *ListOptions) (*Secrets, *Response, error) {
+	u, err := addOptions("user/codespaces/secrets", opts)
+	if err != nil {
+		return nil, nil, err
+	}
+	return s.listSecrets(ctx, u)
+}
+
+// ListOrgSecrets list all secrets available to an org
+//
+// Lists all Codespaces secrets available at the organization-level without revealing their encrypted values. You must authenticate using an access token with the admin:org scope to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/organization-secrets#list-organization-secrets
+//
+//meta:operation GET /orgs/{org}/codespaces/secrets
+func (s *CodespacesService) ListOrgSecrets(ctx context.Context, org string, opts *ListOptions) (*Secrets, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/codespaces/secrets", org)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+	return s.listSecrets(ctx, u)
+}
+
+// ListRepoSecrets list all secrets available to a repo
+//
+// Lists all secrets available in a repository without revealing their encrypted values. You must authenticate using an access token with the repo scope to use this endpoint. GitHub Apps must have write access to the codespaces_secrets repository permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/repository-secrets#list-repository-secrets
+//
+//meta:operation GET /repos/{owner}/{repo}/codespaces/secrets
+func (s *CodespacesService) ListRepoSecrets(ctx context.Context, owner, repo string, opts *ListOptions) (*Secrets, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/codespaces/secrets", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+	return s.listSecrets(ctx, u)
+}
+
+func (s *CodespacesService) listSecrets(ctx context.Context, url string) (*Secrets, *Response, error) {
+	req, err := s.client.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var secrets *Secrets
+	resp, err := s.client.Do(ctx, req, &secrets)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return secrets, resp, nil
+}
+
+// GetUserPublicKey gets the users public key for encrypting codespace secrets
+//
+// Gets your public key, which you need to encrypt secrets. You need to encrypt a secret before you can create or update secrets.
+// You must authenticate using an access token with the codespace or codespace:secrets scope to use this endpoint. User must have Codespaces access to use this endpoint.
+// GitHub Apps must have read access to the codespaces_user_secrets user permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/secrets#get-public-key-for-the-authenticated-user
+//
+//meta:operation GET /user/codespaces/secrets/public-key
+func (s *CodespacesService) GetUserPublicKey(ctx context.Context) (*PublicKey, *Response, error) {
+	return s.getPublicKey(ctx, "user/codespaces/secrets/public-key")
+}
+
+// GetOrgPublicKey gets the org public key for encrypting codespace secrets
+//
+// Gets a public key for an organization, which is required in order to encrypt secrets. You need to encrypt the value of a secret before you can create or update secrets. You must authenticate using an access token with the admin:org scope to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/organization-secrets#get-an-organization-public-key
+//
+//meta:operation GET /orgs/{org}/codespaces/secrets/public-key
+func (s *CodespacesService) GetOrgPublicKey(ctx context.Context, org string) (*PublicKey, *Response, error) {
+	return s.getPublicKey(ctx, fmt.Sprintf("orgs/%v/codespaces/secrets/public-key", org))
+}
+
+// GetRepoPublicKey gets the repo public key for encrypting codespace secrets
+//
+// Gets your public key, which you need to encrypt secrets. You need to encrypt a secret before you can create or update secrets. Anyone with read access to the repository can use this endpoint. If the repository is private you must use an access token with the repo scope. GitHub Apps must have write access to the codespaces_secrets repository permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/repository-secrets#get-a-repository-public-key
+//
+//meta:operation GET /repos/{owner}/{repo}/codespaces/secrets/public-key
+func (s *CodespacesService) GetRepoPublicKey(ctx context.Context, owner, repo string) (*PublicKey, *Response, error) {
+	return s.getPublicKey(ctx, fmt.Sprintf("repos/%v/%v/codespaces/secrets/public-key", owner, repo))
+}
+
+func (s *CodespacesService) getPublicKey(ctx context.Context, url string) (*PublicKey, *Response, error) {
+	req, err := s.client.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var publicKey *PublicKey
+	resp, err := s.client.Do(ctx, req, &publicKey)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return publicKey, resp, nil
+}
+
+// GetUserSecret gets a users codespace secret
+//
+// Gets a secret available to a user's codespaces without revealing its encrypted value.
+// You must authenticate using an access token with the codespace or codespace:secrets scope to use this endpoint. User must have Codespaces access to use this endpoint.
+// GitHub Apps must have read access to the codespaces_user_secrets user permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/secrets#get-a-secret-for-the-authenticated-user
+//
+//meta:operation GET /user/codespaces/secrets/{secret_name}
+func (s *CodespacesService) GetUserSecret(ctx context.Context, name string) (*Secret, *Response, error) {
+	u := fmt.Sprintf("user/codespaces/secrets/%v", name)
+	return s.getSecret(ctx, u)
+}
+
+// GetOrgSecret gets an org codespace secret
+//
+// Gets an organization secret without revealing its encrypted value. You must authenticate using an access token with the admin:org scope to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/organization-secrets#get-an-organization-secret
+//
+//meta:operation GET /orgs/{org}/codespaces/secrets/{secret_name}
+func (s *CodespacesService) GetOrgSecret(ctx context.Context, org, name string) (*Secret, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/codespaces/secrets/%v", org, name)
+	return s.getSecret(ctx, u)
+}
+
+// GetRepoSecret gets a repo codespace secret
+//
+// Gets a single repository secret without revealing its encrypted value. You must authenticate using an access token with the repo scope to use this endpoint. GitHub Apps must have write access to the codespaces_secrets repository permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/repository-secrets#get-a-repository-secret
+//
+//meta:operation GET /repos/{owner}/{repo}/codespaces/secrets/{secret_name}
+func (s *CodespacesService) GetRepoSecret(ctx context.Context, owner, repo, name string) (*Secret, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/codespaces/secrets/%v", owner, repo, name)
+	return s.getSecret(ctx, u)
+}
+
+func (s *CodespacesService) getSecret(ctx context.Context, url string) (*Secret, *Response, error) {
+	req, err := s.client.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var secret *Secret
+	resp, err := s.client.Do(ctx, req, &secret)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return secret, resp, nil
+}
+
+// CreateOrUpdateUserSecret creates or updates a users codespace secret
+//
+// Creates or updates a secret for a user's codespace with an encrypted value. Encrypt your secret using LibSodium.
+// You must authenticate using an access token with the codespace or codespace:secrets scope to use this endpoint. User must also have Codespaces access to use this endpoint.
+// GitHub Apps must have write access to the codespaces_user_secrets user permission and codespaces_secrets repository permission on all referenced repositories to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/secrets#create-or-update-a-secret-for-the-authenticated-user
+//
+//meta:operation PUT /user/codespaces/secrets/{secret_name}
+func (s *CodespacesService) CreateOrUpdateUserSecret(ctx context.Context, eSecret *EncryptedSecret) (*Response, error) {
+	u := fmt.Sprintf("user/codespaces/secrets/%v", eSecret.Name)
+	return s.createOrUpdateSecret(ctx, u, eSecret)
+}
+
+// CreateOrUpdateOrgSecret creates or updates an orgs codespace secret
+//
+// Creates or updates an organization secret with an encrypted value. Encrypt your secret using LibSodium. You must authenticate using an access token with the admin:org scope to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/organization-secrets#create-or-update-an-organization-secret
+//
+//meta:operation PUT /orgs/{org}/codespaces/secrets/{secret_name}
+func (s *CodespacesService) CreateOrUpdateOrgSecret(ctx context.Context, org string, eSecret *EncryptedSecret) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/codespaces/secrets/%v", org, eSecret.Name)
+	return s.createOrUpdateSecret(ctx, u, eSecret)
+}
+
+// CreateOrUpdateRepoSecret creates or updates a repos codespace secret
+//
+// Creates or updates a repository secret with an encrypted value. Encrypt your secret using LibSodium. You must authenticate using an access token with the repo scope to use this endpoint. GitHub Apps must have write access to the codespaces_secrets repository permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/repository-secrets#create-or-update-a-repository-secret
+//
+//meta:operation PUT /repos/{owner}/{repo}/codespaces/secrets/{secret_name}
+func (s *CodespacesService) CreateOrUpdateRepoSecret(ctx context.Context, owner, repo string, eSecret *EncryptedSecret) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/codespaces/secrets/%v", owner, repo, eSecret.Name)
+	return s.createOrUpdateSecret(ctx, u, eSecret)
+}
+
+func (s *CodespacesService) createOrUpdateSecret(ctx context.Context, url string, eSecret *EncryptedSecret) (*Response, error) {
+	req, err := s.client.NewRequest("PUT", url, eSecret)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// DeleteUserSecret deletes a users codespace secret
+//
+// Deletes a secret from a user's codespaces using the secret name. Deleting the secret will remove access from all codespaces that were allowed to access the secret.
+// You must authenticate using an access token with the codespace or codespace:secrets scope to use this endpoint. User must have Codespaces access to use this endpoint.
+// GitHub Apps must have write access to the codespaces_user_secrets user permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/secrets#delete-a-secret-for-the-authenticated-user
+//
+//meta:operation DELETE /user/codespaces/secrets/{secret_name}
+func (s *CodespacesService) DeleteUserSecret(ctx context.Context, name string) (*Response, error) {
+	u := fmt.Sprintf("user/codespaces/secrets/%v", name)
+	return s.deleteSecret(ctx, u)
+}
+
+// DeleteOrgSecret deletes an orgs codespace secret
+//
+// Deletes an organization secret using the secret name. You must authenticate using an access token with the admin:org scope to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/organization-secrets#delete-an-organization-secret
+//
+//meta:operation DELETE /orgs/{org}/codespaces/secrets/{secret_name}
+func (s *CodespacesService) DeleteOrgSecret(ctx context.Context, org, name string) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/codespaces/secrets/%v", org, name)
+	return s.deleteSecret(ctx, u)
+}
+
+// DeleteRepoSecret deletes a repos codespace secret
+//
+// Deletes a secret in a repository using the secret name. You must authenticate using an access token with the repo scope to use this endpoint. GitHub Apps must have write access to the codespaces_secrets repository permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/repository-secrets#delete-a-repository-secret
+//
+//meta:operation DELETE /repos/{owner}/{repo}/codespaces/secrets/{secret_name}
+func (s *CodespacesService) DeleteRepoSecret(ctx context.Context, owner, repo, name string) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/codespaces/secrets/%v", owner, repo, name)
+	return s.deleteSecret(ctx, u)
+}
+
+func (s *CodespacesService) deleteSecret(ctx context.Context, url string) (*Response, error) {
+	req, err := s.client.NewRequest("DELETE", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// ListSelectedReposForUserSecret lists the repositories that have been granted the ability to use a user's codespace secret.
+//
+// You must authenticate using an access token with the codespace or codespace:secrets scope to use this endpoint. User must have Codespaces access to use this endpoint.
+// GitHub Apps must have read access to the codespaces_user_secrets user permission and write access to the codespaces_secrets repository permission on all referenced repositories to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/secrets#list-selected-repositories-for-a-user-secret
+//
+//meta:operation GET /user/codespaces/secrets/{secret_name}/repositories
+func (s *CodespacesService) ListSelectedReposForUserSecret(ctx context.Context, name string, opts *ListOptions) (*SelectedReposList, *Response, error) {
+	u := fmt.Sprintf("user/codespaces/secrets/%v/repositories", name)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return s.listSelectedReposForSecret(ctx, u)
+}
+
+// ListSelectedReposForOrgSecret lists the repositories that have been granted the ability to use an organization's codespace secret.
+//
+// Lists all repositories that have been selected when the visibility for repository access to a secret is set to selected. You must authenticate using an access token with the admin:org scope to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/organization-secrets#list-selected-repositories-for-an-organization-secret
+//
+//meta:operation GET /orgs/{org}/codespaces/secrets/{secret_name}/repositories
+func (s *CodespacesService) ListSelectedReposForOrgSecret(ctx context.Context, org, name string, opts *ListOptions) (*SelectedReposList, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/codespaces/secrets/%v/repositories", org, name)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return s.listSelectedReposForSecret(ctx, u)
+}
+
+func (s *CodespacesService) listSelectedReposForSecret(ctx context.Context, url string) (*SelectedReposList, *Response, error) {
+	req, err := s.client.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var repositories *SelectedReposList
+	resp, err := s.client.Do(ctx, req, &repositories)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return repositories, resp, nil
+}
+
+// SetSelectedReposForUserSecret sets the repositories that have been granted the ability to use a user's codespace secret.
+//
+// You must authenticate using an access token with the codespace or codespace:secrets scope to use this endpoint. User must have Codespaces access to use this endpoint.
+// GitHub Apps must have write access to the codespaces_user_secrets user permission and write access to the codespaces_secrets repository permission on all referenced repositories to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/secrets#set-selected-repositories-for-a-user-secret
+//
+//meta:operation PUT /user/codespaces/secrets/{secret_name}/repositories
+func (s *CodespacesService) SetSelectedReposForUserSecret(ctx context.Context, name string, ids SelectedRepoIDs) (*Response, error) {
+	u := fmt.Sprintf("user/codespaces/secrets/%v/repositories", name)
+	return s.setSelectedRepoForSecret(ctx, u, ids)
+}
+
+// SetSelectedReposForOrgSecret sets the repositories that have been granted the ability to use a user's codespace secret.
+//
+// Replaces all repositories for an organization secret when the visibility for repository access is set to selected. The visibility is set when you Create or update an organization secret. You must authenticate using an access token with the admin:org scope to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/organization-secrets#set-selected-repositories-for-an-organization-secret
+//
+//meta:operation PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories
+func (s *CodespacesService) SetSelectedReposForOrgSecret(ctx context.Context, org, name string, ids SelectedRepoIDs) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/codespaces/secrets/%v/repositories", org, name)
+	return s.setSelectedRepoForSecret(ctx, u, ids)
+}
+
+func (s *CodespacesService) setSelectedRepoForSecret(ctx context.Context, url string, ids SelectedRepoIDs) (*Response, error) {
+	type repoIDs struct {
+		SelectedIDs SelectedRepoIDs `json:"selected_repository_ids"`
+	}
+
+	req, err := s.client.NewRequest("PUT", url, repoIDs{SelectedIDs: ids})
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// AddSelectedRepoToUserSecret adds a repository to the list of repositories that have been granted the ability to use a user's codespace secret.
+//
+// Adds a repository to the selected repositories for a user's codespace secret. You must authenticate using an access token with the codespace or codespace:secrets scope to use this endpoint. User must have Codespaces access to use this endpoint. GitHub Apps must have write access to the codespaces_user_secrets user permission and write access to the codespaces_secrets repository permission on the referenced repository to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/secrets#add-a-selected-repository-to-a-user-secret
+//
+//meta:operation PUT /user/codespaces/secrets/{secret_name}/repositories/{repository_id}
+func (s *CodespacesService) AddSelectedRepoToUserSecret(ctx context.Context, name string, repo *Repository) (*Response, error) {
+	u := fmt.Sprintf("user/codespaces/secrets/%v/repositories/%v", name, *repo.ID)
+	return s.addSelectedRepoToSecret(ctx, u)
+}
+
+// AddSelectedRepoToOrgSecret adds a repository to the list of repositories that have been granted the ability to use an organization's codespace secret.
+//
+// Adds a repository to an organization secret when the visibility for repository access is set to selected. The visibility is set when you Create or update an organization secret. You must authenticate using an access token with the admin:org scope to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/organization-secrets#add-selected-repository-to-an-organization-secret
+//
+//meta:operation PUT /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}
+func (s *CodespacesService) AddSelectedRepoToOrgSecret(ctx context.Context, org, name string, repo *Repository) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/codespaces/secrets/%v/repositories/%v", org, name, *repo.ID)
+	return s.addSelectedRepoToSecret(ctx, u)
+}
+
+func (s *CodespacesService) addSelectedRepoToSecret(ctx context.Context, url string) (*Response, error) {
+	req, err := s.client.NewRequest("PUT", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// RemoveSelectedRepoFromUserSecret removes a repository from the list of repositories that have been granted the ability to use a user's codespace secret.
+//
+// Removes a repository from the selected repositories for a user's codespace secret. You must authenticate using an access token with the codespace or codespace:secrets scope to use this endpoint. User must have Codespaces access to use this endpoint. GitHub Apps must have write access to the codespaces_user_secrets user permission to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/secrets#remove-a-selected-repository-from-a-user-secret
+//
+//meta:operation DELETE /user/codespaces/secrets/{secret_name}/repositories/{repository_id}
+func (s *CodespacesService) RemoveSelectedRepoFromUserSecret(ctx context.Context, name string, repo *Repository) (*Response, error) {
+	u := fmt.Sprintf("user/codespaces/secrets/%v/repositories/%v", name, *repo.ID)
+	return s.removeSelectedRepoFromSecret(ctx, u)
+}
+
+// RemoveSelectedRepoFromOrgSecret removes a repository from the list of repositories that have been granted the ability to use an organization's codespace secret.
+//
+// Removes a repository from an organization secret when the visibility for repository access is set to selected. The visibility is set when you Create or update an organization secret. You must authenticate using an access token with the admin:org scope to use this endpoint.
+//
+// GitHub API docs: https://docs.github.com/rest/codespaces/organization-secrets#remove-selected-repository-from-an-organization-secret
+//
+//meta:operation DELETE /orgs/{org}/codespaces/secrets/{secret_name}/repositories/{repository_id}
+func (s *CodespacesService) RemoveSelectedRepoFromOrgSecret(ctx context.Context, org, name string, repo *Repository) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/codespaces/secrets/%v/repositories/%v", org, name, *repo.ID)
+	return s.removeSelectedRepoFromSecret(ctx, u)
+}
+
+func (s *CodespacesService) removeSelectedRepoFromSecret(ctx context.Context, url string) (*Response, error) {
+	req, err := s.client.NewRequest("DELETE", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}

vendor/github.com/google/go-github/v69/github/copilot.go

@@ -0,0 +1,570 @@
+// Copyright 2023 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+)
+
+// CopilotService provides access to the Copilot-related functions
+// in the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/en/rest/copilot/
+type CopilotService service
+
+// CopilotOrganizationDetails represents the details of an organization's Copilot for Business subscription.
+type CopilotOrganizationDetails struct {
+	SeatBreakdown         *CopilotSeatBreakdown `json:"seat_breakdown"`
+	PublicCodeSuggestions string                `json:"public_code_suggestions"`
+	CopilotChat           string                `json:"copilot_chat"`
+	SeatManagementSetting string                `json:"seat_management_setting"`
+}
+
+// CopilotSeatBreakdown represents the breakdown of Copilot for Business seats for the organization.
+type CopilotSeatBreakdown struct {
+	Total               int `json:"total"`
+	AddedThisCycle      int `json:"added_this_cycle"`
+	PendingCancellation int `json:"pending_cancellation"`
+	PendingInvitation   int `json:"pending_invitation"`
+	ActiveThisCycle     int `json:"active_this_cycle"`
+	InactiveThisCycle   int `json:"inactive_this_cycle"`
+}
+
+// ListCopilotSeatsResponse represents the Copilot for Business seat assignments for an organization.
+type ListCopilotSeatsResponse struct {
+	TotalSeats int64                 `json:"total_seats"`
+	Seats      []*CopilotSeatDetails `json:"seats"`
+}
+
+// CopilotSeatDetails represents the details of a Copilot for Business seat.
+type CopilotSeatDetails struct {
+	// Assignee can either be a User, Team, or Organization.
+	Assignee                interface{} `json:"assignee"`
+	AssigningTeam           *Team       `json:"assigning_team,omitempty"`
+	PendingCancellationDate *string     `json:"pending_cancellation_date,omitempty"`
+	LastActivityAt          *Timestamp  `json:"last_activity_at,omitempty"`
+	LastActivityEditor      *string     `json:"last_activity_editor,omitempty"`
+	CreatedAt               *Timestamp  `json:"created_at"`
+	UpdatedAt               *Timestamp  `json:"updated_at,omitempty"`
+	PlanType                *string     `json:"plan_type,omitempty"`
+}
+
+// SeatAssignments represents the number of seats assigned.
+type SeatAssignments struct {
+	SeatsCreated int `json:"seats_created"`
+}
+
+// SeatCancellations represents the number of seats cancelled.
+type SeatCancellations struct {
+	SeatsCancelled int `json:"seats_cancelled"`
+}
+
+// CopilotMetricsListOptions represents the optional parameters to the CopilotService get metrics methods.
+type CopilotMetricsListOptions struct {
+	Since *time.Time `url:"since,omitempty"`
+	Until *time.Time `url:"until,omitempty"`
+
+	ListOptions
+}
+
+// CopilotIDECodeCompletionsLanguage represents Copilot usage metrics for completions in the IDE for a language.
+type CopilotIDECodeCompletionsLanguage struct {
+	Name              string `json:"name"`
+	TotalEngagedUsers int    `json:"total_engaged_users"`
+}
+
+// CopilotIDECodeCompletionsModelLanguage represents Copilot usage metrics for completions in the IDE for a model and language.
+type CopilotIDECodeCompletionsModelLanguage struct {
+	Name                    string `json:"name"`
+	TotalEngagedUsers       int    `json:"total_engaged_users"`
+	TotalCodeSuggestions    int    `json:"total_code_suggestions"`
+	TotalCodeAcceptances    int    `json:"total_code_acceptances"`
+	TotalCodeLinesSuggested int    `json:"total_code_lines_suggested"`
+	TotalCodeLinesAccepted  int    `json:"total_code_lines_accepted"`
+}
+
+// CopilotIDECodeCompletionsModel represents Copilot usage metrics for completions in the IDE for a model.
+type CopilotIDECodeCompletionsModel struct {
+	Name                    string                                    `json:"name"`
+	IsCustomModel           bool                                      `json:"is_custom_model"`
+	CustomModelTrainingDate *string                                   `json:"custom_model_training_date,omitempty"`
+	TotalEngagedUsers       int                                       `json:"total_engaged_users"`
+	Languages               []*CopilotIDECodeCompletionsModelLanguage `json:"languages"`
+}
+
+// CopilotIDECodeCompletionsEditor represents Copilot usage metrics for completions in the IDE for an editor.
+type CopilotIDECodeCompletionsEditor struct {
+	Name              string                            `json:"name"`
+	TotalEngagedUsers int                               `json:"total_engaged_users"`
+	Models            []*CopilotIDECodeCompletionsModel `json:"models"`
+}
+
+// CopilotIDECodeCompletions represents Copilot usage metrics for Copilot code completions in the IDE, categorized by editor, model and language.
+type CopilotIDECodeCompletions struct {
+	TotalEngagedUsers int                                  `json:"total_engaged_users"`
+	Languages         []*CopilotIDECodeCompletionsLanguage `json:"languages"`
+	Editors           []*CopilotIDECodeCompletionsEditor   `json:"editors"`
+}
+
+// CopilotIDEChatModel represents Copilot usage metrics for chatting with a model in the IDE.
+type CopilotIDEChatModel struct {
+	Name                     string  `json:"name"`
+	IsCustomModel            bool    `json:"is_custom_model"`
+	CustomModelTrainingDate  *string `json:"custom_model_training_date,omitempty"`
+	TotalEngagedUsers        int     `json:"total_engaged_users"`
+	TotalChats               int     `json:"total_chats"`
+	TotalChatInsertionEvents int     `json:"total_chat_insertion_events"`
+	TotalChatCopyEvents      int     `json:"total_chat_copy_events"`
+}
+
+// CopilotIDEChatEditor represents Copilot usage metrics for chatting with a model in the IDE, categorized by editor and model.
+type CopilotIDEChatEditor struct {
+	Name              string                 `json:"name"`
+	TotalEngagedUsers int                    `json:"total_engaged_users"`
+	Models            []*CopilotIDEChatModel `json:"models"`
+}
+
+// CopilotIDEChat represents Copilot usage metrics for Copilot Chat in the IDE, categorized by editor and model.
+type CopilotIDEChat struct {
+	TotalEngagedUsers int                     `json:"total_engaged_users"`
+	Editors           []*CopilotIDEChatEditor `json:"editors"`
+}
+
+// CopilotDotcomChatModel represents Copilot usage metrics for chatting with a model in the webbrowser.
+type CopilotDotcomChatModel struct {
+	Name                    string  `json:"name"`
+	IsCustomModel           bool    `json:"is_custom_model"`
+	CustomModelTrainingDate *string `json:"custom_model_training_date,omitempty"`
+	TotalEngagedUsers       int     `json:"total_engaged_users"`
+	TotalChats              int     `json:"total_chats"`
+}
+
+// CopilotDotcomChat represents Copilot usage metrics for Copilot Chat in the webbrowser, categorized by model.
+type CopilotDotcomChat struct {
+	TotalEngagedUsers int                       `json:"total_engaged_users"`
+	Models            []*CopilotDotcomChatModel `json:"models"`
+}
+
+// CopilotDotcomPullRequestsModel represents Copilot usage metrics for pull requests in the webbrowser, categorized by model.
+type CopilotDotcomPullRequestsModel struct {
+	Name                    string  `json:"name"`
+	IsCustomModel           bool    `json:"is_custom_model"`
+	CustomModelTrainingDate *string `json:"custom_model_training_date,omitempty"`
+	TotalPRSummariesCreated int     `json:"total_pr_summaries_created"`
+	TotalEngagedUsers       int     `json:"total_engaged_users"`
+}
+
+// CopilotDotcomPullRequestsRepository represents Copilot usage metrics for pull requests in the webbrowser, categorized by repository.
+type CopilotDotcomPullRequestsRepository struct {
+	Name              string                            `json:"name"`
+	TotalEngagedUsers int                               `json:"total_engaged_users"`
+	Models            []*CopilotDotcomPullRequestsModel `json:"models"`
+}
+
+// CopilotDotcomPullRequests represents Copilot usage metrics for pull requests in the webbrowser, categorized by repository and model.
+type CopilotDotcomPullRequests struct {
+	TotalEngagedUsers int                                    `json:"total_engaged_users"`
+	Repositories      []*CopilotDotcomPullRequestsRepository `json:"repositories"`
+}
+
+// CopilotMetrics represents Copilot usage metrics for a given day.
+type CopilotMetrics struct {
+	Date                      string                     `json:"date"`
+	TotalActiveUsers          *int                       `json:"total_active_users,omitempty"`
+	TotalEngagedUsers         *int                       `json:"total_engaged_users,omitempty"`
+	CopilotIDECodeCompletions *CopilotIDECodeCompletions `json:"copilot_ide_code_completions,omitempty"`
+	CopilotIDEChat            *CopilotIDEChat            `json:"copilot_ide_chat,omitempty"`
+	CopilotDotcomChat         *CopilotDotcomChat         `json:"copilot_dotcom_chat,omitempty"`
+	CopilotDotcomPullRequests *CopilotDotcomPullRequests `json:"copilot_dotcom_pull_requests,omitempty"`
+}
+
+func (cp *CopilotSeatDetails) UnmarshalJSON(data []byte) error {
+	// Using an alias to avoid infinite recursion when calling json.Unmarshal
+	type alias CopilotSeatDetails
+	var seatDetail alias
+
+	if err := json.Unmarshal(data, &seatDetail); err != nil {
+		return err
+	}
+
+	cp.AssigningTeam = seatDetail.AssigningTeam
+	cp.PendingCancellationDate = seatDetail.PendingCancellationDate
+	cp.LastActivityAt = seatDetail.LastActivityAt
+	cp.LastActivityEditor = seatDetail.LastActivityEditor
+	cp.CreatedAt = seatDetail.CreatedAt
+	cp.UpdatedAt = seatDetail.UpdatedAt
+	cp.PlanType = seatDetail.PlanType
+
+	switch v := seatDetail.Assignee.(type) {
+	case map[string]interface{}:
+		jsonData, err := json.Marshal(seatDetail.Assignee)
+		if err != nil {
+			return err
+		}
+
+		if v["type"] == nil {
+			return errors.New("assignee type field is not set")
+		}
+
+		if t, ok := v["type"].(string); ok && t == "User" {
+			user := &User{}
+			if err := json.Unmarshal(jsonData, user); err != nil {
+				return err
+			}
+			cp.Assignee = user
+		} else if t, ok := v["type"].(string); ok && t == "Team" {
+			team := &Team{}
+			if err := json.Unmarshal(jsonData, team); err != nil {
+				return err
+			}
+			cp.Assignee = team
+		} else if t, ok := v["type"].(string); ok && t == "Organization" {
+			organization := &Organization{}
+			if err := json.Unmarshal(jsonData, organization); err != nil {
+				return err
+			}
+			cp.Assignee = organization
+		} else {
+			return fmt.Errorf("unsupported assignee type %v", v["type"])
+		}
+	default:
+		return fmt.Errorf("unsupported assignee type %T", v)
+	}
+
+	return nil
+}
+
+// GetUser gets the User from the CopilotSeatDetails if the assignee is a user.
+func (cp *CopilotSeatDetails) GetUser() (*User, bool) { u, ok := cp.Assignee.(*User); return u, ok }
+
+// GetTeam gets the Team from the CopilotSeatDetails if the assignee is a team.
+func (cp *CopilotSeatDetails) GetTeam() (*Team, bool) { t, ok := cp.Assignee.(*Team); return t, ok }
+
+// GetOrganization gets the Organization from the CopilotSeatDetails if the assignee is an organization.
+func (cp *CopilotSeatDetails) GetOrganization() (*Organization, bool) {
+	o, ok := cp.Assignee.(*Organization)
+	return o, ok
+}
+
+// GetCopilotBilling gets Copilot for Business billing information and settings for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/copilot/copilot-user-management#get-copilot-seat-information-and-settings-for-an-organization
+//
+//meta:operation GET /orgs/{org}/copilot/billing
+func (s *CopilotService) GetCopilotBilling(ctx context.Context, org string) (*CopilotOrganizationDetails, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/copilot/billing", org)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var copilotDetails *CopilotOrganizationDetails
+	resp, err := s.client.Do(ctx, req, &copilotDetails)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return copilotDetails, resp, nil
+}
+
+// ListCopilotSeats lists Copilot for Business seat assignments for an organization.
+//
+// To paginate through all seats, populate 'Page' with the number of the last page.
+//
+// GitHub API docs: https://docs.github.com/rest/copilot/copilot-user-management#list-all-copilot-seat-assignments-for-an-organization
+//
+//meta:operation GET /orgs/{org}/copilot/billing/seats
+func (s *CopilotService) ListCopilotSeats(ctx context.Context, org string, opts *ListOptions) (*ListCopilotSeatsResponse, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/copilot/billing/seats", org)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var copilotSeats *ListCopilotSeatsResponse
+	resp, err := s.client.Do(ctx, req, &copilotSeats)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return copilotSeats, resp, nil
+}
+
+// ListCopilotEnterpriseSeats lists Copilot for Business seat assignments for an enterprise.
+//
+// To paginate through all seats, populate 'Page' with the number of the last page.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/copilot/copilot-user-management#list-all-copilot-seat-assignments-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/copilot/billing/seats
+func (s *CopilotService) ListCopilotEnterpriseSeats(ctx context.Context, enterprise string, opts *ListOptions) (*ListCopilotSeatsResponse, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/copilot/billing/seats", enterprise)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var copilotSeats *ListCopilotSeatsResponse
+	resp, err := s.client.Do(ctx, req, &copilotSeats)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return copilotSeats, resp, nil
+}
+
+// AddCopilotTeams adds teams to the Copilot for Business subscription for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/copilot/copilot-user-management#add-teams-to-the-copilot-subscription-for-an-organization
+//
+//meta:operation POST /orgs/{org}/copilot/billing/selected_teams
+func (s *CopilotService) AddCopilotTeams(ctx context.Context, org string, teamNames []string) (*SeatAssignments, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/copilot/billing/selected_teams", org)
+
+	body := struct {
+		SelectedTeams []string `json:"selected_teams"`
+	}{
+		SelectedTeams: teamNames,
+	}
+
+	req, err := s.client.NewRequest("POST", u, body)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var seatAssignments *SeatAssignments
+	resp, err := s.client.Do(ctx, req, &seatAssignments)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return seatAssignments, resp, nil
+}
+
+// RemoveCopilotTeams removes teams from the Copilot for Business subscription for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/copilot/copilot-user-management#remove-teams-from-the-copilot-subscription-for-an-organization
+//
+//meta:operation DELETE /orgs/{org}/copilot/billing/selected_teams
+func (s *CopilotService) RemoveCopilotTeams(ctx context.Context, org string, teamNames []string) (*SeatCancellations, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/copilot/billing/selected_teams", org)
+
+	body := struct {
+		SelectedTeams []string `json:"selected_teams"`
+	}{
+		SelectedTeams: teamNames,
+	}
+
+	req, err := s.client.NewRequest("DELETE", u, body)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var seatCancellations *SeatCancellations
+	resp, err := s.client.Do(ctx, req, &seatCancellations)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return seatCancellations, resp, nil
+}
+
+// AddCopilotUsers adds users to the Copilot for Business subscription for an organization
+//
+// GitHub API docs: https://docs.github.com/rest/copilot/copilot-user-management#add-users-to-the-copilot-subscription-for-an-organization
+//
+//meta:operation POST /orgs/{org}/copilot/billing/selected_users
+func (s *CopilotService) AddCopilotUsers(ctx context.Context, org string, users []string) (*SeatAssignments, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/copilot/billing/selected_users", org)
+
+	body := struct {
+		SelectedUsernames []string `json:"selected_usernames"`
+	}{
+		SelectedUsernames: users,
+	}
+
+	req, err := s.client.NewRequest("POST", u, body)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var seatAssignments *SeatAssignments
+	resp, err := s.client.Do(ctx, req, &seatAssignments)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return seatAssignments, resp, nil
+}
+
+// RemoveCopilotUsers removes users from the Copilot for Business subscription for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/copilot/copilot-user-management#remove-users-from-the-copilot-subscription-for-an-organization
+//
+//meta:operation DELETE /orgs/{org}/copilot/billing/selected_users
+func (s *CopilotService) RemoveCopilotUsers(ctx context.Context, org string, users []string) (*SeatCancellations, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/copilot/billing/selected_users", org)
+
+	body := struct {
+		SelectedUsernames []string `json:"selected_usernames"`
+	}{
+		SelectedUsernames: users,
+	}
+
+	req, err := s.client.NewRequest("DELETE", u, body)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var seatCancellations *SeatCancellations
+	resp, err := s.client.Do(ctx, req, &seatCancellations)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return seatCancellations, resp, nil
+}
+
+// GetSeatDetails gets Copilot for Business seat assignment details for a user.
+//
+// GitHub API docs: https://docs.github.com/rest/copilot/copilot-user-management#get-copilot-seat-assignment-details-for-a-user
+//
+//meta:operation GET /orgs/{org}/members/{username}/copilot
+func (s *CopilotService) GetSeatDetails(ctx context.Context, org, user string) (*CopilotSeatDetails, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/members/%v/copilot", org, user)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var seatDetails *CopilotSeatDetails
+	resp, err := s.client.Do(ctx, req, &seatDetails)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return seatDetails, resp, nil
+}
+
+// GetEnterpriseMetrics gets Copilot usage metrics for an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/copilot/copilot-metrics#get-copilot-metrics-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/copilot/metrics
+func (s *CopilotService) GetEnterpriseMetrics(ctx context.Context, enterprise string, opts *CopilotMetricsListOptions) ([]*CopilotMetrics, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/copilot/metrics", enterprise)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var metrics []*CopilotMetrics
+	resp, err := s.client.Do(ctx, req, &metrics)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return metrics, resp, nil
+}
+
+// GetEnterpriseTeamMetrics gets Copilot usage metrics for an enterprise team.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/copilot/copilot-metrics#get-copilot-metrics-for-an-enterprise-team
+//
+//meta:operation GET /enterprises/{enterprise}/team/{team_slug}/copilot/metrics
+func (s *CopilotService) GetEnterpriseTeamMetrics(ctx context.Context, enterprise, team string, opts *CopilotMetricsListOptions) ([]*CopilotMetrics, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/team/%v/copilot/metrics", enterprise, team)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var metrics []*CopilotMetrics
+	resp, err := s.client.Do(ctx, req, &metrics)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return metrics, resp, nil
+}
+
+// GetOrganizationMetrics gets Copilot usage metrics for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/copilot/copilot-metrics#get-copilot-metrics-for-an-organization
+//
+//meta:operation GET /orgs/{org}/copilot/metrics
+func (s *CopilotService) GetOrganizationMetrics(ctx context.Context, org string, opts *CopilotMetricsListOptions) ([]*CopilotMetrics, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/copilot/metrics", org)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var metrics []*CopilotMetrics
+	resp, err := s.client.Do(ctx, req, &metrics)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return metrics, resp, nil
+}
+
+// GetOrganizationTeamMetrics gets Copilot usage metrics for an organization team.
+//
+// GitHub API docs: https://docs.github.com/rest/copilot/copilot-metrics#get-copilot-metrics-for-a-team
+//
+//meta:operation GET /orgs/{org}/team/{team_slug}/copilot/metrics
+func (s *CopilotService) GetOrganizationTeamMetrics(ctx context.Context, org, team string, opts *CopilotMetricsListOptions) ([]*CopilotMetrics, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/team/%v/copilot/metrics", org, team)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var metrics []*CopilotMetrics
+	resp, err := s.client.Do(ctx, req, &metrics)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return metrics, resp, nil
+}

vendor/github.com/google/go-github/v69/github/dependabot.go

@@ -0,0 +1,12 @@
+// Copyright 2022 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+// DependabotService handles communication with the Dependabot related
+// methods of the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/
+type DependabotService service

vendor/github.com/google/go-github/v69/github/dependabot_alerts.go

@@ -0,0 +1,176 @@
+// Copyright 2022 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// Dependency represents the vulnerable dependency.
+type Dependency struct {
+	Package      *VulnerabilityPackage `json:"package,omitempty"`
+	ManifestPath *string               `json:"manifest_path,omitempty"`
+	Scope        *string               `json:"scope,omitempty"`
+}
+
+// AdvisoryCVSS represents the advisory pertaining to the Common Vulnerability Scoring System.
+type AdvisoryCVSS struct {
+	Score        *float64 `json:"score,omitempty"`
+	VectorString *string  `json:"vector_string,omitempty"`
+}
+
+// AdvisoryCWEs represent the advisory pertaining to Common Weakness Enumeration.
+type AdvisoryCWEs struct {
+	CWEID *string `json:"cwe_id,omitempty"`
+	Name  *string `json:"name,omitempty"`
+}
+
+// DependabotSecurityAdvisory represents the GitHub Security Advisory.
+type DependabotSecurityAdvisory struct {
+	GHSAID          *string                  `json:"ghsa_id,omitempty"`
+	CVEID           *string                  `json:"cve_id,omitempty"`
+	Summary         *string                  `json:"summary,omitempty"`
+	Description     *string                  `json:"description,omitempty"`
+	Vulnerabilities []*AdvisoryVulnerability `json:"vulnerabilities,omitempty"`
+	Severity        *string                  `json:"severity,omitempty"`
+	CVSS            *AdvisoryCVSS            `json:"cvss,omitempty"`
+	CWEs            []*AdvisoryCWEs          `json:"cwes,omitempty"`
+	Identifiers     []*AdvisoryIdentifier    `json:"identifiers,omitempty"`
+	References      []*AdvisoryReference     `json:"references,omitempty"`
+	PublishedAt     *Timestamp               `json:"published_at,omitempty"`
+	UpdatedAt       *Timestamp               `json:"updated_at,omitempty"`
+	WithdrawnAt     *Timestamp               `json:"withdrawn_at,omitempty"`
+}
+
+// DependabotAlert represents a Dependabot alert.
+type DependabotAlert struct {
+	Number                *int                        `json:"number,omitempty"`
+	State                 *string                     `json:"state,omitempty"`
+	Dependency            *Dependency                 `json:"dependency,omitempty"`
+	SecurityAdvisory      *DependabotSecurityAdvisory `json:"security_advisory,omitempty"`
+	SecurityVulnerability *AdvisoryVulnerability      `json:"security_vulnerability,omitempty"`
+	URL                   *string                     `json:"url,omitempty"`
+	HTMLURL               *string                     `json:"html_url,omitempty"`
+	CreatedAt             *Timestamp                  `json:"created_at,omitempty"`
+	UpdatedAt             *Timestamp                  `json:"updated_at,omitempty"`
+	DismissedAt           *Timestamp                  `json:"dismissed_at,omitempty"`
+	DismissedBy           *User                       `json:"dismissed_by,omitempty"`
+	DismissedReason       *string                     `json:"dismissed_reason,omitempty"`
+	DismissedComment      *string                     `json:"dismissed_comment,omitempty"`
+	FixedAt               *Timestamp                  `json:"fixed_at,omitempty"`
+	AutoDismissedAt       *Timestamp                  `json:"auto_dismissed_at,omitempty"`
+	// The repository is always empty for events
+	Repository *Repository `json:"repository,omitempty"`
+}
+
+// DependabotAlertState represents the state of a Dependabot alert to update.
+type DependabotAlertState struct {
+	// The state of the Dependabot alert. A dismissed_reason must be provided when setting the state to dismissed.
+	State string `json:"state"`
+	// Required when state is dismissed. A reason for dismissing the alert.
+	// Can be one of: fix_started, inaccurate, no_bandwidth, not_used, tolerable_risk
+	DismissedReason *string `json:"dismissed_reason,omitempty"`
+	// An optional comment associated with dismissing the alert.
+	DismissedComment *string `json:"dismissed_comment,omitempty"`
+}
+
+// ListAlertsOptions specifies the optional parameters to the DependabotService.ListRepoAlerts
+// and DependabotService.ListOrgAlerts methods.
+type ListAlertsOptions struct {
+	State     *string `url:"state,omitempty"`
+	Severity  *string `url:"severity,omitempty"`
+	Ecosystem *string `url:"ecosystem,omitempty"`
+	Package   *string `url:"package,omitempty"`
+	Scope     *string `url:"scope,omitempty"`
+	Sort      *string `url:"sort,omitempty"`
+	Direction *string `url:"direction,omitempty"`
+
+	ListOptions
+	ListCursorOptions
+}
+
+func (s *DependabotService) listAlerts(ctx context.Context, url string, opts *ListAlertsOptions) ([]*DependabotAlert, *Response, error) {
+	u, err := addOptions(url, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var alerts []*DependabotAlert
+	resp, err := s.client.Do(ctx, req, &alerts)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return alerts, resp, nil
+}
+
+// ListRepoAlerts lists all Dependabot alerts of a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/alerts#list-dependabot-alerts-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/dependabot/alerts
+func (s *DependabotService) ListRepoAlerts(ctx context.Context, owner, repo string, opts *ListAlertsOptions) ([]*DependabotAlert, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/dependabot/alerts", owner, repo)
+	return s.listAlerts(ctx, url, opts)
+}
+
+// ListOrgAlerts lists all Dependabot alerts of an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/alerts#list-dependabot-alerts-for-an-organization
+//
+//meta:operation GET /orgs/{org}/dependabot/alerts
+func (s *DependabotService) ListOrgAlerts(ctx context.Context, org string, opts *ListAlertsOptions) ([]*DependabotAlert, *Response, error) {
+	url := fmt.Sprintf("orgs/%v/dependabot/alerts", org)
+	return s.listAlerts(ctx, url, opts)
+}
+
+// GetRepoAlert gets a single repository Dependabot alert.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/alerts#get-a-dependabot-alert
+//
+//meta:operation GET /repos/{owner}/{repo}/dependabot/alerts/{alert_number}
+func (s *DependabotService) GetRepoAlert(ctx context.Context, owner, repo string, number int) (*DependabotAlert, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/dependabot/alerts/%v", owner, repo, number)
+	req, err := s.client.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	alert := new(DependabotAlert)
+	resp, err := s.client.Do(ctx, req, alert)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return alert, resp, nil
+}
+
+// UpdateAlert updates a Dependabot alert.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/alerts#update-a-dependabot-alert
+//
+//meta:operation PATCH /repos/{owner}/{repo}/dependabot/alerts/{alert_number}
+func (s *DependabotService) UpdateAlert(ctx context.Context, owner, repo string, number int, stateInfo *DependabotAlertState) (*DependabotAlert, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/dependabot/alerts/%v", owner, repo, number)
+	req, err := s.client.NewRequest("PATCH", url, stateInfo)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	alert := new(DependabotAlert)
+	resp, err := s.client.Do(ctx, req, alert)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return alert, resp, nil
+}

vendor/github.com/google/go-github/v69/github/dependabot_secrets.go

@@ -0,0 +1,289 @@
+// Copyright 2022 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+func (s *DependabotService) getPublicKey(ctx context.Context, url string) (*PublicKey, *Response, error) {
+	req, err := s.client.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	pubKey := new(PublicKey)
+	resp, err := s.client.Do(ctx, req, pubKey)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return pubKey, resp, nil
+}
+
+// GetRepoPublicKey gets a public key that should be used for Dependabot secret encryption.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/secrets#get-a-repository-public-key
+//
+//meta:operation GET /repos/{owner}/{repo}/dependabot/secrets/public-key
+func (s *DependabotService) GetRepoPublicKey(ctx context.Context, owner, repo string) (*PublicKey, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/dependabot/secrets/public-key", owner, repo)
+	return s.getPublicKey(ctx, url)
+}
+
+// GetOrgPublicKey gets a public key that should be used for Dependabot secret encryption.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/secrets#get-an-organization-public-key
+//
+//meta:operation GET /orgs/{org}/dependabot/secrets/public-key
+func (s *DependabotService) GetOrgPublicKey(ctx context.Context, org string) (*PublicKey, *Response, error) {
+	url := fmt.Sprintf("orgs/%v/dependabot/secrets/public-key", org)
+	return s.getPublicKey(ctx, url)
+}
+
+func (s *DependabotService) listSecrets(ctx context.Context, url string, opts *ListOptions) (*Secrets, *Response, error) {
+	u, err := addOptions(url, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	secrets := new(Secrets)
+	resp, err := s.client.Do(ctx, req, &secrets)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return secrets, resp, nil
+}
+
+// ListRepoSecrets lists all Dependabot secrets available in a repository
+// without revealing their encrypted values.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/secrets#list-repository-secrets
+//
+//meta:operation GET /repos/{owner}/{repo}/dependabot/secrets
+func (s *DependabotService) ListRepoSecrets(ctx context.Context, owner, repo string, opts *ListOptions) (*Secrets, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/dependabot/secrets", owner, repo)
+	return s.listSecrets(ctx, url, opts)
+}
+
+// ListOrgSecrets lists all Dependabot secrets available in an organization
+// without revealing their encrypted values.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/secrets#list-organization-secrets
+//
+//meta:operation GET /orgs/{org}/dependabot/secrets
+func (s *DependabotService) ListOrgSecrets(ctx context.Context, org string, opts *ListOptions) (*Secrets, *Response, error) {
+	url := fmt.Sprintf("orgs/%v/dependabot/secrets", org)
+	return s.listSecrets(ctx, url, opts)
+}
+
+func (s *DependabotService) getSecret(ctx context.Context, url string) (*Secret, *Response, error) {
+	req, err := s.client.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	secret := new(Secret)
+	resp, err := s.client.Do(ctx, req, secret)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return secret, resp, nil
+}
+
+// GetRepoSecret gets a single repository Dependabot secret without revealing its encrypted value.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/secrets#get-a-repository-secret
+//
+//meta:operation GET /repos/{owner}/{repo}/dependabot/secrets/{secret_name}
+func (s *DependabotService) GetRepoSecret(ctx context.Context, owner, repo, name string) (*Secret, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/dependabot/secrets/%v", owner, repo, name)
+	return s.getSecret(ctx, url)
+}
+
+// GetOrgSecret gets a single organization Dependabot secret without revealing its encrypted value.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/secrets#get-an-organization-secret
+//
+//meta:operation GET /orgs/{org}/dependabot/secrets/{secret_name}
+func (s *DependabotService) GetOrgSecret(ctx context.Context, org, name string) (*Secret, *Response, error) {
+	url := fmt.Sprintf("orgs/%v/dependabot/secrets/%v", org, name)
+	return s.getSecret(ctx, url)
+}
+
+// DependabotEncryptedSecret represents a secret that is encrypted using a public key for Dependabot.
+//
+// The value of EncryptedValue must be your secret, encrypted with
+// LibSodium (see documentation here: https://libsodium.gitbook.io/doc/bindings_for_other_languages)
+// using the public key retrieved using the GetPublicKey method.
+type DependabotEncryptedSecret struct {
+	Name                  string                           `json:"-"`
+	KeyID                 string                           `json:"key_id"`
+	EncryptedValue        string                           `json:"encrypted_value"`
+	Visibility            string                           `json:"visibility,omitempty"`
+	SelectedRepositoryIDs DependabotSecretsSelectedRepoIDs `json:"selected_repository_ids,omitempty"`
+}
+
+func (s *DependabotService) putSecret(ctx context.Context, url string, eSecret *DependabotEncryptedSecret) (*Response, error) {
+	req, err := s.client.NewRequest("PUT", url, eSecret)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// CreateOrUpdateRepoSecret creates or updates a repository Dependabot secret with an encrypted value.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/secrets#create-or-update-a-repository-secret
+//
+//meta:operation PUT /repos/{owner}/{repo}/dependabot/secrets/{secret_name}
+func (s *DependabotService) CreateOrUpdateRepoSecret(ctx context.Context, owner, repo string, eSecret *DependabotEncryptedSecret) (*Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/dependabot/secrets/%v", owner, repo, eSecret.Name)
+	return s.putSecret(ctx, url, eSecret)
+}
+
+// CreateOrUpdateOrgSecret creates or updates an organization Dependabot secret with an encrypted value.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/secrets#create-or-update-an-organization-secret
+//
+//meta:operation PUT /orgs/{org}/dependabot/secrets/{secret_name}
+func (s *DependabotService) CreateOrUpdateOrgSecret(ctx context.Context, org string, eSecret *DependabotEncryptedSecret) (*Response, error) {
+	repoIDs := make([]string, len(eSecret.SelectedRepositoryIDs))
+	for i, secret := range eSecret.SelectedRepositoryIDs {
+		repoIDs[i] = fmt.Sprintf("%v", secret)
+	}
+	params := struct {
+		*DependabotEncryptedSecret
+		SelectedRepositoryIDs []string `json:"selected_repository_ids,omitempty"`
+	}{
+		DependabotEncryptedSecret: eSecret,
+		SelectedRepositoryIDs:     repoIDs,
+	}
+
+	url := fmt.Sprintf("orgs/%v/dependabot/secrets/%v", org, eSecret.Name)
+	req, err := s.client.NewRequest("PUT", url, params)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+func (s *DependabotService) deleteSecret(ctx context.Context, url string) (*Response, error) {
+	req, err := s.client.NewRequest("DELETE", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// DeleteRepoSecret deletes a Dependabot secret in a repository using the secret name.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/secrets#delete-a-repository-secret
+//
+//meta:operation DELETE /repos/{owner}/{repo}/dependabot/secrets/{secret_name}
+func (s *DependabotService) DeleteRepoSecret(ctx context.Context, owner, repo, name string) (*Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/dependabot/secrets/%v", owner, repo, name)
+	return s.deleteSecret(ctx, url)
+}
+
+// DeleteOrgSecret deletes a Dependabot secret in an organization using the secret name.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/secrets#delete-an-organization-secret
+//
+//meta:operation DELETE /orgs/{org}/dependabot/secrets/{secret_name}
+func (s *DependabotService) DeleteOrgSecret(ctx context.Context, org, name string) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/dependabot/secrets/%v", org, name)
+	return s.deleteSecret(ctx, url)
+}
+
+// ListSelectedReposForOrgSecret lists all repositories that have access to a Dependabot secret.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/secrets#list-selected-repositories-for-an-organization-secret
+//
+//meta:operation GET /orgs/{org}/dependabot/secrets/{secret_name}/repositories
+func (s *DependabotService) ListSelectedReposForOrgSecret(ctx context.Context, org, name string, opts *ListOptions) (*SelectedReposList, *Response, error) {
+	url := fmt.Sprintf("orgs/%v/dependabot/secrets/%v/repositories", org, name)
+	u, err := addOptions(url, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	result := new(SelectedReposList)
+	resp, err := s.client.Do(ctx, req, result)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return result, resp, nil
+}
+
+// DependabotSecretsSelectedRepoIDs are the repository IDs that have access to the dependabot secrets.
+type DependabotSecretsSelectedRepoIDs []int64
+
+// SetSelectedReposForOrgSecret sets the repositories that have access to a Dependabot secret.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/secrets#set-selected-repositories-for-an-organization-secret
+//
+//meta:operation PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories
+func (s *DependabotService) SetSelectedReposForOrgSecret(ctx context.Context, org, name string, ids DependabotSecretsSelectedRepoIDs) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/dependabot/secrets/%v/repositories", org, name)
+	type repoIDs struct {
+		SelectedIDs DependabotSecretsSelectedRepoIDs `json:"selected_repository_ids"`
+	}
+
+	req, err := s.client.NewRequest("PUT", url, repoIDs{SelectedIDs: ids})
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// AddSelectedRepoToOrgSecret adds a repository to an organization Dependabot secret.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/secrets#add-selected-repository-to-an-organization-secret
+//
+//meta:operation PUT /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}
+func (s *DependabotService) AddSelectedRepoToOrgSecret(ctx context.Context, org, name string, repo *Repository) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/dependabot/secrets/%v/repositories/%v", org, name, *repo.ID)
+	req, err := s.client.NewRequest("PUT", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// RemoveSelectedRepoFromOrgSecret removes a repository from an organization Dependabot secret.
+//
+// GitHub API docs: https://docs.github.com/rest/dependabot/secrets#remove-selected-repository-from-an-organization-secret
+//
+//meta:operation DELETE /orgs/{org}/dependabot/secrets/{secret_name}/repositories/{repository_id}
+func (s *DependabotService) RemoveSelectedRepoFromOrgSecret(ctx context.Context, org, name string, repo *Repository) (*Response, error) {
+	url := fmt.Sprintf("orgs/%v/dependabot/secrets/%v/repositories/%v", org, name, *repo.ID)
+	req, err := s.client.NewRequest("DELETE", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/dependency_graph.go

@@ -0,0 +1,82 @@
+// Copyright 2023 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+type DependencyGraphService service
+
+// SBOM represents a software bill of materials, which describes the
+// packages/libraries that a repository depends on.
+type SBOM struct {
+	SBOM *SBOMInfo `json:"sbom,omitempty"`
+}
+
+// CreationInfo represents when the SBOM was created and who created it.
+type CreationInfo struct {
+	Created  *Timestamp `json:"created,omitempty"`
+	Creators []string   `json:"creators,omitempty"`
+}
+
+// RepoDependencies represents the dependencies of a repo.
+type RepoDependencies struct {
+	SPDXID *string `json:"SPDXID,omitempty"`
+	// Package name
+	Name             *string `json:"name,omitempty"`
+	VersionInfo      *string `json:"versionInfo,omitempty"`
+	DownloadLocation *string `json:"downloadLocation,omitempty"`
+	FilesAnalyzed    *bool   `json:"filesAnalyzed,omitempty"`
+	LicenseConcluded *string `json:"licenseConcluded,omitempty"`
+	LicenseDeclared  *string `json:"licenseDeclared,omitempty"`
+}
+
+// SBOMInfo represents a software bill of materials (SBOM) using SPDX.
+// SPDX is an open standard for SBOMs that
+// identifies and catalogs components, licenses, copyrights, security
+// references, and other metadata relating to software.
+type SBOMInfo struct {
+	SPDXID       *string       `json:"SPDXID,omitempty"`
+	SPDXVersion  *string       `json:"spdxVersion,omitempty"`
+	CreationInfo *CreationInfo `json:"creationInfo,omitempty"`
+
+	// Repo name
+	Name              *string  `json:"name,omitempty"`
+	DataLicense       *string  `json:"dataLicense,omitempty"`
+	DocumentDescribes []string `json:"documentDescribes,omitempty"`
+	DocumentNamespace *string  `json:"documentNamespace,omitempty"`
+
+	// List of packages dependencies
+	Packages []*RepoDependencies `json:"packages,omitempty"`
+}
+
+func (s SBOM) String() string {
+	return Stringify(s)
+}
+
+// GetSBOM fetches the software bill of materials for a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/dependency-graph/sboms#export-a-software-bill-of-materials-sbom-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/dependency-graph/sbom
+func (s *DependencyGraphService) GetSBOM(ctx context.Context, owner, repo string) (*SBOM, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/dependency-graph/sbom", owner, repo)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var sbom *SBOM
+	resp, err := s.client.Do(ctx, req, &sbom)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return sbom, resp, nil
+}

vendor/github.com/google/go-github/v69/github/dependency_graph_snapshots.go

@@ -0,0 +1,113 @@
+// Copyright 2023 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// DependencyGraphSnapshotResolvedDependency represents a resolved dependency in a dependency graph snapshot.
+//
+// GitHub API docs: https://docs.github.com/rest/dependency-graph/dependency-submission#create-a-snapshot-of-dependencies-for-a-repository
+type DependencyGraphSnapshotResolvedDependency struct {
+	PackageURL *string `json:"package_url,omitempty"`
+	// Represents whether the dependency is requested directly by the manifest or is a dependency of another dependency.
+	// Can have the following values:
+	//   - "direct": indicates that the dependency is requested directly by the manifest.
+	//   - "indirect": indicates that the dependency is a dependency of another dependency.
+	Relationship *string `json:"relationship,omitempty"`
+	// Represents whether the dependency is required for the primary build artifact or is only used for development.
+	// Can have the following values:
+	//   - "runtime": indicates that the dependency is required for the primary build artifact.
+	//   - "development": indicates that the dependency is only used for development.
+	Scope        *string  `json:"scope,omitempty"`
+	Dependencies []string `json:"dependencies,omitempty"`
+}
+
+// DependencyGraphSnapshotJob represents the job that created the snapshot.
+//
+// GitHub API docs: https://docs.github.com/rest/dependency-graph/dependency-submission#create-a-snapshot-of-dependencies-for-a-repository
+type DependencyGraphSnapshotJob struct {
+	Correlator *string `json:"correlator,omitempty"`
+	ID         *string `json:"id,omitempty"`
+	HTMLURL    *string `json:"html_url,omitempty"`
+}
+
+// DependencyGraphSnapshotDetector represents a description of the detector used.
+//
+// GitHub API docs: https://docs.github.com/rest/dependency-graph/dependency-submission#create-a-snapshot-of-dependencies-for-a-repository
+type DependencyGraphSnapshotDetector struct {
+	Name    *string `json:"name,omitempty"`
+	Version *string `json:"version,omitempty"`
+	URL     *string `json:"url,omitempty"`
+}
+
+// DependencyGraphSnapshotManifestFile represents the file declaring the repository's dependencies.
+//
+// GitHub API docs: https://docs.github.com/rest/dependency-graph/dependency-submission#create-a-snapshot-of-dependencies-for-a-repository
+type DependencyGraphSnapshotManifestFile struct {
+	SourceLocation *string `json:"source_location,omitempty"`
+}
+
+// DependencyGraphSnapshotManifest represents a collection of related dependencies declared in a file or representing a logical group of dependencies.
+//
+// GitHub API docs: https://docs.github.com/rest/dependency-graph/dependency-submission#create-a-snapshot-of-dependencies-for-a-repository
+type DependencyGraphSnapshotManifest struct {
+	Name     *string                                               `json:"name,omitempty"`
+	File     *DependencyGraphSnapshotManifestFile                  `json:"file,omitempty"`
+	Resolved map[string]*DependencyGraphSnapshotResolvedDependency `json:"resolved,omitempty"`
+}
+
+// DependencyGraphSnapshot represent a snapshot of a repository's dependencies.
+//
+// GitHub API docs: https://docs.github.com/rest/dependency-graph/dependency-submission#create-a-snapshot-of-dependencies-for-a-repository
+type DependencyGraphSnapshot struct {
+	Version   int                                         `json:"version"`
+	Sha       *string                                     `json:"sha,omitempty"`
+	Ref       *string                                     `json:"ref,omitempty"`
+	Job       *DependencyGraphSnapshotJob                 `json:"job,omitempty"`
+	Detector  *DependencyGraphSnapshotDetector            `json:"detector,omitempty"`
+	Scanned   *Timestamp                                  `json:"scanned,omitempty"`
+	Manifests map[string]*DependencyGraphSnapshotManifest `json:"manifests,omitempty"`
+}
+
+// DependencyGraphSnapshotCreationData represents the dependency snapshot's creation result.
+//
+// GitHub API docs: https://docs.github.com/rest/dependency-graph/dependency-submission#create-a-snapshot-of-dependencies-for-a-repository
+type DependencyGraphSnapshotCreationData struct {
+	ID        int64      `json:"id"`
+	CreatedAt *Timestamp `json:"created_at,omitempty"`
+	Message   *string    `json:"message,omitempty"`
+	// Represents the snapshot creation result.
+	// Can have the following values:
+	//   - "SUCCESS": indicates that the snapshot was successfully created and the repository's dependencies were updated.
+	//   - "ACCEPTED": indicates that the snapshot was successfully created, but the repository's dependencies were not updated.
+	//   - "INVALID": indicates that the snapshot was malformed.
+	Result *string `json:"result,omitempty"`
+}
+
+// CreateSnapshot creates a new snapshot of a repository's dependencies.
+//
+// GitHub API docs: https://docs.github.com/rest/dependency-graph/dependency-submission#create-a-snapshot-of-dependencies-for-a-repository
+//
+//meta:operation POST /repos/{owner}/{repo}/dependency-graph/snapshots
+func (s *DependencyGraphService) CreateSnapshot(ctx context.Context, owner, repo string, dependencyGraphSnapshot *DependencyGraphSnapshot) (*DependencyGraphSnapshotCreationData, *Response, error) {
+	url := fmt.Sprintf("repos/%v/%v/dependency-graph/snapshots", owner, repo)
+
+	req, err := s.client.NewRequest("POST", url, dependencyGraphSnapshot)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var snapshotCreationData *DependencyGraphSnapshotCreationData
+	resp, err := s.client.Do(ctx, req, &snapshotCreationData)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return snapshotCreationData, resp, nil
+}

vendor/github.com/google/go-github/v69/github/doc.go

@@ -0,0 +1,200 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Package github provides a client for using the GitHub API.
+
+Usage:
+
+	import "github.com/google/go-github/v69/github"	// with go modules enabled (GO111MODULE=on or outside GOPATH)
+	import "github.com/google/go-github/github"     // with go modules disabled
+
+Construct a new GitHub client, then use the various services on the client to
+access different parts of the GitHub API. For example:
+
+	client := github.NewClient(nil)
+
+	// list all organizations for user "willnorris"
+	orgs, _, err := client.Organizations.List(ctx, "willnorris", nil)
+
+Some API methods have optional parameters that can be passed. For example:
+
+	client := github.NewClient(nil)
+
+	// list public repositories for org "github"
+	opt := &github.RepositoryListByOrgOptions{Type: "public"}
+	repos, _, err := client.Repositories.ListByOrg(ctx, "github", opt)
+
+The services of a client divide the API into logical chunks and correspond to
+the structure of the GitHub API documentation at
+https://docs.github.com/rest .
+
+NOTE: Using the https://pkg.go.dev/context package, one can easily
+pass cancelation signals and deadlines to various services of the client for
+handling a request. In case there is no context available, then context.Background()
+can be used as a starting point.
+
+For more sample code snippets, head over to the https://github.com/google/go-github/tree/master/example directory.
+
+# Authentication
+
+Use Client.WithAuthToken to configure your client to authenticate using an Oauth token
+(for example, a personal access token). This is what is needed for a majority of use cases
+aside from GitHub Apps.
+
+	client := github.NewClient(nil).WithAuthToken("... your access token ...")
+
+Note that when using an authenticated Client, all calls made by the client will
+include the specified OAuth token. Therefore, authenticated clients should
+almost never be shared between different users.
+
+For API methods that require HTTP Basic Authentication, use the
+BasicAuthTransport.
+
+GitHub Apps authentication can be provided by the
+https://github.com/bradleyfalzon/ghinstallation package.
+It supports both authentication as an installation, using an installation access token,
+and as an app, using a JWT.
+
+To authenticate as an installation:
+
+	import "github.com/bradleyfalzon/ghinstallation"
+
+	func main() {
+		// Wrap the shared transport for use with the integration ID 1 authenticating with installation ID 99.
+		itr, err := ghinstallation.NewKeyFromFile(http.DefaultTransport, 1, 99, "2016-10-19.private-key.pem")
+		if err != nil {
+			// Handle error.
+		}
+
+		// Use installation transport with client
+		client := github.NewClient(&http.Client{Transport: itr})
+
+		// Use client...
+	}
+
+To authenticate as an app, using a JWT:
+
+	import "github.com/bradleyfalzon/ghinstallation"
+
+	func main() {
+		// Wrap the shared transport for use with the application ID 1.
+		atr, err := ghinstallation.NewAppsTransportKeyFromFile(http.DefaultTransport, 1, "2016-10-19.private-key.pem")
+		if err != nil {
+			// Handle error.
+		}
+
+		// Use app transport with client
+		client := github.NewClient(&http.Client{Transport: atr})
+
+		// Use client...
+	}
+
+# Rate Limiting
+
+GitHub imposes a rate limit on all API clients. Unauthenticated clients are
+limited to 60 requests per hour, while authenticated clients can make up to
+5,000 requests per hour. The Search API has a custom rate limit. Unauthenticated
+clients are limited to 10 requests per minute, while authenticated clients
+can make up to 30 requests per minute. To receive the higher rate limit when
+making calls that are not issued on behalf of a user,
+use UnauthenticatedRateLimitedTransport.
+
+The returned Response.Rate value contains the rate limit information
+from the most recent API call. If a recent enough response isn't
+available, you can use RateLimits to fetch the most up-to-date rate
+limit data for the client.
+
+To detect an API rate limit error, you can check if its type is *github.RateLimitError.
+For secondary rate limits, you can check if its type is *github.AbuseRateLimitError:
+
+	repos, _, err := client.Repositories.List(ctx, "", nil)
+	if _, ok := err.(*github.RateLimitError); ok {
+		log.Println("hit rate limit")
+	}
+	if _, ok := err.(*github.AbuseRateLimitError); ok {
+		log.Println("hit secondary rate limit")
+	}
+
+Learn more about GitHub rate limiting at
+https://docs.github.com/rest/rate-limit .
+
+# Accepted Status
+
+Some endpoints may return a 202 Accepted status code, meaning that the
+information required is not yet ready and was scheduled to be gathered on
+the GitHub side. Methods known to behave like this are documented specifying
+this behavior.
+
+To detect this condition of error, you can check if its type is
+*github.AcceptedError:
+
+	stats, _, err := client.Repositories.ListContributorsStats(ctx, org, repo)
+	if _, ok := err.(*github.AcceptedError); ok {
+		log.Println("scheduled on GitHub side")
+	}
+
+# Conditional Requests
+
+The GitHub REST API has good support for conditional HTTP requests
+via the ETag header which will help prevent you from burning through your
+rate limit, as well as help speed up your application. go-github does not
+handle conditional requests directly, but is instead designed to work with a
+caching http.Transport.
+
+Typically, an RFC 7234 compliant HTTP cache such as https://github.com/gregjones/httpcache
+is recommended. Alternatively, the https://github.com/bored-engineer/github-conditional-http-transport
+package relies on (undocumented) GitHub specific cache logic and is
+recommended when making requests using short-lived credentials such as a
+GitHub App installation token.
+
+Learn more about GitHub conditional requests at
+https://docs.github.com/rest/overview/resources-in-the-rest-api#conditional-requests.
+
+# Creating and Updating Resources
+
+All structs for GitHub resources use pointer values for all non-repeated fields.
+This allows distinguishing between unset fields and those set to a zero-value.
+Helper functions have been provided to easily create these pointers for string,
+bool, and int values. For example:
+
+	// create a new private repository named "foo"
+	repo := &github.Repository{
+		Name:    github.Ptr("foo"),
+		Private: github.Ptr(true),
+	}
+	client.Repositories.Create(ctx, "", repo)
+
+Users who have worked with protocol buffers should find this pattern familiar.
+
+# Pagination
+
+All requests for resource collections (repos, pull requests, issues, etc.)
+support pagination. Pagination options are described in the
+github.ListOptions struct and passed to the list methods directly or as an
+embedded type of a more specific list options struct (for example
+github.PullRequestListOptions). Pages information is available via the
+github.Response struct.
+
+	client := github.NewClient(nil)
+
+	opt := &github.RepositoryListByOrgOptions{
+		ListOptions: github.ListOptions{PerPage: 10},
+	}
+	// get all pages of results
+	var allRepos []*github.Repository
+	for {
+		repos, resp, err := client.Repositories.ListByOrg(ctx, "github", opt)
+		if err != nil {
+			return err
+		}
+		allRepos = append(allRepos, repos...)
+		if resp.NextPage == 0 {
+			break
+		}
+		opt.Page = resp.NextPage
+	}
+*/
+package github

vendor/github.com/google/go-github/v69/github/emojis.go

@@ -0,0 +1,40 @@
+// Copyright 2023 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+)
+
+// EmojisService provides access to emoji-related functions in the GitHub API.
+type EmojisService service
+
+// List returns the emojis available to use on GitHub.
+//
+// GitHub API docs: https://docs.github.com/rest/emojis/emojis#get-emojis
+//
+//meta:operation GET /emojis
+func (s *EmojisService) List(ctx context.Context) (map[string]string, *Response, error) {
+	req, err := s.client.NewRequest("GET", "emojis", nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var emoji map[string]string
+	resp, err := s.client.Do(ctx, req, &emoji)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return emoji, resp, nil
+}
+
+// ListEmojis returns the emojis available to use on GitHub.
+//
+// Deprecated: Use EmojisService.List instead.
+func (c *Client) ListEmojis(ctx context.Context) (map[string]string, *Response, error) {
+	return c.Emojis.List(ctx)
+}

vendor/github.com/google/go-github/v69/github/enterprise.go

@@ -0,0 +1,12 @@
+// Copyright 2020 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+// EnterpriseService provides access to the enterprise related functions
+// in the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/enterprise-admin/
+type EnterpriseService service

vendor/github.com/google/go-github/v69/github/enterprise_actions_runner_groups.go

@@ -0,0 +1,336 @@
+// Copyright 2023 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ListOrganizations represents the response from the list orgs endpoints.
+type ListOrganizations struct {
+	TotalCount    *int            `json:"total_count,omitempty"`
+	Organizations []*Organization `json:"organizations"`
+}
+
+// EnterpriseRunnerGroup represents a self-hosted runner group configured in an enterprise.
+type EnterpriseRunnerGroup struct {
+	ID                           *int64   `json:"id,omitempty"`
+	Name                         *string  `json:"name,omitempty"`
+	Visibility                   *string  `json:"visibility,omitempty"`
+	Default                      *bool    `json:"default,omitempty"`
+	SelectedOrganizationsURL     *string  `json:"selected_organizations_url,omitempty"`
+	RunnersURL                   *string  `json:"runners_url,omitempty"`
+	Inherited                    *bool    `json:"inherited,omitempty"`
+	AllowsPublicRepositories     *bool    `json:"allows_public_repositories,omitempty"`
+	RestrictedToWorkflows        *bool    `json:"restricted_to_workflows,omitempty"`
+	SelectedWorkflows            []string `json:"selected_workflows,omitempty"`
+	WorkflowRestrictionsReadOnly *bool    `json:"workflow_restrictions_read_only,omitempty"`
+}
+
+// EnterpriseRunnerGroups represents a collection of self-hosted runner groups configured for an enterprise.
+type EnterpriseRunnerGroups struct {
+	TotalCount   *int                     `json:"total_count,omitempty"`
+	RunnerGroups []*EnterpriseRunnerGroup `json:"runner_groups"`
+}
+
+// CreateEnterpriseRunnerGroupRequest represents a request to create a Runner group for an enterprise.
+type CreateEnterpriseRunnerGroupRequest struct {
+	Name       *string `json:"name,omitempty"`
+	Visibility *string `json:"visibility,omitempty"`
+	// List of organization IDs that can access the runner group.
+	SelectedOrganizationIDs []int64 `json:"selected_organization_ids,omitempty"`
+	// Runners represent a list of runner IDs to add to the runner group.
+	Runners []int64 `json:"runners,omitempty"`
+	// If set to True, public repos can use this runner group
+	AllowsPublicRepositories *bool `json:"allows_public_repositories,omitempty"`
+	// If true, the runner group will be restricted to running only the workflows specified in the SelectedWorkflows slice.
+	RestrictedToWorkflows *bool `json:"restricted_to_workflows,omitempty"`
+	// List of workflows the runner group should be allowed to run. This setting will be ignored unless RestrictedToWorkflows is set to true.
+	SelectedWorkflows []string `json:"selected_workflows,omitempty"`
+}
+
+// UpdateEnterpriseRunnerGroupRequest represents a request to update a Runner group for an enterprise.
+type UpdateEnterpriseRunnerGroupRequest struct {
+	Name                     *string  `json:"name,omitempty"`
+	Visibility               *string  `json:"visibility,omitempty"`
+	AllowsPublicRepositories *bool    `json:"allows_public_repositories,omitempty"`
+	RestrictedToWorkflows    *bool    `json:"restricted_to_workflows,omitempty"`
+	SelectedWorkflows        []string `json:"selected_workflows,omitempty"`
+}
+
+// SetOrgAccessRunnerGroupRequest represents a request to replace the list of organizations
+// that can access a self-hosted runner group configured in an enterprise.
+type SetOrgAccessRunnerGroupRequest struct {
+	// Updated list of organization IDs that should be given access to the runner group.
+	SelectedOrganizationIDs []int64 `json:"selected_organization_ids"`
+}
+
+// ListEnterpriseRunnerGroupOptions extend ListOptions to have the optional parameters VisibleToOrganization.
+type ListEnterpriseRunnerGroupOptions struct {
+	ListOptions
+
+	// Only return runner groups that are allowed to be used by this organization.
+	VisibleToOrganization string `url:"visible_to_organization,omitempty"`
+}
+
+// ListRunnerGroups lists all self-hosted runner groups configured in an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runner-groups#list-self-hosted-runner-groups-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/actions/runner-groups
+func (s *EnterpriseService) ListRunnerGroups(ctx context.Context, enterprise string, opts *ListEnterpriseRunnerGroupOptions) (*EnterpriseRunnerGroups, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runner-groups", enterprise)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	groups := &EnterpriseRunnerGroups{}
+	resp, err := s.client.Do(ctx, req, &groups)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return groups, resp, nil
+}
+
+// GetEnterpriseRunnerGroup gets a specific self-hosted runner group for an enterprise using its RunnerGroup ID.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runner-groups#get-a-self-hosted-runner-group-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}
+func (s *EnterpriseService) GetEnterpriseRunnerGroup(ctx context.Context, enterprise string, groupID int64) (*EnterpriseRunnerGroup, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runner-groups/%v", enterprise, groupID)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runnerGroup := new(EnterpriseRunnerGroup)
+	resp, err := s.client.Do(ctx, req, runnerGroup)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return runnerGroup, resp, nil
+}
+
+// DeleteEnterpriseRunnerGroup deletes a self-hosted runner group from an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runner-groups#delete-a-self-hosted-runner-group-from-an-enterprise
+//
+//meta:operation DELETE /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}
+func (s *EnterpriseService) DeleteEnterpriseRunnerGroup(ctx context.Context, enterprise string, groupID int64) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runner-groups/%v", enterprise, groupID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// CreateEnterpriseRunnerGroup creates a new self-hosted runner group for an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runner-groups#create-a-self-hosted-runner-group-for-an-enterprise
+//
+//meta:operation POST /enterprises/{enterprise}/actions/runner-groups
+func (s *EnterpriseService) CreateEnterpriseRunnerGroup(ctx context.Context, enterprise string, createReq CreateEnterpriseRunnerGroupRequest) (*EnterpriseRunnerGroup, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runner-groups", enterprise)
+	req, err := s.client.NewRequest("POST", u, createReq)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runnerGroup := new(EnterpriseRunnerGroup)
+	resp, err := s.client.Do(ctx, req, runnerGroup)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return runnerGroup, resp, nil
+}
+
+// UpdateEnterpriseRunnerGroup updates a self-hosted runner group for an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runner-groups#update-a-self-hosted-runner-group-for-an-enterprise
+//
+//meta:operation PATCH /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}
+func (s *EnterpriseService) UpdateEnterpriseRunnerGroup(ctx context.Context, enterprise string, groupID int64, updateReq UpdateEnterpriseRunnerGroupRequest) (*EnterpriseRunnerGroup, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runner-groups/%v", enterprise, groupID)
+	req, err := s.client.NewRequest("PATCH", u, updateReq)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runnerGroup := new(EnterpriseRunnerGroup)
+	resp, err := s.client.Do(ctx, req, runnerGroup)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return runnerGroup, resp, nil
+}
+
+// ListOrganizationAccessRunnerGroup lists the organizations with access to a self-hosted runner group configured in an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runner-groups#list-organization-access-to-a-self-hosted-runner-group-in-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}/organizations
+func (s *EnterpriseService) ListOrganizationAccessRunnerGroup(ctx context.Context, enterprise string, groupID int64, opts *ListOptions) (*ListOrganizations, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runner-groups/%v/organizations", enterprise, groupID)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	orgs := &ListOrganizations{}
+	resp, err := s.client.Do(ctx, req, &orgs)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return orgs, resp, nil
+}
+
+// SetOrganizationAccessRunnerGroup replaces the list of organizations that have access to a self-hosted runner group configured in an enterprise
+// with a new List of organizations.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runner-groups#set-organization-access-for-a-self-hosted-runner-group-in-an-enterprise
+//
+//meta:operation PUT /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}/organizations
+func (s *EnterpriseService) SetOrganizationAccessRunnerGroup(ctx context.Context, enterprise string, groupID int64, ids SetOrgAccessRunnerGroupRequest) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runner-groups/%v/organizations", enterprise, groupID)
+
+	req, err := s.client.NewRequest("PUT", u, ids)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// AddOrganizationAccessRunnerGroup adds an organization to the list of selected organizations that can access a self-hosted runner group.
+// The runner group must have visibility set to 'selected'.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runner-groups#add-organization-access-to-a-self-hosted-runner-group-in-an-enterprise
+//
+//meta:operation PUT /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}/organizations/{org_id}
+func (s *EnterpriseService) AddOrganizationAccessRunnerGroup(ctx context.Context, enterprise string, groupID, orgID int64) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runner-groups/%v/organizations/%v", enterprise, groupID, orgID)
+
+	req, err := s.client.NewRequest("PUT", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// RemoveOrganizationAccessRunnerGroup removes an organization from the list of selected organizations that can access a self-hosted runner group.
+// The runner group must have visibility set to 'selected'.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runner-groups#remove-organization-access-to-a-self-hosted-runner-group-in-an-enterprise
+//
+//meta:operation DELETE /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}/organizations/{org_id}
+func (s *EnterpriseService) RemoveOrganizationAccessRunnerGroup(ctx context.Context, enterprise string, groupID, orgID int64) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runner-groups/%v/organizations/%v", enterprise, groupID, orgID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// ListRunnerGroupRunners lists self-hosted runners that are in a specific enterprise group.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runner-groups#list-self-hosted-runners-in-a-group-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}/runners
+func (s *EnterpriseService) ListRunnerGroupRunners(ctx context.Context, enterprise string, groupID int64, opts *ListOptions) (*Runners, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runner-groups/%v/runners", enterprise, groupID)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runners := &Runners{}
+	resp, err := s.client.Do(ctx, req, &runners)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return runners, resp, nil
+}
+
+// SetRunnerGroupRunners replaces the list of self-hosted runners that are part of an enterprise runner group
+// with a new list of runners.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runner-groups#set-self-hosted-runners-in-a-group-for-an-enterprise
+//
+//meta:operation PUT /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}/runners
+func (s *EnterpriseService) SetRunnerGroupRunners(ctx context.Context, enterprise string, groupID int64, ids SetRunnerGroupRunnersRequest) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runner-groups/%v/runners", enterprise, groupID)
+
+	req, err := s.client.NewRequest("PUT", u, ids)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// AddRunnerGroupRunners adds a self-hosted runner to a runner group configured in an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runner-groups#add-a-self-hosted-runner-to-a-group-for-an-enterprise
+//
+//meta:operation PUT /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}/runners/{runner_id}
+func (s *EnterpriseService) AddRunnerGroupRunners(ctx context.Context, enterprise string, groupID, runnerID int64) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runner-groups/%v/runners/%v", enterprise, groupID, runnerID)
+
+	req, err := s.client.NewRequest("PUT", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// RemoveRunnerGroupRunners removes a self-hosted runner from a group configured in an enterprise.
+// The runner is then returned to the default group.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runner-groups#remove-a-self-hosted-runner-from-a-group-for-an-enterprise
+//
+//meta:operation DELETE /enterprises/{enterprise}/actions/runner-groups/{runner_group_id}/runners/{runner_id}
+func (s *EnterpriseService) RemoveRunnerGroupRunners(ctx context.Context, enterprise string, groupID, runnerID int64) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runner-groups/%v/runners/%v", enterprise, groupID, runnerID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/enterprise_actions_runners.go

@@ -0,0 +1,139 @@
+// Copyright 2020 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ListRunnerApplicationDownloads lists self-hosted runner application binaries that can be downloaded and run.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runners#list-runner-applications-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/actions/runners/downloads
+func (s *EnterpriseService) ListRunnerApplicationDownloads(ctx context.Context, enterprise string) ([]*RunnerApplicationDownload, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runners/downloads", enterprise)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var rads []*RunnerApplicationDownload
+	resp, err := s.client.Do(ctx, req, &rads)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return rads, resp, nil
+}
+
+// GenerateEnterpriseJITConfig generates a just-in-time configuration for an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runners#create-configuration-for-a-just-in-time-runner-for-an-enterprise
+//
+//meta:operation POST /enterprises/{enterprise}/actions/runners/generate-jitconfig
+func (s *EnterpriseService) GenerateEnterpriseJITConfig(ctx context.Context, enterprise string, request *GenerateJITConfigRequest) (*JITRunnerConfig, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runners/generate-jitconfig", enterprise)
+
+	req, err := s.client.NewRequest("POST", u, request)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	jitConfig := new(JITRunnerConfig)
+	resp, err := s.client.Do(ctx, req, jitConfig)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return jitConfig, resp, nil
+}
+
+// CreateRegistrationToken creates a token that can be used to add a self-hosted runner.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runners#create-a-registration-token-for-an-enterprise
+//
+//meta:operation POST /enterprises/{enterprise}/actions/runners/registration-token
+func (s *EnterpriseService) CreateRegistrationToken(ctx context.Context, enterprise string) (*RegistrationToken, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runners/registration-token", enterprise)
+
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	registrationToken := new(RegistrationToken)
+	resp, err := s.client.Do(ctx, req, registrationToken)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return registrationToken, resp, nil
+}
+
+// ListRunners lists all the self-hosted runners for a enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runners#list-self-hosted-runners-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/actions/runners
+func (s *EnterpriseService) ListRunners(ctx context.Context, enterprise string, opts *ListRunnersOptions) (*Runners, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runners", enterprise)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runners := &Runners{}
+	resp, err := s.client.Do(ctx, req, &runners)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return runners, resp, nil
+}
+
+// GetRunner gets a specific self-hosted runner configured in an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runners#get-a-self-hosted-runner-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/actions/runners/{runner_id}
+func (s *EnterpriseService) GetRunner(ctx context.Context, enterprise string, runnerID int64) (*Runner, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runners/%v", enterprise, runnerID)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	runner := new(Runner)
+	resp, err := s.client.Do(ctx, req, runner)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return runner, resp, nil
+}
+
+// RemoveRunner forces the removal of a self-hosted runner from an enterprise using the runner id.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/self-hosted-runners#delete-a-self-hosted-runner-from-an-enterprise
+//
+//meta:operation DELETE /enterprises/{enterprise}/actions/runners/{runner_id}
+func (s *EnterpriseService) RemoveRunner(ctx context.Context, enterprise string, runnerID int64) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/runners/%v", enterprise, runnerID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/enterprise_audit_log.go

@@ -0,0 +1,37 @@
+// Copyright 2021 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// GetAuditLog gets the audit-log entries for an organization.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/audit-log#get-the-audit-log-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/audit-log
+func (s *EnterpriseService) GetAuditLog(ctx context.Context, enterprise string, opts *GetAuditLogOptions) ([]*AuditEntry, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/audit-log", enterprise)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var auditEntries []*AuditEntry
+	resp, err := s.client.Do(ctx, req, &auditEntries)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return auditEntries, resp, nil
+}

vendor/github.com/google/go-github/v69/github/enterprise_code_security_and_analysis.go

@@ -0,0 +1,85 @@
+// Copyright 2022 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// EnterpriseSecurityAnalysisSettings represents security analysis settings for an enterprise.
+type EnterpriseSecurityAnalysisSettings struct {
+	AdvancedSecurityEnabledForNewRepositories             *bool   `json:"advanced_security_enabled_for_new_repositories,omitempty"`
+	SecretScanningEnabledForNewRepositories               *bool   `json:"secret_scanning_enabled_for_new_repositories,omitempty"`
+	SecretScanningPushProtectionEnabledForNewRepositories *bool   `json:"secret_scanning_push_protection_enabled_for_new_repositories,omitempty"`
+	SecretScanningPushProtectionCustomLink                *string `json:"secret_scanning_push_protection_custom_link,omitempty"`
+	SecretScanningValidityChecksEnabled                   *bool   `json:"secret_scanning_validity_checks_enabled,omitempty"`
+}
+
+// GetCodeSecurityAndAnalysis gets code security and analysis features for an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/code-security-and-analysis#get-code-security-and-analysis-features-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/code_security_and_analysis
+func (s *EnterpriseService) GetCodeSecurityAndAnalysis(ctx context.Context, enterprise string) (*EnterpriseSecurityAnalysisSettings, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/code_security_and_analysis", enterprise)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	settings := new(EnterpriseSecurityAnalysisSettings)
+	resp, err := s.client.Do(ctx, req, settings)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return settings, resp, nil
+}
+
+// UpdateCodeSecurityAndAnalysis updates code security and analysis features for new repositories in an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/code-security-and-analysis#update-code-security-and-analysis-features-for-an-enterprise
+//
+//meta:operation PATCH /enterprises/{enterprise}/code_security_and_analysis
+func (s *EnterpriseService) UpdateCodeSecurityAndAnalysis(ctx context.Context, enterprise string, settings *EnterpriseSecurityAnalysisSettings) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/code_security_and_analysis", enterprise)
+	req, err := s.client.NewRequest("PATCH", u, settings)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// EnableDisableSecurityFeature enables or disables a security feature for all repositories in an enterprise.
+//
+// Valid values for securityProduct: "advanced_security", "secret_scanning", "secret_scanning_push_protection".
+// Valid values for enablement:  "enable_all", "disable_all".
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/code-security-and-analysis#enable-or-disable-a-security-feature
+//
+//meta:operation POST /enterprises/{enterprise}/{security_product}/{enablement}
+func (s *EnterpriseService) EnableDisableSecurityFeature(ctx context.Context, enterprise, securityProduct, enablement string) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/%v/%v", enterprise, securityProduct, enablement)
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}

vendor/github.com/google/go-github/v69/github/enterprise_manage_ghes.go

@@ -0,0 +1,163 @@
+// Copyright 2025 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+)
+
+// NodeQueryOptions specifies the optional parameters to the EnterpriseService
+// Node management APIs.
+type NodeQueryOptions struct {
+	// UUID filters issues based on the node UUID.
+	UUID *string `url:"uuid,omitempty"`
+
+	// ClusterRoles filters the cluster roles from the cluster configuration file.
+	ClusterRoles *string `url:"cluster_roles,omitempty"`
+}
+
+// ClusterStatus represents a response from the ClusterStatus and ReplicationStatus methods.
+type ClusterStatus struct {
+	Status *string              `json:"status,omitempty"`
+	Nodes  []*ClusterStatusNode `json:"nodes"`
+}
+
+// ClusterStatusNode represents the status of a cluster node.
+type ClusterStatusNode struct {
+	Hostname *string                         `json:"hostname,omitempty"`
+	Status   *string                         `json:"status,omitempty"`
+	Services []*ClusterStatusNodeServiceItem `json:"services"`
+}
+
+// ClusterStatusNodeServiceItem represents the status of a service running on a cluster node.
+type ClusterStatusNodeServiceItem struct {
+	Status  *string `json:"status,omitempty"`
+	Name    *string `json:"name,omitempty"`
+	Details *string `json:"details,omitempty"`
+}
+
+// SystemRequirements represents a response from the CheckSystemRequirements method.
+type SystemRequirements struct {
+	Status *string                   `json:"status,omitempty"`
+	Nodes  []*SystemRequirementsNode `json:"nodes"`
+}
+
+// SystemRequirementsNode represents the status of a system node.
+type SystemRequirementsNode struct {
+	Hostname    *string                             `json:"hostname,omitempty"`
+	Status      *string                             `json:"status,omitempty"`
+	RolesStatus []*SystemRequirementsNodeRoleStatus `json:"roles_status"`
+}
+
+// SystemRequirementsNodeRoleStatus represents the status of a role on a system node.
+type SystemRequirementsNodeRoleStatus struct {
+	Status *string `json:"status,omitempty"`
+	Role   *string `json:"role,omitempty"`
+}
+
+// NodeReleaseVersion represents a response from the GetNodeReleaseVersions method.
+type NodeReleaseVersion struct {
+	Hostname *string         `json:"hostname,omitempty"`
+	Version  *ReleaseVersion `json:"version"`
+}
+
+// ReleaseVersion holds the release version information of the node.
+type ReleaseVersion struct {
+	Version   *string `json:"version,omitempty"`
+	Platform  *string `json:"platform,omitempty"`
+	BuildID   *string `json:"build_id,omitempty"`
+	BuildDate *string `json:"build_date,omitempty"`
+}
+
+// CheckSystemRequirements checks if GHES system nodes meet the system requirements.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#get-the-system-requirement-check-results-for-configured-cluster-nodes
+//
+//meta:operation GET /manage/v1/checks/system-requirements
+func (s *EnterpriseService) CheckSystemRequirements(ctx context.Context) (*SystemRequirements, *Response, error) {
+	u := "manage/v1/checks/system-requirements"
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	systemRequirements := new(SystemRequirements)
+	resp, err := s.client.Do(ctx, req, systemRequirements)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return systemRequirements, resp, nil
+}
+
+// ClusterStatus gets the status of all services running on each cluster node.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#get-the-status-of-services-running-on-all-cluster-nodes
+//
+//meta:operation GET /manage/v1/cluster/status
+func (s *EnterpriseService) ClusterStatus(ctx context.Context) (*ClusterStatus, *Response, error) {
+	u := "manage/v1/cluster/status"
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	clusterStatus := new(ClusterStatus)
+	resp, err := s.client.Do(ctx, req, clusterStatus)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return clusterStatus, resp, nil
+}
+
+// ReplicationStatus gets the status of all services running on each replica node.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#get-the-status-of-services-running-on-all-replica-nodes
+//
+//meta:operation GET /manage/v1/replication/status
+func (s *EnterpriseService) ReplicationStatus(ctx context.Context, opts *NodeQueryOptions) (*ClusterStatus, *Response, error) {
+	u, err := addOptions("manage/v1/replication/status", opts)
+	if err != nil {
+		return nil, nil, err
+	}
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	status := new(ClusterStatus)
+	resp, err := s.client.Do(ctx, req, status)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return status, resp, nil
+}
+
+// GetNodeReleaseVersions gets the version information deployed to each node.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#get-all-ghes-release-versions-for-all-nodes
+//
+//meta:operation GET /manage/v1/version
+func (s *EnterpriseService) GetNodeReleaseVersions(ctx context.Context, opts *NodeQueryOptions) ([]*NodeReleaseVersion, *Response, error) {
+	u, err := addOptions("manage/v1/version", opts)
+	if err != nil {
+		return nil, nil, err
+	}
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var releaseVersions []*NodeReleaseVersion
+	resp, err := s.client.Do(ctx, req, &releaseVersions)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return releaseVersions, resp, nil
+}

vendor/github.com/google/go-github/v69/github/enterprise_manage_ghes_config.go

@@ -0,0 +1,516 @@
+// Copyright 2025 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"errors"
+)
+
+// ConfigApplyOptions is a struct to hold the options for the ConfigApply API and the response.
+type ConfigApplyOptions struct {
+	// RunID is the ID of the run to get the status of. If empty a random one will be generated.
+	RunID *string `json:"run_id,omitempty"`
+}
+
+// ConfigApplyStatus is a struct to hold the response from the ConfigApply API.
+type ConfigApplyStatus struct {
+	Running    *bool                    `json:"running,omitempty"`
+	Successful *bool                    `json:"successful,omitempty"`
+	Nodes      []*ConfigApplyStatusNode `json:"nodes"`
+}
+
+// ConfigApplyStatusNode is a struct to hold the response from the ConfigApply API.
+type ConfigApplyStatusNode struct {
+	Hostname   *string `json:"hostname,omitempty"`
+	Running    *bool   `json:"running,omitempty"`
+	Successful *bool   `json:"successful,omitempty"`
+	RunID      *string `json:"run_id,omitempty"`
+}
+
+// ConfigApplyEventsOptions is used to enable pagination.
+type ConfigApplyEventsOptions struct {
+	LastRequestID *string `url:"last_request_id,omitempty"`
+}
+
+// ConfigApplyEvents is a struct to hold the response from the ConfigApplyEvents API.
+type ConfigApplyEvents struct {
+	Nodes []*ConfigApplyEventsNode `json:"nodes"`
+}
+
+// ConfigApplyEventsNode is a struct to hold the response from the ConfigApplyEvents API.
+type ConfigApplyEventsNode struct {
+	Node          *string                       `json:"node,omitempty"`
+	LastRequestID *string                       `json:"last_request_id,omitempty"`
+	Events        []*ConfigApplyEventsNodeEvent `json:"events"`
+}
+
+// ConfigApplyEventsNodeEvent is a struct to hold the response from the ConfigApplyEvents API.
+type ConfigApplyEventsNodeEvent struct {
+	Timestamp    *Timestamp `json:"timestamp,omitempty"`
+	SeverityText *string    `json:"severity_text,omitempty"`
+	Body         *string    `json:"body,omitempty"`
+	EventName    *string    `json:"event_name,omitempty"`
+	Topology     *string    `json:"topology,omitempty"`
+	Hostname     *string    `json:"hostname,omitempty"`
+	ConfigRunID  *string    `json:"config_run_id,omitempty"`
+	TraceID      *string    `json:"trace_id,omitempty"`
+	SpanID       *string    `json:"span_id,omitempty"`
+	SpanParentID *int64     `json:"span_parent_id,omitempty"`
+	SpanDepth    *int       `json:"span_depth,omitempty"`
+}
+
+// InitialConfigOptions is a struct to hold the options for the InitialConfig API.
+type InitialConfigOptions struct {
+	License  string `url:"license"`
+	Password string `url:"password"`
+}
+
+// LicenseStatus is a struct to hold the response from the License API.
+type LicenseStatus struct {
+	AdvancedSecurityEnabled      *bool      `json:"advancedSecurityEnabled,omitempty"`
+	AdvancedSecuritySeats        *int       `json:"advancedSecuritySeats,omitempty"`
+	ClusterSupport               *bool      `json:"clusterSupport,omitempty"`
+	Company                      *string    `json:"company,omitempty"`
+	CroquetSupport               *bool      `json:"croquetSupport,omitempty"`
+	CustomTerms                  *bool      `json:"customTerms,omitempty"`
+	Evaluation                   *bool      `json:"evaluation,omitempty"`
+	ExpireAt                     *Timestamp `json:"expireAt,omitempty"`
+	InsightsEnabled              *bool      `json:"insightsEnabled,omitempty"`
+	InsightsExpireAt             *Timestamp `json:"insightsExpireAt,omitempty"`
+	LearningLabEvaluationExpires *Timestamp `json:"learningLabEvaluationExpires,omitempty"`
+	LearningLabSeats             *int       `json:"learningLabSeats,omitempty"`
+	Perpetual                    *bool      `json:"perpetual,omitempty"`
+	ReferenceNumber              *string    `json:"referenceNumber,omitempty"`
+	Seats                        *int       `json:"seats,omitempty"`
+	SSHAllowed                   *bool      `json:"sshAllowed,omitempty"`
+	SupportKey                   *string    `json:"supportKey,omitempty"`
+	UnlimitedSeating             *bool      `json:"unlimitedSeating,omitempty"`
+}
+
+// UploadLicenseOptions is a struct to hold the options for the UploadLicense API.
+type UploadLicenseOptions struct {
+	License string `url:"license"`
+}
+
+// LicenseCheck is a struct to hold the response from the LicenseStatus API.
+type LicenseCheck struct {
+	Status *string `json:"status,omitempty"`
+}
+
+// ConfigSettings is a struct to hold the response from the Settings API.
+// There are many fields that link to other structs.
+type ConfigSettings struct {
+	PrivateMode           *bool                          `json:"private_mode,omitempty"`
+	PublicPages           *bool                          `json:"public_pages,omitempty"`
+	SubdomainIsolation    *bool                          `json:"subdomain_isolation,omitempty"`
+	SignupEnabled         *bool                          `json:"signup_enabled,omitempty"`
+	GithubHostname        *string                        `json:"github_hostname,omitempty"`
+	IdenticonsHost        *string                        `json:"identicons_host,omitempty"`
+	HTTPProxy             *string                        `json:"http_proxy,omitempty"`
+	AuthMode              *string                        `json:"auth_mode,omitempty"`
+	ExpireSessions        *bool                          `json:"expire_sessions,omitempty"`
+	AdminPassword         *string                        `json:"admin_password,omitempty"`
+	ConfigurationID       *int64                         `json:"configuration_id,omitempty"`
+	ConfigurationRunCount *int                           `json:"configuration_run_count,omitempty"`
+	Avatar                *ConfigSettingsAvatar          `json:"avatar,omitempty"`
+	Customer              *ConfigSettingsCustomer        `json:"customer,omitempty"`
+	License               *ConfigSettingsLicenseSettings `json:"license,omitempty"`
+	GithubSSL             *ConfigSettingsGithubSSL       `json:"github_ssl,omitempty"`
+	LDAP                  *ConfigSettingsLDAP            `json:"ldap,omitempty"`
+	CAS                   *ConfigSettingsCAS             `json:"cas,omitempty"`
+	SAML                  *ConfigSettingsSAML            `json:"saml,omitempty"`
+	GithubOAuth           *ConfigSettingsGithubOAuth     `json:"github_oauth,omitempty"`
+	SMTP                  *ConfigSettingsSMTP            `json:"smtp,omitempty"`
+	NTP                   *ConfigSettingsNTP             `json:"ntp,omitempty"`
+	Timezone              *string                        `json:"timezone,omitempty"`
+	SNMP                  *ConfigSettingsSNMP            `json:"snmp,omitempty"`
+	Syslog                *ConfigSettingsSyslog          `json:"syslog,omitempty"`
+	Assets                *string                        `json:"assets,omitempty"`
+	Pages                 *ConfigSettingsPagesSettings   `json:"pages,omitempty"`
+	Collectd              *ConfigSettingsCollectd        `json:"collectd,omitempty"`
+	Mapping               *ConfigSettingsMapping         `json:"mapping,omitempty"`
+	LoadBalancer          *string                        `json:"load_balancer,omitempty"`
+}
+
+// ConfigSettingsAvatar is a struct to hold the response from the Settings API.
+type ConfigSettingsAvatar struct {
+	Enabled *bool   `json:"enabled,omitempty"`
+	URI     *string `json:"uri,omitempty"`
+}
+
+// ConfigSettingsCustomer is a struct to hold the response from the Settings API.
+type ConfigSettingsCustomer struct {
+	Name          *string `json:"name,omitempty"`
+	Email         *string `json:"email,omitempty"`
+	UUID          *string `json:"uuid,omitempty"`
+	Secret        *string `json:"secret,omitempty"`
+	PublicKeyData *string `json:"public_key_data,omitempty"`
+}
+
+// ConfigSettingsLicenseSettings is a struct to hold the response from the Settings API.
+type ConfigSettingsLicenseSettings struct {
+	Seats            *int       `json:"seats,omitempty"`
+	Evaluation       *bool      `json:"evaluation,omitempty"`
+	Perpetual        *bool      `json:"perpetual,omitempty"`
+	UnlimitedSeating *bool      `json:"unlimited_seating,omitempty"`
+	SupportKey       *string    `json:"support_key,omitempty"`
+	SSHAllowed       *bool      `json:"ssh_allowed,omitempty"`
+	ClusterSupport   *bool      `json:"cluster_support,omitempty"`
+	ExpireAt         *Timestamp `json:"expire_at,omitempty"`
+}
+
+// ConfigSettingsGithubSSL is a struct to hold the response from the Settings API.
+type ConfigSettingsGithubSSL struct {
+	Enabled *bool   `json:"enabled,omitempty"`
+	Cert    *string `json:"cert,omitempty"`
+	Key     *string `json:"key,omitempty"`
+}
+
+// ConfigSettingsLDAP is a struct to hold the response from the Settings API.
+type ConfigSettingsLDAP struct {
+	Host                    *string                           `json:"host,omitempty"`
+	Port                    *int                              `json:"port,omitempty"`
+	Base                    []string                          `json:"base,omitempty"`
+	UID                     *string                           `json:"uid,omitempty"`
+	BindDN                  *string                           `json:"bind_dn,omitempty"`
+	Password                *string                           `json:"password,omitempty"`
+	Method                  *string                           `json:"method,omitempty"`
+	SearchStrategy          *string                           `json:"search_strategy,omitempty"`
+	UserGroups              []string                          `json:"user_groups,omitempty"`
+	AdminGroup              *string                           `json:"admin_group,omitempty"`
+	VirtualAttributeEnabled *bool                             `json:"virtual_attribute_enabled,omitempty"`
+	RecursiveGroupSearch    *bool                             `json:"recursive_group_search,omitempty"`
+	PosixSupport            *bool                             `json:"posix_support,omitempty"`
+	UserSyncEmails          *bool                             `json:"user_sync_emails,omitempty"`
+	UserSyncKeys            *bool                             `json:"user_sync_keys,omitempty"`
+	UserSyncInterval        *int                              `json:"user_sync_interval,omitempty"`
+	TeamSyncInterval        *int                              `json:"team_sync_interval,omitempty"`
+	SyncEnabled             *bool                             `json:"sync_enabled,omitempty"`
+	Reconciliation          *ConfigSettingsLDAPReconciliation `json:"reconciliation,omitempty"`
+	Profile                 *ConfigSettingsLDAPProfile        `json:"profile,omitempty"`
+}
+
+// ConfigSettingsLDAPReconciliation is part of the ConfigSettingsLDAP struct.
+type ConfigSettingsLDAPReconciliation struct {
+	User *string `json:"user,omitempty"`
+	Org  *string `json:"org,omitempty"`
+}
+
+// ConfigSettingsLDAPProfile is part of the ConfigSettingsLDAP struct.
+type ConfigSettingsLDAPProfile struct {
+	UID  *string `json:"uid,omitempty"`
+	Name *string `json:"name,omitempty"`
+	Mail *string `json:"mail,omitempty"`
+	Key  *string `json:"key,omitempty"`
+}
+
+// ConfigSettingsCAS is a struct to hold the response from the Settings API.
+type ConfigSettingsCAS struct {
+	URL *string `json:"url,omitempty"`
+}
+
+// ConfigSettingsSAML is a struct to hold the response from the Settings API.
+type ConfigSettingsSAML struct {
+	SSOURL             *string `json:"sso_url,omitempty"`
+	Certificate        *string `json:"certificate,omitempty"`
+	CertificatePath    *string `json:"certificate_path,omitempty"`
+	Issuer             *string `json:"issuer,omitempty"`
+	IDPInitiatedSSO    *bool   `json:"idp_initiated_sso,omitempty"`
+	DisableAdminDemote *bool   `json:"disable_admin_demote,omitempty"`
+}
+
+// ConfigSettingsGithubOAuth is a struct to hold the response from the Settings API.
+type ConfigSettingsGithubOAuth struct {
+	ClientID         *string `json:"client_id,omitempty"`
+	ClientSecret     *string `json:"client_secret,omitempty"`
+	OrganizationName *string `json:"organization_name,omitempty"`
+	OrganizationTeam *string `json:"organization_team,omitempty"`
+}
+
+// ConfigSettingsSMTP is a struct to hold the response from the Settings API.
+type ConfigSettingsSMTP struct {
+	Enabled                 *bool   `json:"enabled,omitempty"`
+	Address                 *string `json:"address,omitempty"`
+	Authentication          *string `json:"authentication,omitempty"`
+	Port                    *string `json:"port,omitempty"`
+	Domain                  *string `json:"domain,omitempty"`
+	Username                *string `json:"username,omitempty"`
+	UserName                *string `json:"user_name,omitempty"`
+	EnableStarttlsAuto      *bool   `json:"enable_starttls_auto,omitempty"`
+	Password                *string `json:"password,omitempty"`
+	DiscardToNoreplyAddress *bool   `json:"discard-to-noreply-address,omitempty"`
+	SupportAddress          *string `json:"support_address,omitempty"`
+	SupportAddressType      *string `json:"support_address_type,omitempty"`
+	NoreplyAddress          *string `json:"noreply_address,omitempty"`
+}
+
+// ConfigSettingsNTP is a struct to hold the response from the Settings API.
+type ConfigSettingsNTP struct {
+	PrimaryServer   *string `json:"primary_server,omitempty"`
+	SecondaryServer *string `json:"secondary_server,omitempty"`
+}
+
+// ConfigSettingsSNMP is a struct to hold the response from the Settings API.
+type ConfigSettingsSNMP struct {
+	Enabled   *bool   `json:"enabled,omitempty"`
+	Community *string `json:"community,omitempty"`
+}
+
+// ConfigSettingsSyslog is a struct to hold the response from the Settings API.
+type ConfigSettingsSyslog struct {
+	Enabled      *bool   `json:"enabled,omitempty"`
+	Server       *string `json:"server,omitempty"`
+	ProtocolName *string `json:"protocol_name,omitempty"`
+}
+
+// ConfigSettingsPagesSettings is a struct to hold the response from the Settings API.
+type ConfigSettingsPagesSettings struct {
+	Enabled *bool `json:"enabled,omitempty"`
+}
+
+// ConfigSettingsCollectd is a struct to hold the response from the Settings API.
+type ConfigSettingsCollectd struct {
+	Enabled    *bool   `json:"enabled,omitempty"`
+	Server     *string `json:"server,omitempty"`
+	Port       *int    `json:"port,omitempty"`
+	Encryption *string `json:"encryption,omitempty"`
+	Username   *string `json:"username,omitempty"`
+	Password   *string `json:"password,omitempty"`
+}
+
+// ConfigSettingsMapping is a struct to hold the response from the Settings API.
+type ConfigSettingsMapping struct {
+	Enabled    *bool   `json:"enabled,omitempty"`
+	Tileserver *string `json:"tileserver,omitempty"`
+	Basemap    *string `json:"basemap,omitempty"`
+	Token      *string `json:"token,omitempty"`
+}
+
+// NodeMetadataStatus is a struct to hold the response from the NodeMetadata API.
+type NodeMetadataStatus struct {
+	Topology *string        `json:"topology,omitempty"`
+	Nodes    []*NodeDetails `json:"nodes"`
+}
+
+// NodeDetails is a struct to hold the response from the NodeMetadata API.
+type NodeDetails struct {
+	Hostname     *string  `json:"hostname,omitempty"`
+	UUID         *string  `json:"uuid,omitempty"`
+	ClusterRoles []string `json:"cluster_roles,omitempty"`
+}
+
+// ConfigApplyEvents gets events from the command ghe-config-apply.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#list-events-from-ghe-config-apply
+//
+//meta:operation GET /manage/v1/config/apply/events
+func (s *EnterpriseService) ConfigApplyEvents(ctx context.Context, opts *ConfigApplyEventsOptions) (*ConfigApplyEvents, *Response, error) {
+	u, err := addOptions("manage/v1/config/apply/events", opts)
+	if err != nil {
+		return nil, nil, err
+	}
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	configApplyEvents := new(ConfigApplyEvents)
+	resp, err := s.client.Do(ctx, req, configApplyEvents)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return configApplyEvents, resp, nil
+}
+
+// InitialConfig initializes the GitHub Enterprise instance with a license and password.
+// After initializing the instance, you need to run an apply to apply the configuration.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#initialize-instance-configuration-with-license-and-password
+//
+//meta:operation POST /manage/v1/config/init
+func (s *EnterpriseService) InitialConfig(ctx context.Context, license, password string) (*Response, error) {
+	u := "manage/v1/config/init"
+
+	opts := &InitialConfigOptions{
+		License:  license,
+		Password: password,
+	}
+
+	req, err := s.client.NewRequest("POST", u, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// License gets the current license information for the GitHub Enterprise instance.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#get-the-enterprise-license-information
+//
+//meta:operation GET /manage/v1/config/license
+func (s *EnterpriseService) License(ctx context.Context) ([]*LicenseStatus, *Response, error) {
+	u := "manage/v1/config/license"
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var licenseStatus []*LicenseStatus
+	resp, err := s.client.Do(ctx, req, &licenseStatus)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return licenseStatus, resp, nil
+}
+
+// UploadLicense uploads a new license to the GitHub Enterprise instance.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#upload-an-enterprise-license
+//
+//meta:operation PUT /manage/v1/config/license
+func (s *EnterpriseService) UploadLicense(ctx context.Context, license string) (*Response, error) {
+	u := "manage/v1/config/license"
+	opts := &UploadLicenseOptions{
+		License: license,
+	}
+	req, err := s.client.NewRequest("PUT", u, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// LicenseStatus gets the current license status for the GitHub Enterprise instance.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#check-a-license
+//
+//meta:operation GET /manage/v1/config/license/check
+func (s *EnterpriseService) LicenseStatus(ctx context.Context) ([]*LicenseCheck, *Response, error) {
+	u := "manage/v1/config/license/check"
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var checks []*LicenseCheck
+	resp, err := s.client.Do(ctx, req, &checks)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return checks, resp, nil
+}
+
+// NodeMetadata gets the metadata for all nodes in the GitHub Enterprise instance.
+// This is required for clustered setups.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#get-ghes-node-metadata-for-all-nodes
+//
+//meta:operation GET /manage/v1/config/nodes
+func (s *EnterpriseService) NodeMetadata(ctx context.Context, opts *NodeQueryOptions) (*NodeMetadataStatus, *Response, error) {
+	u, err := addOptions("manage/v1/config/nodes", opts)
+	if err != nil {
+		return nil, nil, err
+	}
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	status := new(NodeMetadataStatus)
+	resp, err := s.client.Do(ctx, req, status)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return status, resp, nil
+}
+
+// Settings gets the current configuration settings for the GitHub Enterprise instance.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#get-the-ghes-settings
+//
+//meta:operation GET /manage/v1/config/settings
+func (s *EnterpriseService) Settings(ctx context.Context) (*ConfigSettings, *Response, error) {
+	u := "manage/v1/config/settings"
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	configSettings := new(ConfigSettings)
+	resp, err := s.client.Do(ctx, req, configSettings)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return configSettings, resp, nil
+}
+
+// UpdateSettings updates the configuration settings for the GitHub Enterprise instance.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#set-settings
+//
+//meta:operation PUT /manage/v1/config/settings
+func (s *EnterpriseService) UpdateSettings(ctx context.Context, opts *ConfigSettings) (*Response, error) {
+	u := "manage/v1/config/settings"
+
+	if opts == nil {
+		return nil, errors.New("opts should not be nil")
+	}
+	req, err := s.client.NewRequest("PUT", u, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// ConfigApply triggers a configuration apply run on the GitHub Enterprise instance.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#trigger-a-ghe-config-apply-run
+//
+//meta:operation POST /manage/v1/config/apply
+func (s *EnterpriseService) ConfigApply(ctx context.Context, opts *ConfigApplyOptions) (*ConfigApplyOptions, *Response, error) {
+	u := "manage/v1/config/apply"
+	req, err := s.client.NewRequest("POST", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	configApplyOptions := new(ConfigApplyOptions)
+	resp, err := s.client.Do(ctx, req, configApplyOptions)
+	if err != nil {
+		return nil, resp, err
+	}
+	return configApplyOptions, resp, nil
+}
+
+// ConfigApplyStatus gets the status of a ghe-config-apply run on the GitHub Enterprise instance.
+// You can request lat one or specific id one.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#get-the-status-of-a-ghe-config-apply-run
+//
+//meta:operation GET /manage/v1/config/apply
+func (s *EnterpriseService) ConfigApplyStatus(ctx context.Context, opts *ConfigApplyOptions) (*ConfigApplyStatus, *Response, error) {
+	u := "manage/v1/config/apply"
+	req, err := s.client.NewRequest("GET", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	status := new(ConfigApplyStatus)
+	resp, err := s.client.Do(ctx, req, status)
+	if err != nil {
+		return nil, resp, err
+	}
+	return status, resp, nil
+}

vendor/github.com/google/go-github/v69/github/enterprise_manage_ghes_maintenance.go

@@ -0,0 +1,94 @@
+// Copyright 2025 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+)
+
+// MaintenanceOperationStatus represents the message to be displayed when the instance gets a maintenance operation request.
+type MaintenanceOperationStatus struct {
+	Hostname *string `json:"hostname,omitempty"`
+	UUID     *string `json:"uuid,omitempty"`
+	Message  *string `json:"message,omitempty"`
+}
+
+// MaintenanceStatus represents the status of maintenance mode for all nodes.
+type MaintenanceStatus struct {
+	Hostname               *string                  `json:"hostname,omitempty"`
+	UUID                   *string                  `json:"uuid,omitempty"`
+	Status                 *string                  `json:"status,omitempty"`
+	ScheduledTime          *Timestamp               `json:"scheduled_time,omitempty"`
+	ConnectionServices     []*ConnectionServiceItem `json:"connection_services,omitempty"`
+	CanUnsetMaintenance    *bool                    `json:"can_unset_maintenance,omitempty"`
+	IPExceptionList        []string                 `json:"ip_exception_list,omitempty"`
+	MaintenanceModeMessage *string                  `json:"maintenance_mode_message,omitempty"`
+}
+
+// ConnectionServiceItem represents the connection services for the maintenance status.
+type ConnectionServiceItem struct {
+	Name   *string `json:"name,omitempty"`
+	Number *int    `json:"number,omitempty"`
+}
+
+// MaintenanceOptions represents the options for setting the maintenance mode for the instance.
+// When can be a string, so we can't use a Timestamp type.
+type MaintenanceOptions struct {
+	Enabled                bool     `json:"enabled"`
+	UUID                   *string  `json:"uuid,omitempty"`
+	When                   *string  `json:"when,omitempty"`
+	IPExceptionList        []string `json:"ip_exception_list,omitempty"`
+	MaintenanceModeMessage *string  `json:"maintenance_mode_message,omitempty"`
+}
+
+// GetMaintenanceStatus gets the status of maintenance mode for all nodes.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#get-the-status-of-maintenance-mode
+//
+//meta:operation GET /manage/v1/maintenance
+func (s *EnterpriseService) GetMaintenanceStatus(ctx context.Context, opts *NodeQueryOptions) ([]*MaintenanceStatus, *Response, error) {
+	u, err := addOptions("manage/v1/maintenance", opts)
+	if err != nil {
+		return nil, nil, err
+	}
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var status []*MaintenanceStatus
+	resp, err := s.client.Do(ctx, req, &status)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return status, resp, nil
+}
+
+// CreateMaintenance sets the maintenance mode for the instance.
+// With the enable parameter we can control to put instance into maintenance mode or not. With false we can disable the maintenance mode.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#set-the-status-of-maintenance-mode
+//
+//meta:operation POST /manage/v1/maintenance
+func (s *EnterpriseService) CreateMaintenance(ctx context.Context, enable bool, opts *MaintenanceOptions) ([]*MaintenanceOperationStatus, *Response, error) {
+	u := "manage/v1/maintenance"
+
+	opts.Enabled = enable
+
+	req, err := s.client.NewRequest("POST", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var i []*MaintenanceOperationStatus
+	resp, err := s.client.Do(ctx, req, &i)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return i, resp, nil
+}

vendor/github.com/google/go-github/v69/github/enterprise_manage_ghes_ssh.go

@@ -0,0 +1,99 @@
+// Copyright 2025 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+)
+
+// SSHKeyStatus represents the status of a SSH key operation.
+type SSHKeyStatus struct {
+	Hostname *string `json:"hostname,omitempty"`
+	UUID     *string `json:"uuid,omitempty"`
+	Message  *string `json:"message,omitempty"`
+	Modified *bool   `json:"modified,omitempty"`
+}
+
+// SSHKeyOptions specifies the parameters to the SSH create and delete functions.
+type SSHKeyOptions struct {
+	// Key is the SSH key to add to the instance.
+	Key string `json:"key"`
+}
+
+// ClusterSSHKey represents the SSH keys configured for the instance.
+type ClusterSSHKey struct {
+	Key         *string `json:"key,omitempty"`
+	Fingerprint *string `json:"fingerprint,omitempty"`
+}
+
+// DeleteSSHKey deletes the SSH key from the instance.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#delete-a-ssh-key
+//
+//meta:operation DELETE /manage/v1/access/ssh
+func (s *EnterpriseService) DeleteSSHKey(ctx context.Context, key string) ([]*SSHKeyStatus, *Response, error) {
+	u := "manage/v1/access/ssh"
+	opts := &SSHKeyOptions{
+		Key: key,
+	}
+	req, err := s.client.NewRequest("DELETE", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var sshStatus []*SSHKeyStatus
+	resp, err := s.client.Do(ctx, req, &sshStatus)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return sshStatus, resp, nil
+}
+
+// GetSSHKey gets the SSH keys configured for the instance.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#get-the-configured-ssh-keys
+//
+//meta:operation GET /manage/v1/access/ssh
+func (s *EnterpriseService) GetSSHKey(ctx context.Context) ([]*ClusterSSHKey, *Response, error) {
+	u := "manage/v1/access/ssh"
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var sshKeys []*ClusterSSHKey
+	resp, err := s.client.Do(ctx, req, &sshKeys)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return sshKeys, resp, nil
+}
+
+// CreateSSHKey adds a new SSH key to the instance.
+//
+// GitHub API docs: https://docs.github.com/enterprise-server@3.15/rest/enterprise-admin/manage-ghes#set-a-new-ssh-key
+//
+//meta:operation POST /manage/v1/access/ssh
+func (s *EnterpriseService) CreateSSHKey(ctx context.Context, key string) ([]*SSHKeyStatus, *Response, error) {
+	u := "manage/v1/access/ssh"
+	opts := &SSHKeyOptions{
+		Key: key,
+	}
+	req, err := s.client.NewRequest("POST", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var sshKeyResponse []*SSHKeyStatus
+	resp, err := s.client.Do(ctx, req, &sshKeyResponse)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return sshKeyResponse, resp, nil
+}

vendor/github.com/google/go-github/v69/github/enterprise_properties.go

@@ -0,0 +1,121 @@
+// Copyright 2024 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// GetAllCustomProperties gets all custom properties that are defined for the specified enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/custom-properties#get-custom-properties-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/properties/schema
+func (s *EnterpriseService) GetAllCustomProperties(ctx context.Context, enterprise string) ([]*CustomProperty, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/properties/schema", enterprise)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var customProperties []*CustomProperty
+	resp, err := s.client.Do(ctx, req, &customProperties)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return customProperties, resp, nil
+}
+
+// CreateOrUpdateCustomProperties creates new or updates existing custom properties that are defined for the specified enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/custom-properties#create-or-update-custom-properties-for-an-enterprise
+//
+//meta:operation PATCH /enterprises/{enterprise}/properties/schema
+func (s *EnterpriseService) CreateOrUpdateCustomProperties(ctx context.Context, enterprise string, properties []*CustomProperty) ([]*CustomProperty, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/properties/schema", enterprise)
+
+	params := struct {
+		Properties []*CustomProperty `json:"properties"`
+	}{
+		Properties: properties,
+	}
+
+	req, err := s.client.NewRequest("PATCH", u, params)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var customProperties []*CustomProperty
+	resp, err := s.client.Do(ctx, req, &customProperties)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return customProperties, resp, nil
+}
+
+// GetCustomProperty gets a custom property that is defined for the specified enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/custom-properties#get-a-custom-property-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/properties/schema/{custom_property_name}
+func (s *EnterpriseService) GetCustomProperty(ctx context.Context, enterprise, customPropertyName string) (*CustomProperty, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/properties/schema/%v", enterprise, customPropertyName)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var customProperty *CustomProperty
+	resp, err := s.client.Do(ctx, req, &customProperty)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return customProperty, resp, nil
+}
+
+// CreateOrUpdateCustomProperty creates a new or updates an existing custom property that is defined for the specified enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/custom-properties#create-or-update-a-custom-property-for-an-enterprise
+//
+//meta:operation PUT /enterprises/{enterprise}/properties/schema/{custom_property_name}
+func (s *EnterpriseService) CreateOrUpdateCustomProperty(ctx context.Context, enterprise, customPropertyName string, property *CustomProperty) (*CustomProperty, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/properties/schema/%v", enterprise, customPropertyName)
+
+	req, err := s.client.NewRequest("PUT", u, property)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var customProperty *CustomProperty
+	resp, err := s.client.Do(ctx, req, &customProperty)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return customProperty, resp, nil
+}
+
+// RemoveCustomProperty removes a custom property that is defined for the specified enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/custom-properties#remove-a-custom-property-for-an-enterprise
+//
+//meta:operation DELETE /enterprises/{enterprise}/properties/schema/{custom_property_name}
+func (s *EnterpriseService) RemoveCustomProperty(ctx context.Context, enterprise, customPropertyName string) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/properties/schema/%v", enterprise, customPropertyName)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/enterprise_rules.go

@@ -0,0 +1,118 @@
+// Copyright 2025 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// CreateRepositoryRuleset creates a repository ruleset for the specified enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/rules#create-an-enterprise-repository-ruleset
+//
+//meta:operation POST /enterprises/{enterprise}/rulesets
+func (s *EnterpriseService) CreateRepositoryRuleset(ctx context.Context, enterprise string, ruleset RepositoryRuleset) (*RepositoryRuleset, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/rulesets", enterprise)
+
+	req, err := s.client.NewRequest("POST", u, ruleset)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var rs *RepositoryRuleset
+	resp, err := s.client.Do(ctx, req, &rs)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return rs, resp, nil
+}
+
+// GetRepositoryRuleset gets a repository ruleset for the specified enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/rules#get-an-enterprise-repository-ruleset
+//
+//meta:operation GET /enterprises/{enterprise}/rulesets/{ruleset_id}
+func (s *EnterpriseService) GetRepositoryRuleset(ctx context.Context, enterprise string, rulesetID int64) (*RepositoryRuleset, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/rulesets/%v", enterprise, rulesetID)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var ruleset *RepositoryRuleset
+	resp, err := s.client.Do(ctx, req, &ruleset)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return ruleset, resp, nil
+}
+
+// UpdateRepositoryRuleset updates a repository ruleset for the specified enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/rules#update-an-enterprise-repository-ruleset
+//
+//meta:operation PUT /enterprises/{enterprise}/rulesets/{ruleset_id}
+func (s *EnterpriseService) UpdateRepositoryRuleset(ctx context.Context, enterprise string, rulesetID int64, ruleset RepositoryRuleset) (*RepositoryRuleset, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/rulesets/%v", enterprise, rulesetID)
+
+	req, err := s.client.NewRequest("PUT", u, ruleset)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var rs *RepositoryRuleset
+	resp, err := s.client.Do(ctx, req, &rs)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return rs, resp, nil
+}
+
+// UpdateRepositoryRulesetClearBypassActor clears the bypass actors for a repository ruleset for the specified enterprise.
+//
+// This function is necessary as the UpdateRepositoryRuleset function does not marshal ByPassActor if passed as an empty array.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/rules#update-an-enterprise-repository-ruleset
+//
+//meta:operation PUT /enterprises/{enterprise}/rulesets/{ruleset_id}
+func (s *EnterpriseService) UpdateRepositoryRulesetClearBypassActor(ctx context.Context, enterprise string, rulesetID int64) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/rulesets/%v", enterprise, rulesetID)
+
+	rsClearBypassActor := rulesetClearBypassActors{}
+
+	req, err := s.client.NewRequest("PUT", u, rsClearBypassActor)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// DeleteRepositoryRuleset deletes a repository ruleset from the specified enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/rules#delete-an-enterprise-repository-ruleset
+//
+//meta:operation DELETE /enterprises/{enterprise}/rulesets/{ruleset_id}
+func (s *EnterpriseService) DeleteRepositoryRuleset(ctx context.Context, enterprise string, rulesetID int64) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/rulesets/%v", enterprise, rulesetID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/event.go

@@ -0,0 +1,54 @@
+// Copyright 2018 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"encoding/json"
+)
+
+// Event represents a GitHub event.
+type Event struct {
+	Type       *string          `json:"type,omitempty"`
+	Public     *bool            `json:"public,omitempty"`
+	RawPayload *json.RawMessage `json:"payload,omitempty"`
+	Repo       *Repository      `json:"repo,omitempty"`
+	Actor      *User            `json:"actor,omitempty"`
+	Org        *Organization    `json:"org,omitempty"`
+	CreatedAt  *Timestamp       `json:"created_at,omitempty"`
+	ID         *string          `json:"id,omitempty"`
+}
+
+func (e Event) String() string {
+	return Stringify(e)
+}
+
+// ParsePayload parses the event payload. For recognized event types,
+// a value of the corresponding struct type will be returned.
+func (e *Event) ParsePayload() (interface{}, error) {
+	// It would be nice if e.Type were the snake_case name of the event,
+	// but the existing interface uses the struct name instead.
+	payload := EventForType(typeToMessageMapping[e.GetType()])
+
+	if err := json.Unmarshal(e.GetRawPayload(), &payload); err != nil {
+		return nil, err
+	}
+
+	return payload, nil
+}
+
+// Payload returns the parsed event payload. For recognized event types,
+// a value of the corresponding struct type will be returned.
+//
+// Deprecated: Use ParsePayload instead, which returns an error
+// rather than panics if JSON unmarshaling raw payload fails.
+func (e *Event) Payload() (payload interface{}) {
+	var err error
+	payload, err = e.ParsePayload()
+	if err != nil {
+		panic(err)
+	}
+	return payload
+}

vendor/github.com/google/go-github/v69/github/gists.go

@@ -0,0 +1,397 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+// GistsService handles communication with the Gist related
+// methods of the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/gists
+type GistsService service
+
+// Gist represents a GitHub's gist.
+type Gist struct {
+	ID          *string                   `json:"id,omitempty"`
+	Description *string                   `json:"description,omitempty"`
+	Public      *bool                     `json:"public,omitempty"`
+	Owner       *User                     `json:"owner,omitempty"`
+	Files       map[GistFilename]GistFile `json:"files,omitempty"`
+	Comments    *int                      `json:"comments,omitempty"`
+	HTMLURL     *string                   `json:"html_url,omitempty"`
+	GitPullURL  *string                   `json:"git_pull_url,omitempty"`
+	GitPushURL  *string                   `json:"git_push_url,omitempty"`
+	CreatedAt   *Timestamp                `json:"created_at,omitempty"`
+	UpdatedAt   *Timestamp                `json:"updated_at,omitempty"`
+	NodeID      *string                   `json:"node_id,omitempty"`
+}
+
+func (g Gist) String() string {
+	return Stringify(g)
+}
+
+// GistFilename represents filename on a gist.
+type GistFilename string
+
+// GistFile represents a file on a gist.
+type GistFile struct {
+	Size     *int    `json:"size,omitempty"`
+	Filename *string `json:"filename,omitempty"`
+	Language *string `json:"language,omitempty"`
+	Type     *string `json:"type,omitempty"`
+	RawURL   *string `json:"raw_url,omitempty"`
+	Content  *string `json:"content,omitempty"`
+}
+
+func (g GistFile) String() string {
+	return Stringify(g)
+}
+
+// GistCommit represents a commit on a gist.
+type GistCommit struct {
+	URL          *string      `json:"url,omitempty"`
+	Version      *string      `json:"version,omitempty"`
+	User         *User        `json:"user,omitempty"`
+	ChangeStatus *CommitStats `json:"change_status,omitempty"`
+	CommittedAt  *Timestamp   `json:"committed_at,omitempty"`
+	NodeID       *string      `json:"node_id,omitempty"`
+}
+
+func (gc GistCommit) String() string {
+	return Stringify(gc)
+}
+
+// GistFork represents a fork of a gist.
+type GistFork struct {
+	URL       *string    `json:"url,omitempty"`
+	User      *User      `json:"user,omitempty"`
+	ID        *string    `json:"id,omitempty"`
+	CreatedAt *Timestamp `json:"created_at,omitempty"`
+	UpdatedAt *Timestamp `json:"updated_at,omitempty"`
+	NodeID    *string    `json:"node_id,omitempty"`
+}
+
+func (gf GistFork) String() string {
+	return Stringify(gf)
+}
+
+// GistListOptions specifies the optional parameters to the
+// GistsService.List, GistsService.ListAll, and GistsService.ListStarred methods.
+type GistListOptions struct {
+	// Since filters Gists by time.
+	Since time.Time `url:"since,omitempty"`
+
+	ListOptions
+}
+
+// List gists for a user. Passing the empty string will list
+// all public gists if called anonymously. However, if the call
+// is authenticated, it will returns all gists for the authenticated
+// user.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/gists#list-gists-for-a-user
+// GitHub API docs: https://docs.github.com/rest/gists/gists#list-gists-for-the-authenticated-user
+//
+//meta:operation GET /gists
+//meta:operation GET /users/{username}/gists
+func (s *GistsService) List(ctx context.Context, user string, opts *GistListOptions) ([]*Gist, *Response, error) {
+	var u string
+	if user != "" {
+		u = fmt.Sprintf("users/%v/gists", user)
+	} else {
+		u = "gists"
+	}
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var gists []*Gist
+	resp, err := s.client.Do(ctx, req, &gists)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return gists, resp, nil
+}
+
+// ListAll lists all public gists.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/gists#list-public-gists
+//
+//meta:operation GET /gists/public
+func (s *GistsService) ListAll(ctx context.Context, opts *GistListOptions) ([]*Gist, *Response, error) {
+	u, err := addOptions("gists/public", opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var gists []*Gist
+	resp, err := s.client.Do(ctx, req, &gists)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return gists, resp, nil
+}
+
+// ListStarred lists starred gists of authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/gists#list-starred-gists
+//
+//meta:operation GET /gists/starred
+func (s *GistsService) ListStarred(ctx context.Context, opts *GistListOptions) ([]*Gist, *Response, error) {
+	u, err := addOptions("gists/starred", opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var gists []*Gist
+	resp, err := s.client.Do(ctx, req, &gists)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return gists, resp, nil
+}
+
+// Get a single gist.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/gists#get-a-gist
+//
+//meta:operation GET /gists/{gist_id}
+func (s *GistsService) Get(ctx context.Context, id string) (*Gist, *Response, error) {
+	u := fmt.Sprintf("gists/%v", id)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	gist := new(Gist)
+	resp, err := s.client.Do(ctx, req, gist)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return gist, resp, nil
+}
+
+// GetRevision gets a specific revision of a gist.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/gists#get-a-gist-revision
+//
+//meta:operation GET /gists/{gist_id}/{sha}
+func (s *GistsService) GetRevision(ctx context.Context, id, sha string) (*Gist, *Response, error) {
+	u := fmt.Sprintf("gists/%v/%v", id, sha)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	gist := new(Gist)
+	resp, err := s.client.Do(ctx, req, gist)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return gist, resp, nil
+}
+
+// Create a gist for authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/gists#create-a-gist
+//
+//meta:operation POST /gists
+func (s *GistsService) Create(ctx context.Context, gist *Gist) (*Gist, *Response, error) {
+	u := "gists"
+	req, err := s.client.NewRequest("POST", u, gist)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	g := new(Gist)
+	resp, err := s.client.Do(ctx, req, g)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return g, resp, nil
+}
+
+// Edit a gist.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/gists#update-a-gist
+//
+//meta:operation PATCH /gists/{gist_id}
+func (s *GistsService) Edit(ctx context.Context, id string, gist *Gist) (*Gist, *Response, error) {
+	u := fmt.Sprintf("gists/%v", id)
+	req, err := s.client.NewRequest("PATCH", u, gist)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	g := new(Gist)
+	resp, err := s.client.Do(ctx, req, g)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return g, resp, nil
+}
+
+// ListCommits lists commits of a gist.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/gists#list-gist-commits
+//
+//meta:operation GET /gists/{gist_id}/commits
+func (s *GistsService) ListCommits(ctx context.Context, id string, opts *ListOptions) ([]*GistCommit, *Response, error) {
+	u := fmt.Sprintf("gists/%v/commits", id)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var gistCommits []*GistCommit
+	resp, err := s.client.Do(ctx, req, &gistCommits)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return gistCommits, resp, nil
+}
+
+// Delete a gist.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/gists#delete-a-gist
+//
+//meta:operation DELETE /gists/{gist_id}
+func (s *GistsService) Delete(ctx context.Context, id string) (*Response, error) {
+	u := fmt.Sprintf("gists/%v", id)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// Star a gist on behalf of authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/gists#star-a-gist
+//
+//meta:operation PUT /gists/{gist_id}/star
+func (s *GistsService) Star(ctx context.Context, id string) (*Response, error) {
+	u := fmt.Sprintf("gists/%v/star", id)
+	req, err := s.client.NewRequest("PUT", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// Unstar a gist on a behalf of authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/gists#unstar-a-gist
+//
+//meta:operation DELETE /gists/{gist_id}/star
+func (s *GistsService) Unstar(ctx context.Context, id string) (*Response, error) {
+	u := fmt.Sprintf("gists/%v/star", id)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// IsStarred checks if a gist is starred by authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/gists#check-if-a-gist-is-starred
+//
+//meta:operation GET /gists/{gist_id}/star
+func (s *GistsService) IsStarred(ctx context.Context, id string) (bool, *Response, error) {
+	u := fmt.Sprintf("gists/%v/star", id)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return false, nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	starred, err := parseBoolResponse(err)
+	return starred, resp, err
+}
+
+// Fork a gist.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/gists#fork-a-gist
+//
+//meta:operation POST /gists/{gist_id}/forks
+func (s *GistsService) Fork(ctx context.Context, id string) (*Gist, *Response, error) {
+	u := fmt.Sprintf("gists/%v/forks", id)
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	g := new(Gist)
+	resp, err := s.client.Do(ctx, req, g)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return g, resp, nil
+}
+
+// ListForks lists forks of a gist.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/gists#list-gist-forks
+//
+//meta:operation GET /gists/{gist_id}/forks
+func (s *GistsService) ListForks(ctx context.Context, id string, opts *ListOptions) ([]*GistFork, *Response, error) {
+	u := fmt.Sprintf("gists/%v/forks", id)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var gistForks []*GistFork
+	resp, err := s.client.Do(ctx, req, &gistForks)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return gistForks, resp, nil
+}

vendor/github.com/google/go-github/v69/github/gists_comments.go

@@ -0,0 +1,128 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// GistComment represents a Gist comment.
+type GistComment struct {
+	ID        *int64     `json:"id,omitempty"`
+	URL       *string    `json:"url,omitempty"`
+	Body      *string    `json:"body,omitempty"`
+	User      *User      `json:"user,omitempty"`
+	CreatedAt *Timestamp `json:"created_at,omitempty"`
+}
+
+func (g GistComment) String() string {
+	return Stringify(g)
+}
+
+// ListComments lists all comments for a gist.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/comments#list-gist-comments
+//
+//meta:operation GET /gists/{gist_id}/comments
+func (s *GistsService) ListComments(ctx context.Context, gistID string, opts *ListOptions) ([]*GistComment, *Response, error) {
+	u := fmt.Sprintf("gists/%v/comments", gistID)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var comments []*GistComment
+	resp, err := s.client.Do(ctx, req, &comments)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return comments, resp, nil
+}
+
+// GetComment retrieves a single comment from a gist.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/comments#get-a-gist-comment
+//
+//meta:operation GET /gists/{gist_id}/comments/{comment_id}
+func (s *GistsService) GetComment(ctx context.Context, gistID string, commentID int64) (*GistComment, *Response, error) {
+	u := fmt.Sprintf("gists/%v/comments/%v", gistID, commentID)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	c := new(GistComment)
+	resp, err := s.client.Do(ctx, req, c)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return c, resp, nil
+}
+
+// CreateComment creates a comment for a gist.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/comments#create-a-gist-comment
+//
+//meta:operation POST /gists/{gist_id}/comments
+func (s *GistsService) CreateComment(ctx context.Context, gistID string, comment *GistComment) (*GistComment, *Response, error) {
+	u := fmt.Sprintf("gists/%v/comments", gistID)
+	req, err := s.client.NewRequest("POST", u, comment)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	c := new(GistComment)
+	resp, err := s.client.Do(ctx, req, c)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return c, resp, nil
+}
+
+// EditComment edits an existing gist comment.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/comments#update-a-gist-comment
+//
+//meta:operation PATCH /gists/{gist_id}/comments/{comment_id}
+func (s *GistsService) EditComment(ctx context.Context, gistID string, commentID int64, comment *GistComment) (*GistComment, *Response, error) {
+	u := fmt.Sprintf("gists/%v/comments/%v", gistID, commentID)
+	req, err := s.client.NewRequest("PATCH", u, comment)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	c := new(GistComment)
+	resp, err := s.client.Do(ctx, req, c)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return c, resp, nil
+}
+
+// DeleteComment deletes a gist comment.
+//
+// GitHub API docs: https://docs.github.com/rest/gists/comments#delete-a-gist-comment
+//
+//meta:operation DELETE /gists/{gist_id}/comments/{comment_id}
+func (s *GistsService) DeleteComment(ctx context.Context, gistID string, commentID int64) (*Response, error) {
+	u := fmt.Sprintf("gists/%v/comments/%v", gistID, commentID)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/git.go

@@ -0,0 +1,12 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+// GitService handles communication with the git data related
+// methods of the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/git/
+type GitService service

vendor/github.com/google/go-github/v69/github/git_blobs.go

@@ -0,0 +1,88 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+)
+
+// Blob represents a blob object.
+type Blob struct {
+	Content  *string `json:"content,omitempty"`
+	Encoding *string `json:"encoding,omitempty"`
+	SHA      *string `json:"sha,omitempty"`
+	Size     *int    `json:"size,omitempty"`
+	URL      *string `json:"url,omitempty"`
+	NodeID   *string `json:"node_id,omitempty"`
+}
+
+// GetBlob fetches a blob from a repo given a SHA.
+//
+// GitHub API docs: https://docs.github.com/rest/git/blobs#get-a-blob
+//
+//meta:operation GET /repos/{owner}/{repo}/git/blobs/{file_sha}
+func (s *GitService) GetBlob(ctx context.Context, owner string, repo string, sha string) (*Blob, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/git/blobs/%v", owner, repo, sha)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	blob := new(Blob)
+	resp, err := s.client.Do(ctx, req, blob)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return blob, resp, nil
+}
+
+// GetBlobRaw fetches a blob's contents from a repo.
+// Unlike GetBlob, it returns the raw bytes rather than the base64-encoded data.
+//
+// GitHub API docs: https://docs.github.com/rest/git/blobs#get-a-blob
+//
+//meta:operation GET /repos/{owner}/{repo}/git/blobs/{file_sha}
+func (s *GitService) GetBlobRaw(ctx context.Context, owner, repo, sha string) ([]byte, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/git/blobs/%v", owner, repo, sha)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req.Header.Set("Accept", "application/vnd.github.v3.raw")
+
+	var buf bytes.Buffer
+	resp, err := s.client.Do(ctx, req, &buf)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return buf.Bytes(), resp, nil
+}
+
+// CreateBlob creates a blob object.
+//
+// GitHub API docs: https://docs.github.com/rest/git/blobs#create-a-blob
+//
+//meta:operation POST /repos/{owner}/{repo}/git/blobs
+func (s *GitService) CreateBlob(ctx context.Context, owner string, repo string, blob *Blob) (*Blob, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/git/blobs", owner, repo)
+	req, err := s.client.NewRequest("POST", u, blob)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	t := new(Blob)
+	resp, err := s.client.Do(ctx, req, t)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return t, resp, nil
+}

vendor/github.com/google/go-github/v69/github/git_commits.go

@@ -0,0 +1,224 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+)
+
+// SignatureVerification represents GPG signature verification.
+type SignatureVerification struct {
+	Verified  *bool   `json:"verified,omitempty"`
+	Reason    *string `json:"reason,omitempty"`
+	Signature *string `json:"signature,omitempty"`
+	Payload   *string `json:"payload,omitempty"`
+}
+
+// MessageSigner is used by GitService.CreateCommit to sign a commit.
+//
+// To create a MessageSigner that signs a commit with a [golang.org/x/crypto/openpgp.Entity],
+// or [github.com/ProtonMail/go-crypto/openpgp.Entity], use:
+//
+//	commit.Signer = github.MessageSignerFunc(func(w io.Writer, r io.Reader) error {
+//		return openpgp.ArmoredDetachSign(w, openpgpEntity, r, nil)
+//	})
+type MessageSigner interface {
+	Sign(w io.Writer, r io.Reader) error
+}
+
+// MessageSignerFunc is a single function implementation of MessageSigner.
+type MessageSignerFunc func(w io.Writer, r io.Reader) error
+
+func (f MessageSignerFunc) Sign(w io.Writer, r io.Reader) error {
+	return f(w, r)
+}
+
+// Commit represents a GitHub commit.
+type Commit struct {
+	SHA          *string                `json:"sha,omitempty"`
+	Author       *CommitAuthor          `json:"author,omitempty"`
+	Committer    *CommitAuthor          `json:"committer,omitempty"`
+	Message      *string                `json:"message,omitempty"`
+	Tree         *Tree                  `json:"tree,omitempty"`
+	Parents      []*Commit              `json:"parents,omitempty"`
+	HTMLURL      *string                `json:"html_url,omitempty"`
+	URL          *string                `json:"url,omitempty"`
+	Verification *SignatureVerification `json:"verification,omitempty"`
+	NodeID       *string                `json:"node_id,omitempty"`
+
+	// CommentCount is the number of GitHub comments on the commit. This
+	// is only populated for requests that fetch GitHub data like
+	// Pulls.ListCommits, Repositories.ListCommits, etc.
+	CommentCount *int `json:"comment_count,omitempty"`
+}
+
+func (c Commit) String() string {
+	return Stringify(c)
+}
+
+// CommitAuthor represents the author or committer of a commit. The commit
+// author may not correspond to a GitHub User.
+type CommitAuthor struct {
+	Date  *Timestamp `json:"date,omitempty"`
+	Name  *string    `json:"name,omitempty"`
+	Email *string    `json:"email,omitempty"`
+
+	// The following fields are only populated by Webhook events.
+	Login *string `json:"username,omitempty"` // Renamed for go-github consistency.
+}
+
+func (c CommitAuthor) String() string {
+	return Stringify(c)
+}
+
+// GetCommit fetches the Commit object for a given SHA.
+//
+// GitHub API docs: https://docs.github.com/rest/git/commits#get-a-commit-object
+//
+//meta:operation GET /repos/{owner}/{repo}/git/commits/{commit_sha}
+func (s *GitService) GetCommit(ctx context.Context, owner string, repo string, sha string) (*Commit, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/git/commits/%v", owner, repo, sha)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	c := new(Commit)
+	resp, err := s.client.Do(ctx, req, c)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return c, resp, nil
+}
+
+// createCommit represents the body of a CreateCommit request.
+type createCommit struct {
+	Author    *CommitAuthor `json:"author,omitempty"`
+	Committer *CommitAuthor `json:"committer,omitempty"`
+	Message   *string       `json:"message,omitempty"`
+	Tree      *string       `json:"tree,omitempty"`
+	Parents   []string      `json:"parents,omitempty"`
+	Signature *string       `json:"signature,omitempty"`
+}
+
+type CreateCommitOptions struct {
+	// CreateCommit will sign the commit with this signer. See MessageSigner doc for more details.
+	// Ignored on commits where Verification.Signature is defined.
+	Signer MessageSigner
+}
+
+// CreateCommit creates a new commit in a repository.
+// commit must not be nil.
+//
+// The commit.Committer is optional and will be filled with the commit.Author
+// data if omitted. If the commit.Author is omitted, it will be filled in with
+// the authenticated user’s information and the current date.
+//
+// GitHub API docs: https://docs.github.com/rest/git/commits#create-a-commit
+//
+//meta:operation POST /repos/{owner}/{repo}/git/commits
+func (s *GitService) CreateCommit(ctx context.Context, owner string, repo string, commit *Commit, opts *CreateCommitOptions) (*Commit, *Response, error) {
+	if commit == nil {
+		return nil, nil, errors.New("commit must be provided")
+	}
+	if opts == nil {
+		opts = &CreateCommitOptions{}
+	}
+
+	u := fmt.Sprintf("repos/%v/%v/git/commits", owner, repo)
+
+	parents := make([]string, len(commit.Parents))
+	for i, parent := range commit.Parents {
+		parents[i] = *parent.SHA
+	}
+
+	body := &createCommit{
+		Author:    commit.Author,
+		Committer: commit.Committer,
+		Message:   commit.Message,
+		Parents:   parents,
+	}
+	if commit.Tree != nil {
+		body.Tree = commit.Tree.SHA
+	}
+	switch {
+	case commit.Verification != nil:
+		body.Signature = commit.Verification.Signature
+	case opts.Signer != nil:
+		signature, err := createSignature(opts.Signer, body)
+		if err != nil {
+			return nil, nil, err
+		}
+		body.Signature = &signature
+	}
+
+	req, err := s.client.NewRequest("POST", u, body)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	c := new(Commit)
+	resp, err := s.client.Do(ctx, req, c)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return c, resp, nil
+}
+
+func createSignature(signer MessageSigner, commit *createCommit) (string, error) {
+	if signer == nil {
+		return "", errors.New("createSignature: invalid parameters")
+	}
+
+	message, err := createSignatureMessage(commit)
+	if err != nil {
+		return "", err
+	}
+
+	var writer bytes.Buffer
+	err = signer.Sign(&writer, strings.NewReader(message))
+	if err != nil {
+		return "", err
+	}
+
+	return writer.String(), nil
+}
+
+func createSignatureMessage(commit *createCommit) (string, error) {
+	if commit == nil || commit.Message == nil || *commit.Message == "" || commit.Author == nil {
+		return "", errors.New("createSignatureMessage: invalid parameters")
+	}
+
+	var message []string
+
+	if commit.Tree != nil {
+		message = append(message, fmt.Sprintf("tree %s", *commit.Tree))
+	}
+
+	for _, parent := range commit.Parents {
+		message = append(message, fmt.Sprintf("parent %s", parent))
+	}
+
+	message = append(message, fmt.Sprintf("author %s <%s> %d %s", commit.Author.GetName(), commit.Author.GetEmail(), commit.Author.GetDate().Unix(), commit.Author.GetDate().Format("-0700")))
+
+	committer := commit.Committer
+	if committer == nil {
+		committer = commit.Author
+	}
+
+	// There needs to be a double newline after committer
+	message = append(message, fmt.Sprintf("committer %s <%s> %d %s\n", committer.GetName(), committer.GetEmail(), committer.GetDate().Unix(), committer.GetDate().Format("-0700")))
+	message = append(message, *commit.Message)
+
+	return strings.Join(message, "\n"), nil
+}

vendor/github.com/google/go-github/v69/github/git_refs.go

@@ -0,0 +1,185 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+	"net/url"
+	"strings"
+)
+
+// Reference represents a GitHub reference.
+type Reference struct {
+	Ref    *string    `json:"ref"`
+	URL    *string    `json:"url"`
+	Object *GitObject `json:"object"`
+	NodeID *string    `json:"node_id,omitempty"`
+}
+
+func (r Reference) String() string {
+	return Stringify(r)
+}
+
+// GitObject represents a Git object.
+type GitObject struct {
+	Type *string `json:"type"`
+	SHA  *string `json:"sha"`
+	URL  *string `json:"url"`
+}
+
+func (o GitObject) String() string {
+	return Stringify(o)
+}
+
+// createRefRequest represents the payload for creating a reference.
+type createRefRequest struct {
+	Ref *string `json:"ref"`
+	SHA *string `json:"sha"`
+}
+
+// updateRefRequest represents the payload for updating a reference.
+type updateRefRequest struct {
+	SHA   *string `json:"sha"`
+	Force *bool   `json:"force"`
+}
+
+// GetRef fetches a single reference in a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/git/refs#get-a-reference
+//
+//meta:operation GET /repos/{owner}/{repo}/git/ref/{ref}
+func (s *GitService) GetRef(ctx context.Context, owner string, repo string, ref string) (*Reference, *Response, error) {
+	ref = strings.TrimPrefix(ref, "refs/")
+	u := fmt.Sprintf("repos/%v/%v/git/ref/%v", owner, repo, refURLEscape(ref))
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	r := new(Reference)
+	resp, err := s.client.Do(ctx, req, r)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return r, resp, nil
+}
+
+// refURLEscape escapes every path segment of the given ref. Those must
+// not contain escaped "/" - as "%2F" - or github will not recognize it.
+func refURLEscape(ref string) string {
+	parts := strings.Split(ref, "/")
+	for i, s := range parts {
+		parts[i] = url.PathEscape(s)
+	}
+	return strings.Join(parts, "/")
+}
+
+// ReferenceListOptions specifies optional parameters to the
+// GitService.ListMatchingRefs method.
+type ReferenceListOptions struct {
+	Ref string `url:"-"`
+
+	ListOptions
+}
+
+// ListMatchingRefs lists references in a repository that match a supplied ref.
+// Use an empty ref to list all references.
+//
+// GitHub API docs: https://docs.github.com/rest/git/refs#list-matching-references
+//
+//meta:operation GET /repos/{owner}/{repo}/git/matching-refs/{ref}
+func (s *GitService) ListMatchingRefs(ctx context.Context, owner, repo string, opts *ReferenceListOptions) ([]*Reference, *Response, error) {
+	var ref string
+	if opts != nil {
+		ref = strings.TrimPrefix(opts.Ref, "refs/")
+	}
+	u := fmt.Sprintf("repos/%v/%v/git/matching-refs/%v", owner, repo, refURLEscape(ref))
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var rs []*Reference
+	resp, err := s.client.Do(ctx, req, &rs)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return rs, resp, nil
+}
+
+// CreateRef creates a new ref in a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/git/refs#create-a-reference
+//
+//meta:operation POST /repos/{owner}/{repo}/git/refs
+func (s *GitService) CreateRef(ctx context.Context, owner string, repo string, ref *Reference) (*Reference, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/git/refs", owner, repo)
+	req, err := s.client.NewRequest("POST", u, &createRefRequest{
+		// back-compat with previous behavior that didn't require 'refs/' prefix
+		Ref: Ptr("refs/" + strings.TrimPrefix(*ref.Ref, "refs/")),
+		SHA: ref.Object.SHA,
+	})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	r := new(Reference)
+	resp, err := s.client.Do(ctx, req, r)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return r, resp, nil
+}
+
+// UpdateRef updates an existing ref in a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/git/refs#update-a-reference
+//
+//meta:operation PATCH /repos/{owner}/{repo}/git/refs/{ref}
+func (s *GitService) UpdateRef(ctx context.Context, owner string, repo string, ref *Reference, force bool) (*Reference, *Response, error) {
+	refPath := strings.TrimPrefix(*ref.Ref, "refs/")
+	u := fmt.Sprintf("repos/%v/%v/git/refs/%v", owner, repo, refURLEscape(refPath))
+	req, err := s.client.NewRequest("PATCH", u, &updateRefRequest{
+		SHA:   ref.Object.SHA,
+		Force: &force,
+	})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	r := new(Reference)
+	resp, err := s.client.Do(ctx, req, r)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return r, resp, nil
+}
+
+// DeleteRef deletes a ref from a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/git/refs#delete-a-reference
+//
+//meta:operation DELETE /repos/{owner}/{repo}/git/refs/{ref}
+func (s *GitService) DeleteRef(ctx context.Context, owner string, repo string, ref string) (*Response, error) {
+	ref = strings.TrimPrefix(ref, "refs/")
+	u := fmt.Sprintf("repos/%v/%v/git/refs/%v", owner, repo, refURLEscape(ref))
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/git_tags.go

@@ -0,0 +1,88 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// Tag represents a tag object.
+type Tag struct {
+	Tag          *string                `json:"tag,omitempty"`
+	SHA          *string                `json:"sha,omitempty"`
+	URL          *string                `json:"url,omitempty"`
+	Message      *string                `json:"message,omitempty"`
+	Tagger       *CommitAuthor          `json:"tagger,omitempty"`
+	Object       *GitObject             `json:"object,omitempty"`
+	Verification *SignatureVerification `json:"verification,omitempty"`
+	NodeID       *string                `json:"node_id,omitempty"`
+}
+
+// createTagRequest represents the body of a CreateTag request. This is mostly
+// identical to Tag with the exception that the object SHA and Type are
+// top-level fields, rather than being nested inside a JSON object.
+type createTagRequest struct {
+	Tag     *string       `json:"tag,omitempty"`
+	Message *string       `json:"message,omitempty"`
+	Object  *string       `json:"object,omitempty"`
+	Type    *string       `json:"type,omitempty"`
+	Tagger  *CommitAuthor `json:"tagger,omitempty"`
+}
+
+// GetTag fetches a tag from a repo given a SHA.
+//
+// GitHub API docs: https://docs.github.com/rest/git/tags#get-a-tag
+//
+//meta:operation GET /repos/{owner}/{repo}/git/tags/{tag_sha}
+func (s *GitService) GetTag(ctx context.Context, owner string, repo string, sha string) (*Tag, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/git/tags/%v", owner, repo, sha)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	tag := new(Tag)
+	resp, err := s.client.Do(ctx, req, tag)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return tag, resp, nil
+}
+
+// CreateTag creates a tag object.
+//
+// GitHub API docs: https://docs.github.com/rest/git/tags#create-a-tag-object
+//
+//meta:operation POST /repos/{owner}/{repo}/git/tags
+func (s *GitService) CreateTag(ctx context.Context, owner string, repo string, tag *Tag) (*Tag, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/git/tags", owner, repo)
+
+	// convert Tag into a createTagRequest
+	tagRequest := &createTagRequest{
+		Tag:     tag.Tag,
+		Message: tag.Message,
+		Tagger:  tag.Tagger,
+	}
+	if tag.Object != nil {
+		tagRequest.Object = tag.Object.SHA
+		tagRequest.Type = tag.Object.Type
+	}
+
+	req, err := s.client.NewRequest("POST", u, tagRequest)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	t := new(Tag)
+	resp, err := s.client.Do(ctx, req, t)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return t, resp, nil
+}

vendor/github.com/google/go-github/v69/github/git_trees.go

@@ -0,0 +1,166 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// Tree represents a GitHub tree.
+type Tree struct {
+	SHA     *string      `json:"sha,omitempty"`
+	Entries []*TreeEntry `json:"tree,omitempty"`
+
+	// Truncated is true if the number of items in the tree
+	// exceeded GitHub's maximum limit and the Entries were truncated
+	// in the response. Only populated for requests that fetch
+	// trees like Git.GetTree.
+	Truncated *bool `json:"truncated,omitempty"`
+}
+
+func (t Tree) String() string {
+	return Stringify(t)
+}
+
+// TreeEntry represents the contents of a tree structure. TreeEntry can
+// represent either a blob, a commit (in the case of a submodule), or another
+// tree.
+type TreeEntry struct {
+	SHA     *string `json:"sha,omitempty"`
+	Path    *string `json:"path,omitempty"`
+	Mode    *string `json:"mode,omitempty"`
+	Type    *string `json:"type,omitempty"`
+	Size    *int    `json:"size,omitempty"`
+	Content *string `json:"content,omitempty"`
+	URL     *string `json:"url,omitempty"`
+}
+
+func (t TreeEntry) String() string {
+	return Stringify(t)
+}
+
+// treeEntryWithFileDelete is used internally to delete a file whose
+// Content and SHA fields are empty. It does this by removing the "omitempty"
+// tag modifier on the SHA field which causes the GitHub API to receive
+// {"sha":null} and thereby delete the file.
+type treeEntryWithFileDelete struct {
+	SHA     *string `json:"sha"`
+	Path    *string `json:"path,omitempty"`
+	Mode    *string `json:"mode,omitempty"`
+	Type    *string `json:"type,omitempty"`
+	Size    *int    `json:"size,omitempty"`
+	Content *string `json:"content,omitempty"`
+	URL     *string `json:"url,omitempty"`
+}
+
+func (t *TreeEntry) MarshalJSON() ([]byte, error) {
+	if t.SHA == nil && t.Content == nil {
+		return json.Marshal(struct {
+			SHA  *string `json:"sha"`
+			Path *string `json:"path,omitempty"`
+			Mode *string `json:"mode,omitempty"`
+			Type *string `json:"type,omitempty"`
+		}{
+			nil,
+			t.Path,
+			t.Mode,
+			t.Type,
+		})
+	}
+	return json.Marshal(struct {
+		SHA     *string `json:"sha,omitempty"`
+		Path    *string `json:"path,omitempty"`
+		Mode    *string `json:"mode,omitempty"`
+		Type    *string `json:"type,omitempty"`
+		Size    *int    `json:"size,omitempty"`
+		Content *string `json:"content,omitempty"`
+		URL     *string `json:"url,omitempty"`
+	}{
+		SHA:     t.SHA,
+		Path:    t.Path,
+		Mode:    t.Mode,
+		Type:    t.Type,
+		Size:    t.Size,
+		Content: t.Content,
+		URL:     t.URL,
+	})
+}
+
+// GetTree fetches the Tree object for a given sha hash from a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/git/trees#get-a-tree
+//
+//meta:operation GET /repos/{owner}/{repo}/git/trees/{tree_sha}
+func (s *GitService) GetTree(ctx context.Context, owner string, repo string, sha string, recursive bool) (*Tree, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/git/trees/%v", owner, repo, sha)
+	if recursive {
+		u += "?recursive=1"
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	t := new(Tree)
+	resp, err := s.client.Do(ctx, req, t)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return t, resp, nil
+}
+
+// createTree represents the body of a CreateTree request.
+type createTree struct {
+	BaseTree string        `json:"base_tree,omitempty"`
+	Entries  []interface{} `json:"tree"`
+}
+
+// CreateTree creates a new tree in a repository. If both a tree and a nested
+// path modifying that tree are specified, it will overwrite the contents of
+// that tree with the new path contents and write a new tree out.
+//
+// GitHub API docs: https://docs.github.com/rest/git/trees#create-a-tree
+//
+//meta:operation POST /repos/{owner}/{repo}/git/trees
+func (s *GitService) CreateTree(ctx context.Context, owner string, repo string, baseTree string, entries []*TreeEntry) (*Tree, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/git/trees", owner, repo)
+
+	newEntries := make([]interface{}, 0, len(entries))
+	for _, entry := range entries {
+		if entry.Content == nil && entry.SHA == nil {
+			newEntries = append(newEntries, treeEntryWithFileDelete{
+				Path: entry.Path,
+				Mode: entry.Mode,
+				Type: entry.Type,
+				Size: entry.Size,
+				URL:  entry.URL,
+			})
+			continue
+		}
+		newEntries = append(newEntries, entry)
+	}
+
+	body := &createTree{
+		BaseTree: baseTree,
+		Entries:  newEntries,
+	}
+	req, err := s.client.NewRequest("POST", u, body)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	t := new(Tree)
+	resp, err := s.client.Do(ctx, req, t)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return t, resp, nil
+}

vendor/github.com/google/go-github/v69/github/gitignore.go

@@ -0,0 +1,68 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// GitignoresService provides access to the gitignore related functions in the
+// GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/gitignore/
+type GitignoresService service
+
+// Gitignore represents a .gitignore file as returned by the GitHub API.
+type Gitignore struct {
+	Name   *string `json:"name,omitempty"`
+	Source *string `json:"source,omitempty"`
+}
+
+func (g Gitignore) String() string {
+	return Stringify(g)
+}
+
+// List all available Gitignore templates.
+//
+// GitHub API docs: https://docs.github.com/rest/gitignore/gitignore#get-all-gitignore-templates
+//
+//meta:operation GET /gitignore/templates
+func (s *GitignoresService) List(ctx context.Context) ([]string, *Response, error) {
+	req, err := s.client.NewRequest("GET", "gitignore/templates", nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var availableTemplates []string
+	resp, err := s.client.Do(ctx, req, &availableTemplates)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return availableTemplates, resp, nil
+}
+
+// Get a Gitignore by name.
+//
+// GitHub API docs: https://docs.github.com/rest/gitignore/gitignore#get-a-gitignore-template
+//
+//meta:operation GET /gitignore/templates/{name}
+func (s *GitignoresService) Get(ctx context.Context, name string) (*Gitignore, *Response, error) {
+	u := fmt.Sprintf("gitignore/templates/%v", name)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	gitignore := new(Gitignore)
+	resp, err := s.client.Do(ctx, req, gitignore)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return gitignore, resp, nil
+}

vendor/github.com/google/go-github/v69/github/interactions.go

@@ -0,0 +1,28 @@
+// Copyright 2018 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+// InteractionsService handles communication with the repository and organization related
+// methods of the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/interactions/
+type InteractionsService service
+
+// InteractionRestriction represents the interaction restrictions for repository and organization.
+type InteractionRestriction struct {
+	// Specifies the group of GitHub users who can
+	// comment, open issues, or create pull requests for the given repository.
+	// Possible values are: "existing_users", "contributors_only" and "collaborators_only".
+	Limit *string `json:"limit,omitempty"`
+
+	// Origin specifies the type of the resource to interact with.
+	// Possible values are: "repository" and "organization".
+	Origin *string `json:"origin,omitempty"`
+
+	// ExpiresAt specifies the time after which the interaction restrictions expire.
+	// The default expiry time is 24 hours from the time restriction is created.
+	ExpiresAt *Timestamp `json:"expires_at,omitempty"`
+}

vendor/github.com/google/go-github/v69/github/interactions_orgs.go

@@ -0,0 +1,86 @@
+// Copyright 2019 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// GetRestrictionsForOrg fetches the interaction restrictions for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/interactions/orgs#get-interaction-restrictions-for-an-organization
+//
+//meta:operation GET /orgs/{org}/interaction-limits
+func (s *InteractionsService) GetRestrictionsForOrg(ctx context.Context, organization string) (*InteractionRestriction, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/interaction-limits", organization)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeInteractionRestrictionsPreview)
+
+	organizationInteractions := new(InteractionRestriction)
+
+	resp, err := s.client.Do(ctx, req, organizationInteractions)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return organizationInteractions, resp, nil
+}
+
+// UpdateRestrictionsForOrg adds or updates the interaction restrictions for an organization.
+//
+// limit specifies the group of GitHub users who can comment, open issues, or create pull requests
+// in public repositories for the given organization.
+// Possible values are: "existing_users", "contributors_only", "collaborators_only".
+//
+// GitHub API docs: https://docs.github.com/rest/interactions/orgs#set-interaction-restrictions-for-an-organization
+//
+//meta:operation PUT /orgs/{org}/interaction-limits
+func (s *InteractionsService) UpdateRestrictionsForOrg(ctx context.Context, organization, limit string) (*InteractionRestriction, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/interaction-limits", organization)
+
+	interaction := &InteractionRestriction{Limit: Ptr(limit)}
+
+	req, err := s.client.NewRequest("PUT", u, interaction)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeInteractionRestrictionsPreview)
+
+	organizationInteractions := new(InteractionRestriction)
+
+	resp, err := s.client.Do(ctx, req, organizationInteractions)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return organizationInteractions, resp, nil
+}
+
+// RemoveRestrictionsFromOrg removes the interaction restrictions for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/interactions/orgs#remove-interaction-restrictions-for-an-organization
+//
+//meta:operation DELETE /orgs/{org}/interaction-limits
+func (s *InteractionsService) RemoveRestrictionsFromOrg(ctx context.Context, organization string) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/interaction-limits", organization)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeInteractionRestrictionsPreview)
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/interactions_repos.go

@@ -0,0 +1,86 @@
+// Copyright 2018 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// GetRestrictionsForRepo fetches the interaction restrictions for a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/interactions/repos#get-interaction-restrictions-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/interaction-limits
+func (s *InteractionsService) GetRestrictionsForRepo(ctx context.Context, owner, repo string) (*InteractionRestriction, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/interaction-limits", owner, repo)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeInteractionRestrictionsPreview)
+
+	repositoryInteractions := new(InteractionRestriction)
+
+	resp, err := s.client.Do(ctx, req, repositoryInteractions)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return repositoryInteractions, resp, nil
+}
+
+// UpdateRestrictionsForRepo adds or updates the interaction restrictions for a repository.
+//
+// limit specifies the group of GitHub users who can comment, open issues, or create pull requests
+// for the given repository.
+// Possible values are: "existing_users", "contributors_only", "collaborators_only".
+//
+// GitHub API docs: https://docs.github.com/rest/interactions/repos#set-interaction-restrictions-for-a-repository
+//
+//meta:operation PUT /repos/{owner}/{repo}/interaction-limits
+func (s *InteractionsService) UpdateRestrictionsForRepo(ctx context.Context, owner, repo, limit string) (*InteractionRestriction, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/interaction-limits", owner, repo)
+
+	interaction := &InteractionRestriction{Limit: Ptr(limit)}
+
+	req, err := s.client.NewRequest("PUT", u, interaction)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeInteractionRestrictionsPreview)
+
+	repositoryInteractions := new(InteractionRestriction)
+
+	resp, err := s.client.Do(ctx, req, repositoryInteractions)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return repositoryInteractions, resp, nil
+}
+
+// RemoveRestrictionsFromRepo removes the interaction restrictions for a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/interactions/repos#remove-interaction-restrictions-for-a-repository
+//
+//meta:operation DELETE /repos/{owner}/{repo}/interaction-limits
+func (s *InteractionsService) RemoveRestrictionsFromRepo(ctx context.Context, owner, repo string) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/interaction-limits", owner, repo)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeInteractionRestrictionsPreview)
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/issue_import.go

@@ -0,0 +1,154 @@
+// Copyright 2020 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// IssueImportService handles communication with the issue import related
+// methods of the Issue Import GitHub API.
+type IssueImportService service
+
+// IssueImportRequest represents a request to create an issue.
+//
+// https://gist.github.com/jonmagic/5282384165e0f86ef105#supported-issue-and-comment-fields
+type IssueImportRequest struct {
+	IssueImport IssueImport `json:"issue"`
+	Comments    []*Comment  `json:"comments,omitempty"`
+}
+
+// IssueImport represents body of issue to import.
+type IssueImport struct {
+	Title     string     `json:"title"`
+	Body      string     `json:"body"`
+	CreatedAt *Timestamp `json:"created_at,omitempty"`
+	ClosedAt  *Timestamp `json:"closed_at,omitempty"`
+	UpdatedAt *Timestamp `json:"updated_at,omitempty"`
+	Assignee  *string    `json:"assignee,omitempty"`
+	Milestone *int       `json:"milestone,omitempty"`
+	Closed    *bool      `json:"closed,omitempty"`
+	Labels    []string   `json:"labels,omitempty"`
+}
+
+// Comment represents comments of issue to import.
+type Comment struct {
+	CreatedAt *Timestamp `json:"created_at,omitempty"`
+	Body      string     `json:"body"`
+}
+
+// IssueImportResponse represents the response of an issue import create request.
+//
+// https://gist.github.com/jonmagic/5282384165e0f86ef105#import-issue-response
+type IssueImportResponse struct {
+	ID               *int                `json:"id,omitempty"`
+	Status           *string             `json:"status,omitempty"`
+	URL              *string             `json:"url,omitempty"`
+	ImportIssuesURL  *string             `json:"import_issues_url,omitempty"`
+	RepositoryURL    *string             `json:"repository_url,omitempty"`
+	CreatedAt        *Timestamp          `json:"created_at,omitempty"`
+	UpdatedAt        *Timestamp          `json:"updated_at,omitempty"`
+	Message          *string             `json:"message,omitempty"`
+	DocumentationURL *string             `json:"documentation_url,omitempty"`
+	Errors           []*IssueImportError `json:"errors,omitempty"`
+}
+
+// IssueImportError represents errors of an issue import create request.
+type IssueImportError struct {
+	Location *string `json:"location,omitempty"`
+	Resource *string `json:"resource,omitempty"`
+	Field    *string `json:"field,omitempty"`
+	Value    *string `json:"value,omitempty"`
+	Code     *string `json:"code,omitempty"`
+}
+
+// Create a new imported issue on the specified repository.
+//
+// GitHub API docs: https://gist.github.com/jonmagic/5282384165e0f86ef105#start-an-issue-import
+//
+//meta:operation POST /repos/{owner}/{repo}/import/issues
+func (s *IssueImportService) Create(ctx context.Context, owner, repo string, issue *IssueImportRequest) (*IssueImportResponse, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/import/issues", owner, repo)
+	req, err := s.client.NewRequest("POST", u, issue)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept headers when APIs fully launch.
+	req.Header.Set("Accept", mediaTypeIssueImportAPI)
+
+	i := new(IssueImportResponse)
+	resp, err := s.client.Do(ctx, req, i)
+	if err != nil {
+		aerr, ok := err.(*AcceptedError)
+		if ok {
+			if err := json.Unmarshal(aerr.Raw, i); err != nil {
+				return i, resp, err
+			}
+			return i, resp, err
+		}
+		return nil, resp, err
+	}
+
+	return i, resp, nil
+}
+
+// CheckStatus checks the status of an imported issue.
+//
+// GitHub API docs: https://gist.github.com/jonmagic/5282384165e0f86ef105#import-status-request
+//
+//meta:operation GET /repos/{owner}/{repo}/import/issues/{issue_number}
+func (s *IssueImportService) CheckStatus(ctx context.Context, owner, repo string, issueID int64) (*IssueImportResponse, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/import/issues/%v", owner, repo, issueID)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept headers when APIs fully launch.
+	req.Header.Set("Accept", mediaTypeIssueImportAPI)
+
+	i := new(IssueImportResponse)
+	resp, err := s.client.Do(ctx, req, i)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return i, resp, nil
+}
+
+// CheckStatusSince checks the status of multiple imported issues since a given date.
+//
+// GitHub API docs: https://gist.github.com/jonmagic/5282384165e0f86ef105#check-status-of-multiple-issues
+//
+//meta:operation GET /repos/{owner}/{repo}/import/issues
+func (s *IssueImportService) CheckStatusSince(ctx context.Context, owner, repo string, since Timestamp) ([]*IssueImportResponse, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/import/issues?since=%v", owner, repo, since.Format("2006-01-02"))
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept headers when APIs fully launch.
+	req.Header.Set("Accept", mediaTypeIssueImportAPI)
+
+	var b bytes.Buffer
+	resp, err := s.client.Do(ctx, req, &b)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	var i []*IssueImportResponse
+	err = json.Unmarshal(b.Bytes(), &i)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return i, resp, nil
+}

vendor/github.com/google/go-github/v69/github/issues.go

@@ -0,0 +1,396 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+// IssuesService handles communication with the issue related
+// methods of the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/
+type IssuesService service
+
+// Issue represents a GitHub issue on a repository.
+//
+// Note: As far as the GitHub API is concerned, every pull request is an issue,
+// but not every issue is a pull request. Some endpoints, events, and webhooks
+// may also return pull requests via this struct. If PullRequestLinks is nil,
+// this is an issue, and if PullRequestLinks is not nil, this is a pull request.
+// The IsPullRequest helper method can be used to check that.
+type Issue struct {
+	ID     *int64  `json:"id,omitempty"`
+	Number *int    `json:"number,omitempty"`
+	State  *string `json:"state,omitempty"`
+	// StateReason can be one of: "completed", "not_planned", "reopened".
+	StateReason       *string           `json:"state_reason,omitempty"`
+	Locked            *bool             `json:"locked,omitempty"`
+	Title             *string           `json:"title,omitempty"`
+	Body              *string           `json:"body,omitempty"`
+	AuthorAssociation *string           `json:"author_association,omitempty"`
+	User              *User             `json:"user,omitempty"`
+	Labels            []*Label          `json:"labels,omitempty"`
+	Assignee          *User             `json:"assignee,omitempty"`
+	Comments          *int              `json:"comments,omitempty"`
+	ClosedAt          *Timestamp        `json:"closed_at,omitempty"`
+	CreatedAt         *Timestamp        `json:"created_at,omitempty"`
+	UpdatedAt         *Timestamp        `json:"updated_at,omitempty"`
+	ClosedBy          *User             `json:"closed_by,omitempty"`
+	URL               *string           `json:"url,omitempty"`
+	HTMLURL           *string           `json:"html_url,omitempty"`
+	CommentsURL       *string           `json:"comments_url,omitempty"`
+	EventsURL         *string           `json:"events_url,omitempty"`
+	LabelsURL         *string           `json:"labels_url,omitempty"`
+	RepositoryURL     *string           `json:"repository_url,omitempty"`
+	Milestone         *Milestone        `json:"milestone,omitempty"`
+	PullRequestLinks  *PullRequestLinks `json:"pull_request,omitempty"`
+	Repository        *Repository       `json:"repository,omitempty"`
+	Reactions         *Reactions        `json:"reactions,omitempty"`
+	Assignees         []*User           `json:"assignees,omitempty"`
+	NodeID            *string           `json:"node_id,omitempty"`
+	Draft             *bool             `json:"draft,omitempty"`
+	Type              *IssueType        `json:"type,omitempty"`
+
+	// TextMatches is only populated from search results that request text matches
+	// See: search.go and https://docs.github.com/rest/search/#text-match-metadata
+	TextMatches []*TextMatch `json:"text_matches,omitempty"`
+
+	// ActiveLockReason is populated only when LockReason is provided while locking the issue.
+	// Possible values are: "off-topic", "too heated", "resolved", and "spam".
+	ActiveLockReason *string `json:"active_lock_reason,omitempty"`
+}
+
+func (i Issue) String() string {
+	return Stringify(i)
+}
+
+// IsPullRequest reports whether the issue is also a pull request. It uses the
+// method recommended by GitHub's API documentation, which is to check whether
+// PullRequestLinks is non-nil.
+func (i Issue) IsPullRequest() bool {
+	return i.PullRequestLinks != nil
+}
+
+// IssueRequest represents a request to create/edit an issue.
+// It is separate from Issue above because otherwise Labels
+// and Assignee fail to serialize to the correct JSON.
+type IssueRequest struct {
+	Title    *string   `json:"title,omitempty"`
+	Body     *string   `json:"body,omitempty"`
+	Labels   *[]string `json:"labels,omitempty"`
+	Assignee *string   `json:"assignee,omitempty"`
+	State    *string   `json:"state,omitempty"`
+	// StateReason can be 'completed' or 'not_planned'.
+	StateReason *string   `json:"state_reason,omitempty"`
+	Milestone   *int      `json:"milestone,omitempty"`
+	Assignees   *[]string `json:"assignees,omitempty"`
+}
+
+// IssueListOptions specifies the optional parameters to the IssuesService.List
+// and IssuesService.ListByOrg methods.
+type IssueListOptions struct {
+	// Filter specifies which issues to list. Possible values are: assigned,
+	// created, mentioned, subscribed, all. Default is "assigned".
+	Filter string `url:"filter,omitempty"`
+
+	// State filters issues based on their state. Possible values are: open,
+	// closed, all. Default is "open".
+	State string `url:"state,omitempty"`
+
+	// Labels filters issues based on their label.
+	Labels []string `url:"labels,comma,omitempty"`
+
+	// Sort specifies how to sort issues. Possible values are: created, updated,
+	// and comments. Default value is "created".
+	Sort string `url:"sort,omitempty"`
+
+	// Direction in which to sort issues. Possible values are: asc, desc.
+	// Default is "desc".
+	Direction string `url:"direction,omitempty"`
+
+	// Since filters issues by time.
+	Since time.Time `url:"since,omitempty"`
+
+	ListOptions
+}
+
+// PullRequestLinks object is added to the Issue object when it's an issue included
+// in the IssueCommentEvent webhook payload, if the webhook is fired by a comment on a PR.
+type PullRequestLinks struct {
+	URL      *string    `json:"url,omitempty"`
+	HTMLURL  *string    `json:"html_url,omitempty"`
+	DiffURL  *string    `json:"diff_url,omitempty"`
+	PatchURL *string    `json:"patch_url,omitempty"`
+	MergedAt *Timestamp `json:"merged_at,omitempty"`
+}
+
+// IssueType represents the type of issue.
+// For now it shows up when receiveing an Issue event.
+type IssueType struct {
+	ID          *int64     `json:"id,omitempty"`
+	NodeID      *string    `json:"node_id,omitempty"`
+	Name        *string    `json:"name,omitempty"`
+	Description *string    `json:"description,omitempty"`
+	Color       *string    `json:"color,omitempty"`
+	CreatedAt   *Timestamp `json:"created_at,omitempty"`
+	UpdatedAt   *Timestamp `json:"updated_at,omitempty"`
+}
+
+// List the issues for the authenticated user. If all is true, list issues
+// across all the user's visible repositories including owned, member, and
+// organization repositories; if false, list only owned and member
+// repositories.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/issues#list-issues-assigned-to-the-authenticated-user
+// GitHub API docs: https://docs.github.com/rest/issues/issues#list-user-account-issues-assigned-to-the-authenticated-user
+//
+//meta:operation GET /issues
+//meta:operation GET /user/issues
+func (s *IssuesService) List(ctx context.Context, all bool, opts *IssueListOptions) ([]*Issue, *Response, error) {
+	var u string
+	if all {
+		u = "issues"
+	} else {
+		u = "user/issues"
+	}
+	return s.listIssues(ctx, u, opts)
+}
+
+// ListByOrg fetches the issues in the specified organization for the
+// authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/issues#list-organization-issues-assigned-to-the-authenticated-user
+//
+//meta:operation GET /orgs/{org}/issues
+func (s *IssuesService) ListByOrg(ctx context.Context, org string, opts *IssueListOptions) ([]*Issue, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/issues", org)
+	return s.listIssues(ctx, u, opts)
+}
+
+func (s *IssuesService) listIssues(ctx context.Context, u string, opts *IssueListOptions) ([]*Issue, *Response, error) {
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launch.
+	req.Header.Set("Accept", mediaTypeReactionsPreview)
+
+	var issues []*Issue
+	resp, err := s.client.Do(ctx, req, &issues)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return issues, resp, nil
+}
+
+// IssueListByRepoOptions specifies the optional parameters to the
+// IssuesService.ListByRepo method.
+type IssueListByRepoOptions struct {
+	// Milestone limits issues for the specified milestone. Possible values are
+	// a milestone number, "none" for issues with no milestone, "*" for issues
+	// with any milestone.
+	Milestone string `url:"milestone,omitempty"`
+
+	// State filters issues based on their state. Possible values are: open,
+	// closed, all. Default is "open".
+	State string `url:"state,omitempty"`
+
+	// Assignee filters issues based on their assignee. Possible values are a
+	// user name, "none" for issues that are not assigned, "*" for issues with
+	// any assigned user.
+	Assignee string `url:"assignee,omitempty"`
+
+	// Creator filters issues based on their creator.
+	Creator string `url:"creator,omitempty"`
+
+	// Mentioned filters issues to those mentioned a specific user.
+	Mentioned string `url:"mentioned,omitempty"`
+
+	// Labels filters issues based on their label.
+	Labels []string `url:"labels,omitempty,comma"`
+
+	// Sort specifies how to sort issues. Possible values are: created, updated,
+	// and comments. Default value is "created".
+	Sort string `url:"sort,omitempty"`
+
+	// Direction in which to sort issues. Possible values are: asc, desc.
+	// Default is "desc".
+	Direction string `url:"direction,omitempty"`
+
+	// Since filters issues by time.
+	Since time.Time `url:"since,omitempty"`
+
+	ListOptions
+}
+
+// ListByRepo lists the issues for the specified repository.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/issues#list-repository-issues
+//
+//meta:operation GET /repos/{owner}/{repo}/issues
+func (s *IssuesService) ListByRepo(ctx context.Context, owner string, repo string, opts *IssueListByRepoOptions) ([]*Issue, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeReactionsPreview)
+
+	var issues []*Issue
+	resp, err := s.client.Do(ctx, req, &issues)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return issues, resp, nil
+}
+
+// Get a single issue.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/issues#get-an-issue
+//
+//meta:operation GET /repos/{owner}/{repo}/issues/{issue_number}
+func (s *IssuesService) Get(ctx context.Context, owner string, repo string, number int) (*Issue, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/%d", owner, repo, number)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launch.
+	req.Header.Set("Accept", mediaTypeReactionsPreview)
+
+	issue := new(Issue)
+	resp, err := s.client.Do(ctx, req, issue)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return issue, resp, nil
+}
+
+// Create a new issue on the specified repository.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/issues#create-an-issue
+//
+//meta:operation POST /repos/{owner}/{repo}/issues
+func (s *IssuesService) Create(ctx context.Context, owner string, repo string, issue *IssueRequest) (*Issue, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues", owner, repo)
+	req, err := s.client.NewRequest("POST", u, issue)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	i := new(Issue)
+	resp, err := s.client.Do(ctx, req, i)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return i, resp, nil
+}
+
+// Edit (update) an issue.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/issues#update-an-issue
+//
+//meta:operation PATCH /repos/{owner}/{repo}/issues/{issue_number}
+func (s *IssuesService) Edit(ctx context.Context, owner string, repo string, number int, issue *IssueRequest) (*Issue, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/%d", owner, repo, number)
+	req, err := s.client.NewRequest("PATCH", u, issue)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	i := new(Issue)
+	resp, err := s.client.Do(ctx, req, i)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return i, resp, nil
+}
+
+// RemoveMilestone removes a milestone from an issue.
+//
+// This is a helper method to explicitly update an issue with a `null` milestone, thereby removing it.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/issues#update-an-issue
+//
+//meta:operation PATCH /repos/{owner}/{repo}/issues/{issue_number}
+func (s *IssuesService) RemoveMilestone(ctx context.Context, owner, repo string, issueNumber int) (*Issue, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/%v", owner, repo, issueNumber)
+	req, err := s.client.NewRequest("PATCH", u, &struct {
+		Milestone *Milestone `json:"milestone"`
+	}{})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	i := new(Issue)
+	resp, err := s.client.Do(ctx, req, i)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return i, resp, nil
+}
+
+// LockIssueOptions specifies the optional parameters to the
+// IssuesService.Lock method.
+type LockIssueOptions struct {
+	// LockReason specifies the reason to lock this issue.
+	// Providing a lock reason can help make it clearer to contributors why an issue
+	// was locked. Possible values are: "off-topic", "too heated", "resolved", and "spam".
+	LockReason string `json:"lock_reason,omitempty"`
+}
+
+// Lock an issue's conversation.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/issues#lock-an-issue
+//
+//meta:operation PUT /repos/{owner}/{repo}/issues/{issue_number}/lock
+func (s *IssuesService) Lock(ctx context.Context, owner string, repo string, number int, opts *LockIssueOptions) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/%d/lock", owner, repo, number)
+	req, err := s.client.NewRequest("PUT", u, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// Unlock an issue's conversation.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/issues#unlock-an-issue
+//
+//meta:operation DELETE /repos/{owner}/{repo}/issues/{issue_number}/lock
+func (s *IssuesService) Unlock(ctx context.Context, owner string, repo string, number int) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/%d/lock", owner, repo, number)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/issues_assignees.go

@@ -0,0 +1,103 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ListAssignees fetches all available assignees (owners and collaborators) to
+// which issues may be assigned.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/assignees#list-assignees
+//
+//meta:operation GET /repos/{owner}/{repo}/assignees
+func (s *IssuesService) ListAssignees(ctx context.Context, owner, repo string, opts *ListOptions) ([]*User, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/assignees", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var assignees []*User
+	resp, err := s.client.Do(ctx, req, &assignees)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return assignees, resp, nil
+}
+
+// IsAssignee checks if a user is an assignee for the specified repository.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/assignees#check-if-a-user-can-be-assigned
+//
+//meta:operation GET /repos/{owner}/{repo}/assignees/{assignee}
+func (s *IssuesService) IsAssignee(ctx context.Context, owner, repo, user string) (bool, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/assignees/%v", owner, repo, user)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return false, nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	assignee, err := parseBoolResponse(err)
+	return assignee, resp, err
+}
+
+// AddAssignees adds the provided GitHub users as assignees to the issue.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/assignees#add-assignees-to-an-issue
+//
+//meta:operation POST /repos/{owner}/{repo}/issues/{issue_number}/assignees
+func (s *IssuesService) AddAssignees(ctx context.Context, owner, repo string, number int, assignees []string) (*Issue, *Response, error) {
+	users := &struct {
+		Assignees []string `json:"assignees,omitempty"`
+	}{Assignees: assignees}
+	u := fmt.Sprintf("repos/%v/%v/issues/%v/assignees", owner, repo, number)
+	req, err := s.client.NewRequest("POST", u, users)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	issue := &Issue{}
+	resp, err := s.client.Do(ctx, req, issue)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return issue, resp, nil
+}
+
+// RemoveAssignees removes the provided GitHub users as assignees from the issue.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/assignees#remove-assignees-from-an-issue
+//
+//meta:operation DELETE /repos/{owner}/{repo}/issues/{issue_number}/assignees
+func (s *IssuesService) RemoveAssignees(ctx context.Context, owner, repo string, number int, assignees []string) (*Issue, *Response, error) {
+	users := &struct {
+		Assignees []string `json:"assignees,omitempty"`
+	}{Assignees: assignees}
+	u := fmt.Sprintf("repos/%v/%v/issues/%v/assignees", owner, repo, number)
+	req, err := s.client.NewRequest("DELETE", u, users)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	issue := &Issue{}
+	resp, err := s.client.Do(ctx, req, issue)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return issue, resp, nil
+}

vendor/github.com/google/go-github/v69/github/issues_comments.go

@@ -0,0 +1,165 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+// IssueComment represents a comment left on an issue.
+type IssueComment struct {
+	ID        *int64     `json:"id,omitempty"`
+	NodeID    *string    `json:"node_id,omitempty"`
+	Body      *string    `json:"body,omitempty"`
+	User      *User      `json:"user,omitempty"`
+	Reactions *Reactions `json:"reactions,omitempty"`
+	CreatedAt *Timestamp `json:"created_at,omitempty"`
+	UpdatedAt *Timestamp `json:"updated_at,omitempty"`
+	// AuthorAssociation is the comment author's relationship to the issue's repository.
+	// Possible values are "COLLABORATOR", "CONTRIBUTOR", "FIRST_TIMER", "FIRST_TIME_CONTRIBUTOR", "MEMBER", "OWNER", or "NONE".
+	AuthorAssociation *string `json:"author_association,omitempty"`
+	URL               *string `json:"url,omitempty"`
+	HTMLURL           *string `json:"html_url,omitempty"`
+	IssueURL          *string `json:"issue_url,omitempty"`
+}
+
+func (i IssueComment) String() string {
+	return Stringify(i)
+}
+
+// IssueListCommentsOptions specifies the optional parameters to the
+// IssuesService.ListComments method.
+type IssueListCommentsOptions struct {
+	// Sort specifies how to sort comments. Possible values are: created, updated.
+	Sort *string `url:"sort,omitempty"`
+
+	// Direction in which to sort comments. Possible values are: asc, desc.
+	Direction *string `url:"direction,omitempty"`
+
+	// Since filters comments by time.
+	Since *time.Time `url:"since,omitempty"`
+
+	ListOptions
+}
+
+// ListComments lists all comments on the specified issue. Specifying an issue
+// number of 0 will return all comments on all issues for the repository.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/comments#list-issue-comments
+// GitHub API docs: https://docs.github.com/rest/issues/comments#list-issue-comments-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/issues/comments
+//meta:operation GET /repos/{owner}/{repo}/issues/{issue_number}/comments
+func (s *IssuesService) ListComments(ctx context.Context, owner string, repo string, number int, opts *IssueListCommentsOptions) ([]*IssueComment, *Response, error) {
+	var u string
+	if number == 0 {
+		u = fmt.Sprintf("repos/%v/%v/issues/comments", owner, repo)
+	} else {
+		u = fmt.Sprintf("repos/%v/%v/issues/%d/comments", owner, repo, number)
+	}
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeReactionsPreview)
+
+	var comments []*IssueComment
+	resp, err := s.client.Do(ctx, req, &comments)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return comments, resp, nil
+}
+
+// GetComment fetches the specified issue comment.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/comments#get-an-issue-comment
+//
+//meta:operation GET /repos/{owner}/{repo}/issues/comments/{comment_id}
+func (s *IssuesService) GetComment(ctx context.Context, owner string, repo string, commentID int64) (*IssueComment, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/comments/%d", owner, repo, commentID)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeReactionsPreview)
+
+	comment := new(IssueComment)
+	resp, err := s.client.Do(ctx, req, comment)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return comment, resp, nil
+}
+
+// CreateComment creates a new comment on the specified issue.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/comments#create-an-issue-comment
+//
+//meta:operation POST /repos/{owner}/{repo}/issues/{issue_number}/comments
+func (s *IssuesService) CreateComment(ctx context.Context, owner string, repo string, number int, comment *IssueComment) (*IssueComment, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/%d/comments", owner, repo, number)
+	req, err := s.client.NewRequest("POST", u, comment)
+	if err != nil {
+		return nil, nil, err
+	}
+	c := new(IssueComment)
+	resp, err := s.client.Do(ctx, req, c)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return c, resp, nil
+}
+
+// EditComment updates an issue comment.
+// A non-nil comment.Body must be provided. Other comment fields should be left nil.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/comments#update-an-issue-comment
+//
+//meta:operation PATCH /repos/{owner}/{repo}/issues/comments/{comment_id}
+func (s *IssuesService) EditComment(ctx context.Context, owner string, repo string, commentID int64, comment *IssueComment) (*IssueComment, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/comments/%d", owner, repo, commentID)
+	req, err := s.client.NewRequest("PATCH", u, comment)
+	if err != nil {
+		return nil, nil, err
+	}
+	c := new(IssueComment)
+	resp, err := s.client.Do(ctx, req, c)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return c, resp, nil
+}
+
+// DeleteComment deletes an issue comment.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/comments#delete-an-issue-comment
+//
+//meta:operation DELETE /repos/{owner}/{repo}/issues/comments/{comment_id}
+func (s *IssuesService) DeleteComment(ctx context.Context, owner string, repo string, commentID int64) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/comments/%d", owner, repo, commentID)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/issues_events.go

@@ -0,0 +1,189 @@
+// Copyright 2014 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// IssueEvent represents an event that occurred around an Issue or Pull Request.
+type IssueEvent struct {
+	ID  *int64  `json:"id,omitempty"`
+	URL *string `json:"url,omitempty"`
+
+	// The User that generated this event.
+	Actor *User `json:"actor,omitempty"`
+
+	// The action corresponding to the event.
+	Action string `json:"action,omitempty"`
+
+	// Event identifies the actual type of Event that occurred. Possible
+	// values are:
+	//
+	//     closed
+	//       The Actor closed the issue.
+	//       If the issue was closed by commit message, CommitID holds the SHA1 hash of the commit.
+	//
+	//     merged
+	//       The Actor merged into master a branch containing a commit mentioning the issue.
+	//       CommitID holds the SHA1 of the merge commit.
+	//
+	//     referenced
+	//       The Actor committed to master a commit mentioning the issue in its commit message.
+	//       CommitID holds the SHA1 of the commit.
+	//
+	//     reopened, unlocked
+	//       The Actor did that to the issue.
+	//
+	//     locked
+	//       The Actor locked the issue.
+	//       LockReason holds the reason of locking the issue (if provided while locking).
+	//
+	//     renamed
+	//       The Actor changed the issue title from Rename.From to Rename.To.
+	//
+	//     mentioned
+	//       Someone unspecified @mentioned the Actor [sic] in an issue comment body.
+	//
+	//     assigned, unassigned
+	//       The Assigner assigned the issue to or removed the assignment from the Assignee.
+	//
+	//     labeled, unlabeled
+	//       The Actor added or removed the Label from the issue.
+	//
+	//     milestoned, demilestoned
+	//       The Actor added or removed the issue from the Milestone.
+	//
+	//     subscribed, unsubscribed
+	//       The Actor subscribed to or unsubscribed from notifications for an issue.
+	//
+	//     head_ref_deleted, head_ref_restored
+	//       The pull request’s branch was deleted or restored.
+	//
+	//    review_dismissed
+	//       The review was dismissed and `DismissedReview` will be populated below.
+	//
+	//    review_requested, review_request_removed
+	//       The Actor requested or removed the request for a review.
+	//       RequestedReviewer or RequestedTeam, and ReviewRequester will be populated below.
+	//
+	Event *string `json:"event,omitempty"`
+
+	CreatedAt *Timestamp `json:"created_at,omitempty"`
+	Issue     *Issue     `json:"issue,omitempty"`
+
+	// Only present on certain events; see above.
+	Repository            *Repository      `json:"repository,omitempty"`
+	Assignee              *User            `json:"assignee,omitempty"`
+	Assigner              *User            `json:"assigner,omitempty"`
+	CommitID              *string          `json:"commit_id,omitempty"`
+	Milestone             *Milestone       `json:"milestone,omitempty"`
+	Label                 *Label           `json:"label,omitempty"`
+	Rename                *Rename          `json:"rename,omitempty"`
+	LockReason            *string          `json:"lock_reason,omitempty"`
+	DismissedReview       *DismissedReview `json:"dismissed_review,omitempty"`
+	RequestedReviewer     *User            `json:"requested_reviewer,omitempty"`
+	RequestedTeam         *Team            `json:"requested_team,omitempty"`
+	ReviewRequester       *User            `json:"review_requester,omitempty"`
+	PerformedViaGithubApp *App             `json:"performed_via_github_app,omitempty"`
+}
+
+// DismissedReview represents details for 'dismissed_review' events.
+type DismissedReview struct {
+	// State represents the state of the dismissed review.
+	// Possible values are: "commented", "approved", and "changes_requested".
+	State             *string `json:"state,omitempty"`
+	ReviewID          *int64  `json:"review_id,omitempty"`
+	DismissalMessage  *string `json:"dismissal_message,omitempty"`
+	DismissalCommitID *string `json:"dismissal_commit_id,omitempty"`
+}
+
+// ListIssueEvents lists events for the specified issue.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/events#list-issue-events
+//
+//meta:operation GET /repos/{owner}/{repo}/issues/{issue_number}/events
+func (s *IssuesService) ListIssueEvents(ctx context.Context, owner, repo string, number int, opts *ListOptions) ([]*IssueEvent, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/%v/events", owner, repo, number)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req.Header.Set("Accept", mediaTypeProjectCardDetailsPreview)
+
+	var events []*IssueEvent
+	resp, err := s.client.Do(ctx, req, &events)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return events, resp, nil
+}
+
+// ListRepositoryEvents lists events for the specified repository.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/events#list-issue-events-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/issues/events
+func (s *IssuesService) ListRepositoryEvents(ctx context.Context, owner, repo string, opts *ListOptions) ([]*IssueEvent, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/events", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var events []*IssueEvent
+	resp, err := s.client.Do(ctx, req, &events)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return events, resp, nil
+}
+
+// GetEvent returns the specified issue event.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/events#get-an-issue-event
+//
+//meta:operation GET /repos/{owner}/{repo}/issues/events/{event_id}
+func (s *IssuesService) GetEvent(ctx context.Context, owner, repo string, id int64) (*IssueEvent, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/events/%v", owner, repo, id)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	event := new(IssueEvent)
+	resp, err := s.client.Do(ctx, req, event)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return event, resp, nil
+}
+
+// Rename contains details for 'renamed' events.
+type Rename struct {
+	From *string `json:"from,omitempty"`
+	To   *string `json:"to,omitempty"`
+}
+
+func (r Rename) String() string {
+	return Stringify(r)
+}

vendor/github.com/google/go-github/v69/github/issues_labels.go

@@ -0,0 +1,253 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// Label represents a GitHub label on an Issue.
+type Label struct {
+	ID          *int64  `json:"id,omitempty"`
+	URL         *string `json:"url,omitempty"`
+	Name        *string `json:"name,omitempty"`
+	Color       *string `json:"color,omitempty"`
+	Description *string `json:"description,omitempty"`
+	Default     *bool   `json:"default,omitempty"`
+	NodeID      *string `json:"node_id,omitempty"`
+}
+
+func (l Label) String() string {
+	return Stringify(l)
+}
+
+// ListLabels lists all labels for a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/labels#list-labels-for-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/labels
+func (s *IssuesService) ListLabels(ctx context.Context, owner string, repo string, opts *ListOptions) ([]*Label, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/labels", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var labels []*Label
+	resp, err := s.client.Do(ctx, req, &labels)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return labels, resp, nil
+}
+
+// GetLabel gets a single label.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/labels#get-a-label
+//
+//meta:operation GET /repos/{owner}/{repo}/labels/{name}
+func (s *IssuesService) GetLabel(ctx context.Context, owner string, repo string, name string) (*Label, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/labels/%v", owner, repo, name)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	label := new(Label)
+	resp, err := s.client.Do(ctx, req, label)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return label, resp, nil
+}
+
+// CreateLabel creates a new label on the specified repository.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/labels#create-a-label
+//
+//meta:operation POST /repos/{owner}/{repo}/labels
+func (s *IssuesService) CreateLabel(ctx context.Context, owner string, repo string, label *Label) (*Label, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/labels", owner, repo)
+	req, err := s.client.NewRequest("POST", u, label)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	l := new(Label)
+	resp, err := s.client.Do(ctx, req, l)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return l, resp, nil
+}
+
+// EditLabel edits a label.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/labels#update-a-label
+//
+//meta:operation PATCH /repos/{owner}/{repo}/labels/{name}
+func (s *IssuesService) EditLabel(ctx context.Context, owner string, repo string, name string, label *Label) (*Label, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/labels/%v", owner, repo, name)
+	req, err := s.client.NewRequest("PATCH", u, label)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	l := new(Label)
+	resp, err := s.client.Do(ctx, req, l)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return l, resp, nil
+}
+
+// DeleteLabel deletes a label.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/labels#delete-a-label
+//
+//meta:operation DELETE /repos/{owner}/{repo}/labels/{name}
+func (s *IssuesService) DeleteLabel(ctx context.Context, owner string, repo string, name string) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/labels/%v", owner, repo, name)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+	return s.client.Do(ctx, req, nil)
+}
+
+// ListLabelsByIssue lists all labels for an issue.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/labels#list-labels-for-an-issue
+//
+//meta:operation GET /repos/{owner}/{repo}/issues/{issue_number}/labels
+func (s *IssuesService) ListLabelsByIssue(ctx context.Context, owner string, repo string, number int, opts *ListOptions) ([]*Label, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/%d/labels", owner, repo, number)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var labels []*Label
+	resp, err := s.client.Do(ctx, req, &labels)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return labels, resp, nil
+}
+
+// AddLabelsToIssue adds labels to an issue.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/labels#add-labels-to-an-issue
+//
+//meta:operation POST /repos/{owner}/{repo}/issues/{issue_number}/labels
+func (s *IssuesService) AddLabelsToIssue(ctx context.Context, owner string, repo string, number int, labels []string) ([]*Label, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/%d/labels", owner, repo, number)
+	req, err := s.client.NewRequest("POST", u, labels)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var l []*Label
+	resp, err := s.client.Do(ctx, req, &l)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return l, resp, nil
+}
+
+// RemoveLabelForIssue removes a label for an issue.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/labels#remove-a-label-from-an-issue
+//
+//meta:operation DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels/{name}
+func (s *IssuesService) RemoveLabelForIssue(ctx context.Context, owner string, repo string, number int, label string) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/%d/labels/%v", owner, repo, number, label)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// ReplaceLabelsForIssue replaces all labels for an issue.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/labels#set-labels-for-an-issue
+//
+//meta:operation PUT /repos/{owner}/{repo}/issues/{issue_number}/labels
+func (s *IssuesService) ReplaceLabelsForIssue(ctx context.Context, owner string, repo string, number int, labels []string) ([]*Label, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/%d/labels", owner, repo, number)
+	req, err := s.client.NewRequest("PUT", u, labels)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var l []*Label
+	resp, err := s.client.Do(ctx, req, &l)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return l, resp, nil
+}
+
+// RemoveLabelsForIssue removes all labels for an issue.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/labels#remove-all-labels-from-an-issue
+//
+//meta:operation DELETE /repos/{owner}/{repo}/issues/{issue_number}/labels
+func (s *IssuesService) RemoveLabelsForIssue(ctx context.Context, owner string, repo string, number int) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/%d/labels", owner, repo, number)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// ListLabelsForMilestone lists labels for every issue in a milestone.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/labels#list-labels-for-issues-in-a-milestone
+//
+//meta:operation GET /repos/{owner}/{repo}/milestones/{milestone_number}/labels
+func (s *IssuesService) ListLabelsForMilestone(ctx context.Context, owner string, repo string, number int, opts *ListOptions) ([]*Label, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/milestones/%d/labels", owner, repo, number)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var labels []*Label
+	resp, err := s.client.Do(ctx, req, &labels)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return labels, resp, nil
+}

vendor/github.com/google/go-github/v69/github/issues_milestones.go

@@ -0,0 +1,157 @@
+// Copyright 2014 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// Milestone represents a GitHub repository milestone.
+type Milestone struct {
+	URL          *string    `json:"url,omitempty"`
+	HTMLURL      *string    `json:"html_url,omitempty"`
+	LabelsURL    *string    `json:"labels_url,omitempty"`
+	ID           *int64     `json:"id,omitempty"`
+	Number       *int       `json:"number,omitempty"`
+	State        *string    `json:"state,omitempty"`
+	Title        *string    `json:"title,omitempty"`
+	Description  *string    `json:"description,omitempty"`
+	Creator      *User      `json:"creator,omitempty"`
+	OpenIssues   *int       `json:"open_issues,omitempty"`
+	ClosedIssues *int       `json:"closed_issues,omitempty"`
+	CreatedAt    *Timestamp `json:"created_at,omitempty"`
+	UpdatedAt    *Timestamp `json:"updated_at,omitempty"`
+	ClosedAt     *Timestamp `json:"closed_at,omitempty"`
+	DueOn        *Timestamp `json:"due_on,omitempty"`
+	NodeID       *string    `json:"node_id,omitempty"`
+}
+
+func (m Milestone) String() string {
+	return Stringify(m)
+}
+
+// MilestoneListOptions specifies the optional parameters to the
+// IssuesService.ListMilestones method.
+type MilestoneListOptions struct {
+	// State filters milestones based on their state. Possible values are:
+	// open, closed, all. Default is "open".
+	State string `url:"state,omitempty"`
+
+	// Sort specifies how to sort milestones. Possible values are: due_on, completeness.
+	// Default value is "due_on".
+	Sort string `url:"sort,omitempty"`
+
+	// Direction in which to sort milestones. Possible values are: asc, desc.
+	// Default is "asc".
+	Direction string `url:"direction,omitempty"`
+
+	ListOptions
+}
+
+// ListMilestones lists all milestones for a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/milestones#list-milestones
+//
+//meta:operation GET /repos/{owner}/{repo}/milestones
+func (s *IssuesService) ListMilestones(ctx context.Context, owner string, repo string, opts *MilestoneListOptions) ([]*Milestone, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/milestones", owner, repo)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var milestones []*Milestone
+	resp, err := s.client.Do(ctx, req, &milestones)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return milestones, resp, nil
+}
+
+// GetMilestone gets a single milestone.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/milestones#get-a-milestone
+//
+//meta:operation GET /repos/{owner}/{repo}/milestones/{milestone_number}
+func (s *IssuesService) GetMilestone(ctx context.Context, owner string, repo string, number int) (*Milestone, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/milestones/%d", owner, repo, number)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	milestone := new(Milestone)
+	resp, err := s.client.Do(ctx, req, milestone)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return milestone, resp, nil
+}
+
+// CreateMilestone creates a new milestone on the specified repository.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/milestones#create-a-milestone
+//
+//meta:operation POST /repos/{owner}/{repo}/milestones
+func (s *IssuesService) CreateMilestone(ctx context.Context, owner string, repo string, milestone *Milestone) (*Milestone, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/milestones", owner, repo)
+	req, err := s.client.NewRequest("POST", u, milestone)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	m := new(Milestone)
+	resp, err := s.client.Do(ctx, req, m)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return m, resp, nil
+}
+
+// EditMilestone edits a milestone.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/milestones#update-a-milestone
+//
+//meta:operation PATCH /repos/{owner}/{repo}/milestones/{milestone_number}
+func (s *IssuesService) EditMilestone(ctx context.Context, owner string, repo string, number int, milestone *Milestone) (*Milestone, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/milestones/%d", owner, repo, number)
+	req, err := s.client.NewRequest("PATCH", u, milestone)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	m := new(Milestone)
+	resp, err := s.client.Do(ctx, req, m)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return m, resp, nil
+}
+
+// DeleteMilestone deletes a milestone.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/milestones#delete-a-milestone
+//
+//meta:operation DELETE /repos/{owner}/{repo}/milestones/{milestone_number}
+func (s *IssuesService) DeleteMilestone(ctx context.Context, owner string, repo string, number int) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/milestones/%d", owner, repo, number)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/issues_timeline.go

@@ -0,0 +1,202 @@
+// Copyright 2016 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+	"strings"
+)
+
+// Timeline represents an event that occurred around an Issue or Pull Request.
+//
+// It is similar to an IssueEvent but may contain more information.
+// GitHub API docs: https://docs.github.com/developers/webhooks-and-events/events/issue-event-types
+type Timeline struct {
+	ID        *int64  `json:"id,omitempty"`
+	URL       *string `json:"url,omitempty"`
+	CommitURL *string `json:"commit_url,omitempty"`
+
+	// The User object that generated the event.
+	Actor *User `json:"actor,omitempty"`
+
+	// The person who commented on the issue.
+	User *User `json:"user,omitempty"`
+
+	// The person who authored the commit.
+	Author *CommitAuthor `json:"author,omitempty"`
+	// The person who committed the commit on behalf of the author.
+	Committer *CommitAuthor `json:"committer,omitempty"`
+	// The SHA of the commit in the pull request.
+	SHA *string `json:"sha,omitempty"`
+	// The commit message.
+	Message *string `json:"message,omitempty"`
+	// A list of parent commits.
+	Parents []*Commit `json:"parents,omitempty"`
+
+	// Event identifies the actual type of Event that occurred. Possible values
+	// are:
+	//
+	//     assigned
+	//       The issue was assigned to the assignee.
+	//
+	//     closed
+	//       The issue was closed by the actor. When the commit_id is present, it
+	//       identifies the commit that closed the issue using "closes / fixes #NN"
+	//       syntax.
+	//
+	//     commented
+	//       A comment was added to the issue.
+	//
+	//     committed
+	//       A commit was added to the pull request's 'HEAD' branch. Only provided
+	//       for pull requests.
+	//
+	//     cross-referenced
+	//       The issue was referenced from another issue. The 'source' attribute
+	//       contains the 'id', 'actor', and 'url' of the reference's source.
+	//
+	//     demilestoned
+	//       The issue was removed from a milestone.
+	//
+	//     head_ref_deleted
+	//       The pull request's branch was deleted.
+	//
+	//     head_ref_restored
+	//       The pull request's branch was restored.
+	//
+	//     labeled
+	//       A label was added to the issue.
+	//
+	//     locked
+	//       The issue was locked by the actor.
+	//
+	//     mentioned
+	//       The actor was @mentioned in an issue body.
+	//
+	//     merged
+	//       The issue was merged by the actor. The 'commit_id' attribute is the
+	//       SHA1 of the HEAD commit that was merged.
+	//
+	//     milestoned
+	//       The issue was added to a milestone.
+	//
+	//     referenced
+	//       The issue was referenced from a commit message. The 'commit_id'
+	//       attribute is the commit SHA1 of where that happened.
+	//
+	//     renamed
+	//       The issue title was changed.
+	//
+	//     reopened
+	//       The issue was reopened by the actor.
+	//
+	//     reviewed
+	//       The pull request was reviewed.
+	//
+	//     review_requested
+	//       The actor requested a review from a user or team.
+	//       Reviewer and Requester/RequestedTeam will be populated.
+	//
+	//     review_request_removed
+	//       The actor removed a review request from a user or team.
+	//       Reviewer and Requester/RequestedTeam will be populated.
+	//
+	//     subscribed
+	//       The actor subscribed to receive notifications for an issue.
+	//
+	//     unassigned
+	//       The assignee was unassigned from the issue.
+	//
+	//     unlabeled
+	//       A label was removed from the issue.
+	//
+	//     unlocked
+	//       The issue was unlocked by the actor.
+	//
+	//     unsubscribed
+	//       The actor unsubscribed to stop receiving notifications for an issue.
+	//
+	Event *string `json:"event,omitempty"`
+
+	// The string SHA of a commit that referenced this Issue or Pull Request.
+	CommitID *string `json:"commit_id,omitempty"`
+	// The timestamp indicating when the event occurred.
+	CreatedAt *Timestamp `json:"created_at,omitempty"`
+	// The Label object including `name` and `color` attributes. Only provided for
+	// 'labeled' and 'unlabeled' events.
+	Label *Label `json:"label,omitempty"`
+	// The User object which was assigned to (or unassigned from) this Issue or
+	// Pull Request. Only provided for 'assigned' and 'unassigned' events.
+	Assignee *User `json:"assignee,omitempty"`
+	Assigner *User `json:"assigner,omitempty"`
+
+	// The Milestone object including a 'title' attribute.
+	// Only provided for 'milestoned' and 'demilestoned' events.
+	Milestone *Milestone `json:"milestone,omitempty"`
+	// The 'id', 'actor', and 'url' for the source of a reference from another issue.
+	// Only provided for 'cross-referenced' events.
+	Source *Source `json:"source,omitempty"`
+	// An object containing rename details including 'from' and 'to' attributes.
+	// Only provided for 'renamed' events.
+	Rename *Rename `json:"rename,omitempty"`
+	// The state of a submitted review. Can be one of: 'commented',
+	// 'changes_requested' or 'approved'.
+	// Only provided for 'reviewed' events.
+	State *string `json:"state,omitempty"`
+
+	// The person requested to review the pull request.
+	Reviewer *User `json:"requested_reviewer,omitempty"`
+	// RequestedTeam contains the team requested to review the pull request.
+	RequestedTeam *Team `json:"requested_team,omitempty"`
+	// The person who requested a review.
+	Requester *User `json:"review_requester,omitempty"`
+
+	// The review summary text.
+	Body        *string    `json:"body,omitempty"`
+	SubmittedAt *Timestamp `json:"submitted_at,omitempty"`
+
+	PerformedViaGithubApp *App `json:"performed_via_github_app,omitempty"`
+}
+
+// Source represents a reference's source.
+type Source struct {
+	ID    *int64  `json:"id,omitempty"`
+	URL   *string `json:"url,omitempty"`
+	Actor *User   `json:"actor,omitempty"`
+	Type  *string `json:"type,omitempty"`
+	Issue *Issue  `json:"issue,omitempty"`
+}
+
+// ListIssueTimeline lists events for the specified issue.
+//
+// GitHub API docs: https://docs.github.com/rest/issues/timeline#list-timeline-events-for-an-issue
+//
+//meta:operation GET /repos/{owner}/{repo}/issues/{issue_number}/timeline
+func (s *IssuesService) ListIssueTimeline(ctx context.Context, owner, repo string, number int, opts *ListOptions) ([]*Timeline, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/issues/%v/timeline", owner, repo, number)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	acceptHeaders := []string{mediaTypeTimelinePreview, mediaTypeProjectCardDetailsPreview}
+	req.Header.Set("Accept", strings.Join(acceptHeaders, ", "))
+
+	var events []*Timeline
+	resp, err := s.client.Do(ctx, req, &events)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return events, resp, nil
+}

vendor/github.com/google/go-github/v69/github/licenses.go

@@ -0,0 +1,101 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// LicensesService handles communication with the license related
+// methods of the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/licenses/
+type LicensesService service
+
+// RepositoryLicense represents the license for a repository.
+type RepositoryLicense struct {
+	Name *string `json:"name,omitempty"`
+	Path *string `json:"path,omitempty"`
+
+	SHA         *string  `json:"sha,omitempty"`
+	Size        *int     `json:"size,omitempty"`
+	URL         *string  `json:"url,omitempty"`
+	HTMLURL     *string  `json:"html_url,omitempty"`
+	GitURL      *string  `json:"git_url,omitempty"`
+	DownloadURL *string  `json:"download_url,omitempty"`
+	Type        *string  `json:"type,omitempty"`
+	Content     *string  `json:"content,omitempty"`
+	Encoding    *string  `json:"encoding,omitempty"`
+	License     *License `json:"license,omitempty"`
+}
+
+func (l RepositoryLicense) String() string {
+	return Stringify(l)
+}
+
+// License represents an open source license.
+type License struct {
+	Key  *string `json:"key,omitempty"`
+	Name *string `json:"name,omitempty"`
+	URL  *string `json:"url,omitempty"`
+
+	SPDXID         *string   `json:"spdx_id,omitempty"`
+	HTMLURL        *string   `json:"html_url,omitempty"`
+	Featured       *bool     `json:"featured,omitempty"`
+	Description    *string   `json:"description,omitempty"`
+	Implementation *string   `json:"implementation,omitempty"`
+	Permissions    *[]string `json:"permissions,omitempty"`
+	Conditions     *[]string `json:"conditions,omitempty"`
+	Limitations    *[]string `json:"limitations,omitempty"`
+	Body           *string   `json:"body,omitempty"`
+}
+
+func (l License) String() string {
+	return Stringify(l)
+}
+
+// List popular open source licenses.
+//
+// GitHub API docs: https://docs.github.com/rest/licenses/licenses#get-all-commonly-used-licenses
+//
+//meta:operation GET /licenses
+func (s *LicensesService) List(ctx context.Context) ([]*License, *Response, error) {
+	req, err := s.client.NewRequest("GET", "licenses", nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var licenses []*License
+	resp, err := s.client.Do(ctx, req, &licenses)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return licenses, resp, nil
+}
+
+// Get extended metadata for one license.
+//
+// GitHub API docs: https://docs.github.com/rest/licenses/licenses#get-a-license
+//
+//meta:operation GET /licenses/{license}
+func (s *LicensesService) Get(ctx context.Context, licenseName string) (*License, *Response, error) {
+	u := fmt.Sprintf("licenses/%s", licenseName)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	license := new(License)
+	resp, err := s.client.Do(ctx, req, license)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return license, resp, nil
+}

vendor/github.com/google/go-github/v69/github/markdown.go

@@ -0,0 +1,69 @@
+// Copyright 2023 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"bytes"
+	"context"
+)
+
+// MarkdownService provides access to markdown-related functions in the GitHub API.
+type MarkdownService service
+
+// MarkdownOptions specifies optional parameters to the Render method.
+type MarkdownOptions struct {
+	// Mode identifies the rendering mode. Possible values are:
+	//   markdown - render a document as plain Render, just like
+	//   README files are rendered.
+	//
+	//   gfm - to render a document as user-content, e.g. like user
+	//   comments or issues are rendered. In GFM mode, hard line breaks are
+	//   always taken into account, and issue and user mentions are linked
+	//   accordingly.
+	//
+	// Default is "markdown".
+	Mode string
+
+	// Context identifies the repository context. Only taken into account
+	// when rendering as "gfm".
+	Context string
+}
+
+type markdownRenderRequest struct {
+	Text    *string `json:"text,omitempty"`
+	Mode    *string `json:"mode,omitempty"`
+	Context *string `json:"context,omitempty"`
+}
+
+// Render renders an arbitrary Render document.
+//
+// GitHub API docs: https://docs.github.com/rest/markdown/markdown#render-a-markdown-document
+//
+//meta:operation POST /markdown
+func (s *MarkdownService) Render(ctx context.Context, text string, opts *MarkdownOptions) (string, *Response, error) {
+	request := &markdownRenderRequest{Text: Ptr(text)}
+	if opts != nil {
+		if opts.Mode != "" {
+			request.Mode = Ptr(opts.Mode)
+		}
+		if opts.Context != "" {
+			request.Context = Ptr(opts.Context)
+		}
+	}
+
+	req, err := s.client.NewRequest("POST", "markdown", request)
+	if err != nil {
+		return "", nil, err
+	}
+
+	buf := new(bytes.Buffer)
+	resp, err := s.client.Do(ctx, req, buf)
+	if err != nil {
+		return "", resp, err
+	}
+
+	return buf.String(), resp, nil
+}

vendor/github.com/google/go-github/v69/github/messages.go

@@ -0,0 +1,356 @@
+// Copyright 2016 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file provides functions for validating payloads from GitHub Webhooks.
+// GitHub API docs: https://developer.github.com/webhooks/securing/#validating-payloads-from-github
+
+package github
+
+import (
+	"crypto/hmac"
+	"crypto/sha1"
+	"crypto/sha256"
+	"crypto/sha512"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"hash"
+	"io"
+	"mime"
+	"net/http"
+	"net/url"
+	"reflect"
+	"sort"
+	"strings"
+)
+
+const (
+	// sha1Prefix is the prefix used by GitHub before the HMAC hexdigest.
+	sha1Prefix = "sha1"
+	// sha256Prefix and sha512Prefix are provided for future compatibility.
+	sha256Prefix = "sha256"
+	sha512Prefix = "sha512"
+	// SHA1SignatureHeader is the GitHub header key used to pass the HMAC-SHA1 hexdigest.
+	SHA1SignatureHeader = "X-Hub-Signature"
+	// SHA256SignatureHeader is the GitHub header key used to pass the HMAC-SHA256 hexdigest.
+	SHA256SignatureHeader = "X-Hub-Signature-256"
+	// EventTypeHeader is the GitHub header key used to pass the event type.
+	EventTypeHeader = "X-Github-Event"
+	// DeliveryIDHeader is the GitHub header key used to pass the unique ID for the webhook event.
+	DeliveryIDHeader = "X-Github-Delivery"
+)
+
+var (
+	// eventTypeMapping maps webhooks types to their corresponding go-github struct types.
+	eventTypeMapping = map[string]interface{}{
+		"branch_protection_configuration": &BranchProtectionConfigurationEvent{},
+		"branch_protection_rule":          &BranchProtectionRuleEvent{},
+		"check_run":                       &CheckRunEvent{},
+		"check_suite":                     &CheckSuiteEvent{},
+		"code_scanning_alert":             &CodeScanningAlertEvent{},
+		"commit_comment":                  &CommitCommentEvent{},
+		"content_reference":               &ContentReferenceEvent{},
+		"create":                          &CreateEvent{},
+		"custom_property":                 &CustomPropertyEvent{},
+		"custom_property_values":          &CustomPropertyValuesEvent{},
+		"delete":                          &DeleteEvent{},
+		"dependabot_alert":                &DependabotAlertEvent{},
+		"deploy_key":                      &DeployKeyEvent{},
+		"deployment":                      &DeploymentEvent{},
+		"deployment_review":               &DeploymentReviewEvent{},
+		"deployment_status":               &DeploymentStatusEvent{},
+		"deployment_protection_rule":      &DeploymentProtectionRuleEvent{},
+		"discussion":                      &DiscussionEvent{},
+		"discussion_comment":              &DiscussionCommentEvent{},
+		"fork":                            &ForkEvent{},
+		"github_app_authorization":        &GitHubAppAuthorizationEvent{},
+		"gollum":                          &GollumEvent{},
+		"installation":                    &InstallationEvent{},
+		"installation_repositories":       &InstallationRepositoriesEvent{},
+		"installation_target":             &InstallationTargetEvent{},
+		"issue_comment":                   &IssueCommentEvent{},
+		"issues":                          &IssuesEvent{},
+		"label":                           &LabelEvent{},
+		"marketplace_purchase":            &MarketplacePurchaseEvent{},
+		"member":                          &MemberEvent{},
+		"membership":                      &MembershipEvent{},
+		"merge_group":                     &MergeGroupEvent{},
+		"meta":                            &MetaEvent{},
+		"milestone":                       &MilestoneEvent{},
+		"organization":                    &OrganizationEvent{},
+		"org_block":                       &OrgBlockEvent{},
+		"package":                         &PackageEvent{},
+		"page_build":                      &PageBuildEvent{},
+		"personal_access_token_request":   &PersonalAccessTokenRequestEvent{},
+		"ping":                            &PingEvent{},
+		"projects_v2":                     &ProjectV2Event{},
+		"projects_v2_item":                &ProjectV2ItemEvent{},
+		"public":                          &PublicEvent{},
+		"pull_request":                    &PullRequestEvent{},
+		"pull_request_review":             &PullRequestReviewEvent{},
+		"pull_request_review_comment":     &PullRequestReviewCommentEvent{},
+		"pull_request_review_thread":      &PullRequestReviewThreadEvent{},
+		"pull_request_target":             &PullRequestTargetEvent{},
+		"push":                            &PushEvent{},
+		"repository":                      &RepositoryEvent{},
+		"repository_dispatch":             &RepositoryDispatchEvent{},
+		"repository_import":               &RepositoryImportEvent{},
+		"repository_ruleset":              &RepositoryRulesetEvent{},
+		"repository_vulnerability_alert":  &RepositoryVulnerabilityAlertEvent{},
+		"release":                         &ReleaseEvent{},
+		"secret_scanning_alert":           &SecretScanningAlertEvent{},
+		"secret_scanning_alert_location":  &SecretScanningAlertLocationEvent{},
+		"security_advisory":               &SecurityAdvisoryEvent{},
+		"security_and_analysis":           &SecurityAndAnalysisEvent{},
+		"sponsorship":                     &SponsorshipEvent{},
+		"star":                            &StarEvent{},
+		"status":                          &StatusEvent{},
+		"team":                            &TeamEvent{},
+		"team_add":                        &TeamAddEvent{},
+		"user":                            &UserEvent{},
+		"watch":                           &WatchEvent{},
+		"workflow_dispatch":               &WorkflowDispatchEvent{},
+		"workflow_job":                    &WorkflowJobEvent{},
+		"workflow_run":                    &WorkflowRunEvent{},
+	}
+	// Forward mapping of event types to the string names of the structs.
+	messageToTypeName = make(map[string]string, len(eventTypeMapping))
+	// Inverse map of the above.
+	typeToMessageMapping = make(map[string]string, len(eventTypeMapping))
+)
+
+func init() {
+	for k, v := range eventTypeMapping {
+		typename := reflect.TypeOf(v).Elem().Name()
+		messageToTypeName[k] = typename
+		typeToMessageMapping[typename] = k
+	}
+}
+
+// genMAC generates the HMAC signature for a message provided the secret key
+// and hashFunc.
+func genMAC(message, key []byte, hashFunc func() hash.Hash) []byte {
+	mac := hmac.New(hashFunc, key)
+	mac.Write(message)
+	return mac.Sum(nil)
+}
+
+// checkMAC reports whether messageMAC is a valid HMAC tag for message.
+func checkMAC(message, messageMAC, key []byte, hashFunc func() hash.Hash) bool {
+	expectedMAC := genMAC(message, key, hashFunc)
+	return hmac.Equal(messageMAC, expectedMAC)
+}
+
+// messageMAC returns the hex-decoded HMAC tag from the signature and its
+// corresponding hash function.
+func messageMAC(signature string) ([]byte, func() hash.Hash, error) {
+	if signature == "" {
+		return nil, nil, errors.New("missing signature")
+	}
+	sigParts := strings.SplitN(signature, "=", 2)
+	if len(sigParts) != 2 {
+		return nil, nil, fmt.Errorf("error parsing signature %q", signature)
+	}
+
+	var hashFunc func() hash.Hash
+	switch sigParts[0] {
+	case sha1Prefix:
+		hashFunc = sha1.New
+	case sha256Prefix:
+		hashFunc = sha256.New
+	case sha512Prefix:
+		hashFunc = sha512.New
+	default:
+		return nil, nil, fmt.Errorf("unknown hash type prefix: %q", sigParts[0])
+	}
+
+	buf, err := hex.DecodeString(sigParts[1])
+	if err != nil {
+		return nil, nil, fmt.Errorf("error decoding signature %q: %v", signature, err)
+	}
+	return buf, hashFunc, nil
+}
+
+// ValidatePayloadFromBody validates an incoming GitHub Webhook event request body
+// and returns the (JSON) payload.
+// The Content-Type header of the payload can be "application/json" or "application/x-www-form-urlencoded".
+// If the Content-Type is neither then an error is returned.
+// secretToken is the GitHub Webhook secret token.
+// If your webhook does not contain a secret token, you can pass an empty secretToken.
+// Webhooks without a secret token are not secure and should be avoided.
+//
+// Example usage:
+//
+//	func (s *GitHubEventMonitor) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+//	  // read signature from request
+//	  signature := ""
+//	  payload, err := github.ValidatePayloadFromBody(r.Header.Get("Content-Type"), r.Body, signature, s.webhookSecretKey)
+//	  if err != nil { ... }
+//	  // Process payload...
+//	}
+func ValidatePayloadFromBody(contentType string, readable io.Reader, signature string, secretToken []byte) (payload []byte, err error) {
+	var body []byte // Raw body that GitHub uses to calculate the signature.
+
+	switch contentType {
+	case "application/json":
+		var err error
+		if body, err = io.ReadAll(readable); err != nil {
+			return nil, err
+		}
+
+		// If the content type is application/json,
+		// the JSON payload is just the original body.
+		payload = body
+
+	case "application/x-www-form-urlencoded":
+		// payloadFormParam is the name of the form parameter that the JSON payload
+		// will be in if a webhook has its content type set to application/x-www-form-urlencoded.
+		const payloadFormParam = "payload"
+
+		var err error
+		if body, err = io.ReadAll(readable); err != nil {
+			return nil, err
+		}
+
+		// If the content type is application/x-www-form-urlencoded,
+		// the JSON payload will be under the "payload" form param.
+		form, err := url.ParseQuery(string(body))
+		if err != nil {
+			return nil, err
+		}
+		payload = []byte(form.Get(payloadFormParam))
+
+	default:
+		return nil, fmt.Errorf("webhook request has unsupported Content-Type %q", contentType)
+	}
+
+	// Validate the signature if present or if one is expected (secretToken is non-empty).
+	if len(secretToken) > 0 || len(signature) > 0 {
+		if err := ValidateSignature(signature, body, secretToken); err != nil {
+			return nil, err
+		}
+	}
+
+	return payload, nil
+}
+
+// ValidatePayload validates an incoming GitHub Webhook event request
+// and returns the (JSON) payload.
+// The Content-Type header of the payload can be "application/json" or "application/x-www-form-urlencoded".
+// If the Content-Type is neither then an error is returned.
+// secretToken is the GitHub Webhook secret token.
+// If your webhook does not contain a secret token, you can pass nil or an empty slice.
+// This is intended for local development purposes only and all webhooks should ideally set up a secret token.
+//
+// Example usage:
+//
+//	func (s *GitHubEventMonitor) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+//	  payload, err := github.ValidatePayload(r, s.webhookSecretKey)
+//	  if err != nil { ... }
+//	  // Process payload...
+//	}
+func ValidatePayload(r *http.Request, secretToken []byte) (payload []byte, err error) {
+	signature := r.Header.Get(SHA256SignatureHeader)
+	if signature == "" {
+		signature = r.Header.Get(SHA1SignatureHeader)
+	}
+
+	contentType, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
+	if err != nil {
+		return nil, err
+	}
+
+	return ValidatePayloadFromBody(contentType, r.Body, signature, secretToken)
+}
+
+// ValidateSignature validates the signature for the given payload.
+// signature is the GitHub hash signature delivered in the X-Hub-Signature header.
+// payload is the JSON payload sent by GitHub Webhooks.
+// secretToken is the GitHub Webhook secret token.
+//
+// GitHub API docs: https://developer.github.com/webhooks/securing/#validating-payloads-from-github
+func ValidateSignature(signature string, payload, secretToken []byte) error {
+	messageMAC, hashFunc, err := messageMAC(signature)
+	if err != nil {
+		return err
+	}
+	if !checkMAC(payload, messageMAC, secretToken, hashFunc) {
+		return errors.New("payload signature check failed")
+	}
+	return nil
+}
+
+// WebHookType returns the event type of webhook request r.
+//
+// GitHub API docs: https://docs.github.com/developers/webhooks-and-events/events/github-event-types
+func WebHookType(r *http.Request) string {
+	return r.Header.Get(EventTypeHeader)
+}
+
+// DeliveryID returns the unique delivery ID of webhook request r.
+//
+// GitHub API docs: https://docs.github.com/developers/webhooks-and-events/events/github-event-types
+func DeliveryID(r *http.Request) string {
+	return r.Header.Get(DeliveryIDHeader)
+}
+
+// ParseWebHook parses the event payload. For recognized event types, a
+// value of the corresponding struct type will be returned (as returned
+// by Event.ParsePayload()). An error will be returned for unrecognized event
+// types.
+//
+// Example usage:
+//
+//	func (s *GitHubEventMonitor) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+//	  payload, err := github.ValidatePayload(r, s.webhookSecretKey)
+//	  if err != nil { ... }
+//	  event, err := github.ParseWebHook(github.WebHookType(r), payload)
+//	  if err != nil { ... }
+//	  switch event := event.(type) {
+//	  case *github.CommitCommentEvent:
+//	      processCommitCommentEvent(event)
+//	  case *github.CreateEvent:
+//	      processCreateEvent(event)
+//	  ...
+//	  }
+//	}
+func ParseWebHook(messageType string, payload []byte) (interface{}, error) {
+	eventType, ok := messageToTypeName[messageType]
+	if !ok {
+		return nil, fmt.Errorf("unknown X-Github-Event in message: %v", messageType)
+	}
+
+	event := Event{
+		Type:       &eventType,
+		RawPayload: (*json.RawMessage)(&payload),
+	}
+	return event.ParsePayload()
+}
+
+// MessageTypes returns a sorted list of all the known GitHub event type strings
+// supported by go-github.
+func MessageTypes() []string {
+	types := make([]string, 0, len(eventTypeMapping))
+	for t := range eventTypeMapping {
+		types = append(types, t)
+	}
+	sort.Strings(types)
+	return types
+}
+
+// EventForType returns an empty struct matching the specified GitHub event type.
+// If messageType does not match any known event types, it returns nil.
+func EventForType(messageType string) interface{} {
+	prototype := eventTypeMapping[messageType]
+	if prototype == nil {
+		return nil
+	}
+	// return a _copy_ of the pointed-to-object.  Unfortunately, for this we
+	// need to use reflection.  If we store the actual objects in the map,
+	// we still need to use reflection to convert from `any` to the actual
+	// type, so this was deemed the lesser of two evils. (#2865)
+	return reflect.New(reflect.TypeOf(prototype).Elem()).Interface()
+}

vendor/github.com/google/go-github/v69/github/meta.go

@@ -0,0 +1,184 @@
+// Copyright 2014 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"net/url"
+)
+
+// MetaService provides access to functions in the GitHub API that GitHub categorizes as "meta".
+type MetaService service
+
+// APIMeta represents metadata about the GitHub API.
+type APIMeta struct {
+	// An array of IP addresses in CIDR format specifying the addresses
+	// that incoming service hooks will originate from on GitHub.com.
+	Hooks []string `json:"hooks,omitempty"`
+
+	// An array of IP addresses in CIDR format specifying the Git servers
+	// for GitHub.com.
+	Git []string `json:"git,omitempty"`
+
+	// Whether authentication with username and password is supported.
+	// (GitHub Enterprise instances using CAS or OAuth for authentication
+	// will return false. Features like Basic Authentication with a
+	// username and password, sudo mode, and two-factor authentication are
+	// not supported on these servers.)
+	VerifiablePasswordAuthentication *bool `json:"verifiable_password_authentication,omitempty"`
+
+	// An array of IP addresses in CIDR format specifying the addresses
+	// which serve GitHub Packages.
+	Packages []string `json:"packages,omitempty"`
+
+	// An array of IP addresses in CIDR format specifying the addresses
+	// which serve GitHub Pages websites.
+	Pages []string `json:"pages,omitempty"`
+
+	// An array of IP addresses specifying the addresses that source imports
+	// will originate from on GitHub.com.
+	Importer []string `json:"importer,omitempty"`
+
+	// An array of IP addresses specifying the addresses that source imports
+	// will originate from on GitHub Enterprise Cloud.
+	GithubEnterpriseImporter []string `json:"github_enterprise_importer,omitempty"`
+
+	// An array of IP addresses in CIDR format specifying the IP addresses
+	// GitHub Actions will originate from.
+	Actions []string `json:"actions,omitempty"`
+
+	// An array of IP addresses in CIDR format specifying the IP addresses
+	// Dependabot will originate from.
+	Dependabot []string `json:"dependabot,omitempty"`
+
+	// A map of algorithms to SSH key fingerprints.
+	SSHKeyFingerprints map[string]string `json:"ssh_key_fingerprints,omitempty"`
+
+	// An array of SSH keys.
+	SSHKeys []string `json:"ssh_keys,omitempty"`
+
+	// An array of IP addresses in CIDR format specifying the addresses
+	// which serve GitHub websites.
+	Web []string `json:"web,omitempty"`
+
+	// An array of IP addresses in CIDR format specifying the addresses
+	// which serve GitHub APIs.
+	API []string `json:"api,omitempty"`
+
+	// GitHub services and their associated domains. Note that many of these domains
+	// are represented as wildcards (e.g. "*.github.com").
+	Domains *APIMetaDomains `json:"domains,omitempty"`
+}
+
+// APIMetaDomains represents the domains associated with GitHub services.
+type APIMetaDomains struct {
+	Website              []string                     `json:"website,omitempty"`
+	Codespaces           []string                     `json:"codespaces,omitempty"`
+	Copilot              []string                     `json:"copilot,omitempty"`
+	Packages             []string                     `json:"packages,omitempty"`
+	Actions              []string                     `json:"actions,omitempty"`
+	ArtifactAttestations *APIMetaArtifactAttestations `json:"artifact_attestations,omitempty"`
+}
+
+// APIMetaArtifactAttestations represents the artifact attestation services domains.
+type APIMetaArtifactAttestations struct {
+	TrustDomain string   `json:"trust_domain,omitempty"`
+	Services    []string `json:"services,omitempty"`
+}
+
+// Get returns information about GitHub.com, the service. Or, if you access
+// this endpoint on your organization’s GitHub Enterprise installation, this
+// endpoint provides information about that installation.
+//
+// GitHub API docs: https://docs.github.com/rest/meta/meta#get-github-meta-information
+//
+//meta:operation GET /meta
+func (s *MetaService) Get(ctx context.Context) (*APIMeta, *Response, error) {
+	req, err := s.client.NewRequest("GET", "meta", nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	meta := new(APIMeta)
+	resp, err := s.client.Do(ctx, req, meta)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return meta, resp, nil
+}
+
+// APIMeta returns information about GitHub.com.
+//
+// Deprecated: Use MetaService.Get instead.
+func (c *Client) APIMeta(ctx context.Context) (*APIMeta, *Response, error) {
+	return c.Meta.Get(ctx)
+}
+
+// Octocat returns an ASCII art octocat with the specified message in a speech
+// bubble. If message is empty, a random zen phrase is used.
+//
+// GitHub API docs: https://docs.github.com/rest/meta/meta#get-octocat
+//
+//meta:operation GET /octocat
+func (s *MetaService) Octocat(ctx context.Context, message string) (string, *Response, error) {
+	u := "octocat"
+	if message != "" {
+		u = fmt.Sprintf("%s?s=%s", u, url.QueryEscape(message))
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return "", nil, err
+	}
+
+	buf := new(bytes.Buffer)
+	resp, err := s.client.Do(ctx, req, buf)
+	if err != nil {
+		return "", resp, err
+	}
+
+	return buf.String(), resp, nil
+}
+
+// Octocat returns an ASCII art octocat with the specified message in a speech
+// bubble. If message is empty, a random zen phrase is used.
+//
+// Deprecated: Use MetaService.Octocat instead.
+func (c *Client) Octocat(ctx context.Context, message string) (string, *Response, error) {
+	return c.Meta.Octocat(ctx, message)
+}
+
+// Zen returns a random line from The Zen of GitHub.
+//
+// See also: http://warpspire.com/posts/taste/
+//
+// GitHub API docs: https://docs.github.com/rest/meta/meta#get-the-zen-of-github
+//
+//meta:operation GET /zen
+func (s *MetaService) Zen(ctx context.Context) (string, *Response, error) {
+	req, err := s.client.NewRequest("GET", "zen", nil)
+	if err != nil {
+		return "", nil, err
+	}
+
+	buf := new(bytes.Buffer)
+	resp, err := s.client.Do(ctx, req, buf)
+	if err != nil {
+		return "", resp, err
+	}
+
+	return buf.String(), resp, nil
+}
+
+// Zen returns a random line from The Zen of GitHub.
+//
+// Deprecated: Use MetaService.Zen instead.
+func (c *Client) Zen(ctx context.Context) (string, *Response, error) {
+	return c.Meta.Zen(ctx)
+}

vendor/github.com/google/go-github/v69/github/migrations.go

@@ -0,0 +1,240 @@
+// Copyright 2016 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+)
+
+// MigrationService provides access to the migration related functions
+// in the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/migration/
+type MigrationService service
+
+// Migration represents a GitHub migration (archival).
+type Migration struct {
+	ID   *int64  `json:"id,omitempty"`
+	GUID *string `json:"guid,omitempty"`
+	// State is the current state of a migration.
+	// Possible values are:
+	//     "pending" which means the migration hasn't started yet,
+	//     "exporting" which means the migration is in progress,
+	//     "exported" which means the migration finished successfully, or
+	//     "failed" which means the migration failed.
+	State *string `json:"state,omitempty"`
+	// LockRepositories indicates whether repositories are locked (to prevent
+	// manipulation) while migrating data.
+	LockRepositories *bool `json:"lock_repositories,omitempty"`
+	// ExcludeAttachments indicates whether attachments should be excluded from
+	// the migration (to reduce migration archive file size).
+	ExcludeAttachments *bool         `json:"exclude_attachments,omitempty"`
+	URL                *string       `json:"url,omitempty"`
+	CreatedAt          *string       `json:"created_at,omitempty"`
+	UpdatedAt          *string       `json:"updated_at,omitempty"`
+	Repositories       []*Repository `json:"repositories,omitempty"`
+}
+
+func (m Migration) String() string {
+	return Stringify(m)
+}
+
+// MigrationOptions specifies the optional parameters to Migration methods.
+type MigrationOptions struct {
+	// LockRepositories indicates whether repositories should be locked (to prevent
+	// manipulation) while migrating data.
+	LockRepositories bool
+
+	// ExcludeAttachments indicates whether attachments should be excluded from
+	// the migration (to reduce migration archive file size).
+	ExcludeAttachments bool
+}
+
+// startMigration represents the body of a StartMigration request.
+type startMigration struct {
+	// Repositories is a slice of repository names to migrate.
+	Repositories []string `json:"repositories,omitempty"`
+
+	// LockRepositories indicates whether repositories should be locked (to prevent
+	// manipulation) while migrating data.
+	LockRepositories *bool `json:"lock_repositories,omitempty"`
+
+	// ExcludeAttachments indicates whether attachments should be excluded from
+	// the migration (to reduce migration archive file size).
+	ExcludeAttachments *bool `json:"exclude_attachments,omitempty"`
+}
+
+// StartMigration starts the generation of a migration archive.
+// repos is a slice of repository names to migrate.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/orgs#start-an-organization-migration
+//
+//meta:operation POST /orgs/{org}/migrations
+func (s *MigrationService) StartMigration(ctx context.Context, org string, repos []string, opts *MigrationOptions) (*Migration, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/migrations", org)
+
+	body := &startMigration{Repositories: repos}
+	if opts != nil {
+		body.LockRepositories = Ptr(opts.LockRepositories)
+		body.ExcludeAttachments = Ptr(opts.ExcludeAttachments)
+	}
+
+	req, err := s.client.NewRequest("POST", u, body)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeMigrationsPreview)
+
+	m := &Migration{}
+	resp, err := s.client.Do(ctx, req, m)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return m, resp, nil
+}
+
+// ListMigrations lists the most recent migrations.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/orgs#list-organization-migrations
+//
+//meta:operation GET /orgs/{org}/migrations
+func (s *MigrationService) ListMigrations(ctx context.Context, org string, opts *ListOptions) ([]*Migration, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/migrations", org)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeMigrationsPreview)
+
+	var m []*Migration
+	resp, err := s.client.Do(ctx, req, &m)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return m, resp, nil
+}
+
+// MigrationStatus gets the status of a specific migration archive.
+// id is the migration ID.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/orgs#get-an-organization-migration-status
+//
+//meta:operation GET /orgs/{org}/migrations/{migration_id}
+func (s *MigrationService) MigrationStatus(ctx context.Context, org string, id int64) (*Migration, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/migrations/%v", org, id)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeMigrationsPreview)
+
+	m := &Migration{}
+	resp, err := s.client.Do(ctx, req, m)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return m, resp, nil
+}
+
+// MigrationArchiveURL fetches a migration archive URL.
+// id is the migration ID.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/orgs#download-an-organization-migration-archive
+//
+//meta:operation GET /orgs/{org}/migrations/{migration_id}/archive
+func (s *MigrationService) MigrationArchiveURL(ctx context.Context, org string, id int64) (url string, err error) {
+	u := fmt.Sprintf("orgs/%v/migrations/%v/archive", org, id)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return "", err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeMigrationsPreview)
+
+	s.client.clientMu.Lock()
+	defer s.client.clientMu.Unlock()
+
+	// Disable the redirect mechanism because AWS fails if the GitHub auth token is provided.
+	var loc string
+	saveRedirect := s.client.client.CheckRedirect
+	s.client.client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
+		loc = req.URL.String()
+		return errors.New("disable redirect")
+	}
+	defer func() { s.client.client.CheckRedirect = saveRedirect }()
+
+	_, err = s.client.Do(ctx, req, nil) // expect error from disable redirect
+	if err == nil {
+		return "", errors.New("expected redirect, none provided")
+	}
+	if !strings.Contains(err.Error(), "disable redirect") {
+		return "", err
+	}
+	return loc, nil
+}
+
+// DeleteMigration deletes a previous migration archive.
+// id is the migration ID.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/orgs#delete-an-organization-migration-archive
+//
+//meta:operation DELETE /orgs/{org}/migrations/{migration_id}/archive
+func (s *MigrationService) DeleteMigration(ctx context.Context, org string, id int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/migrations/%v/archive", org, id)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeMigrationsPreview)
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// UnlockRepo unlocks a repository that was locked for migration.
+// id is the migration ID.
+// You should unlock each migrated repository and delete them when the migration
+// is complete and you no longer need the source data.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/orgs#unlock-an-organization-repository
+//
+//meta:operation DELETE /orgs/{org}/migrations/{migration_id}/repos/{repo_name}/lock
+func (s *MigrationService) UnlockRepo(ctx context.Context, org string, id int64, repo string) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/migrations/%v/repos/%v/lock", org, id, repo)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeMigrationsPreview)
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/migrations_source_import.go

@@ -0,0 +1,321 @@
+// Copyright 2016 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// Import represents a repository import request.
+type Import struct {
+	// The URL of the originating repository.
+	VCSURL *string `json:"vcs_url,omitempty"`
+	// The originating VCS type. Can be one of 'subversion', 'git',
+	// 'mercurial', or 'tfvc'. Without this parameter, the import job will
+	// take additional time to detect the VCS type before beginning the
+	// import. This detection step will be reflected in the response.
+	VCS *string `json:"vcs,omitempty"`
+	// VCSUsername and VCSPassword are only used for StartImport calls that
+	// are importing a password-protected repository.
+	VCSUsername *string `json:"vcs_username,omitempty"`
+	VCSPassword *string `json:"vcs_password,omitempty"`
+	// For a tfvc import, the name of the project that is being imported.
+	TFVCProject *string `json:"tfvc_project,omitempty"`
+
+	// LFS related fields that may be preset in the Import Progress response
+
+	// Describes whether the import has been opted in or out of using Git
+	// LFS. The value can be 'opt_in', 'opt_out', or 'undecided' if no
+	// action has been taken.
+	UseLFS *string `json:"use_lfs,omitempty"`
+	// Describes whether files larger than 100MB were found during the
+	// importing step.
+	HasLargeFiles *bool `json:"has_large_files,omitempty"`
+	// The total size in gigabytes of files larger than 100MB found in the
+	// originating repository.
+	LargeFilesSize *int `json:"large_files_size,omitempty"`
+	// The total number of files larger than 100MB found in the originating
+	// repository. To see a list of these files, call LargeFiles.
+	LargeFilesCount *int `json:"large_files_count,omitempty"`
+
+	// Identifies the current status of an import. An import that does not
+	// have errors will progress through these steps:
+	//
+	//     detecting - the "detection" step of the import is in progress
+	//         because the request did not include a VCS parameter. The
+	//         import is identifying the type of source control present at
+	//         the URL.
+	//     importing - the "raw" step of the import is in progress. This is
+	//         where commit data is fetched from the original repository.
+	//         The import progress response will include CommitCount (the
+	//         total number of raw commits that will be imported) and
+	//         Percent (0 - 100, the current progress through the import).
+	//     mapping - the "rewrite" step of the import is in progress. This
+	//         is where SVN branches are converted to Git branches, and
+	//         where author updates are applied. The import progress
+	//         response does not include progress information.
+	//     pushing - the "push" step of the import is in progress. This is
+	//         where the importer updates the repository on GitHub. The
+	//         import progress response will include PushPercent, which is
+	//         the percent value reported by git push when it is "Writing
+	//         objects".
+	//     complete - the import is complete, and the repository is ready
+	//         on GitHub.
+	//
+	// If there are problems, you will see one of these in the status field:
+	//
+	//     auth_failed - the import requires authentication in order to
+	//         connect to the original repository. Make an UpdateImport
+	//         request, and include VCSUsername and VCSPassword.
+	//     error - the import encountered an error. The import progress
+	//         response will include the FailedStep and an error message.
+	//         Contact GitHub support for more information.
+	//     detection_needs_auth - the importer requires authentication for
+	//         the originating repository to continue detection. Make an
+	//         UpdateImport request, and include VCSUsername and
+	//         VCSPassword.
+	//     detection_found_nothing - the importer didn't recognize any
+	//         source control at the URL.
+	//     detection_found_multiple - the importer found several projects
+	//         or repositories at the provided URL. When this is the case,
+	//         the Import Progress response will also include a
+	//         ProjectChoices field with the possible project choices as
+	//         values. Make an UpdateImport request, and include VCS and
+	//         (if applicable) TFVCProject.
+	Status        *string `json:"status,omitempty"`
+	CommitCount   *int    `json:"commit_count,omitempty"`
+	StatusText    *string `json:"status_text,omitempty"`
+	AuthorsCount  *int    `json:"authors_count,omitempty"`
+	Percent       *int    `json:"percent,omitempty"`
+	PushPercent   *int    `json:"push_percent,omitempty"`
+	URL           *string `json:"url,omitempty"`
+	HTMLURL       *string `json:"html_url,omitempty"`
+	AuthorsURL    *string `json:"authors_url,omitempty"`
+	RepositoryURL *string `json:"repository_url,omitempty"`
+	Message       *string `json:"message,omitempty"`
+	FailedStep    *string `json:"failed_step,omitempty"`
+
+	// Human readable display name, provided when the Import appears as
+	// part of ProjectChoices.
+	HumanName *string `json:"human_name,omitempty"`
+
+	// When the importer finds several projects or repositories at the
+	// provided URLs, this will identify the available choices. Call
+	// UpdateImport with the selected Import value.
+	ProjectChoices []*Import `json:"project_choices,omitempty"`
+}
+
+func (i Import) String() string {
+	return Stringify(i)
+}
+
+// SourceImportAuthor identifies an author imported from a source repository.
+//
+// GitHub API docs: https://docs.github.com/rest/migration/source_imports/#get-commit-authors
+type SourceImportAuthor struct {
+	ID         *int64  `json:"id,omitempty"`
+	RemoteID   *string `json:"remote_id,omitempty"`
+	RemoteName *string `json:"remote_name,omitempty"`
+	Email      *string `json:"email,omitempty"`
+	Name       *string `json:"name,omitempty"`
+	URL        *string `json:"url,omitempty"`
+	ImportURL  *string `json:"import_url,omitempty"`
+}
+
+func (a SourceImportAuthor) String() string {
+	return Stringify(a)
+}
+
+// LargeFile identifies a file larger than 100MB found during a repository import.
+//
+// GitHub API docs: https://docs.github.com/rest/migration/source_imports/#get-large-files
+type LargeFile struct {
+	RefName *string `json:"ref_name,omitempty"`
+	Path    *string `json:"path,omitempty"`
+	OID     *string `json:"oid,omitempty"`
+	Size    *int    `json:"size,omitempty"`
+}
+
+func (f LargeFile) String() string {
+	return Stringify(f)
+}
+
+// StartImport initiates a repository import.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/source-imports#start-an-import
+//
+//meta:operation PUT /repos/{owner}/{repo}/import
+func (s *MigrationService) StartImport(ctx context.Context, owner, repo string, in *Import) (*Import, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/import", owner, repo)
+	req, err := s.client.NewRequest("PUT", u, in)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	out := new(Import)
+	resp, err := s.client.Do(ctx, req, out)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return out, resp, nil
+}
+
+// ImportProgress queries for the status and progress of an ongoing repository import.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/source-imports#get-an-import-status
+//
+//meta:operation GET /repos/{owner}/{repo}/import
+func (s *MigrationService) ImportProgress(ctx context.Context, owner, repo string) (*Import, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/import", owner, repo)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	out := new(Import)
+	resp, err := s.client.Do(ctx, req, out)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return out, resp, nil
+}
+
+// UpdateImport initiates a repository import.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/source-imports#update-an-import
+//
+//meta:operation PATCH /repos/{owner}/{repo}/import
+func (s *MigrationService) UpdateImport(ctx context.Context, owner, repo string, in *Import) (*Import, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/import", owner, repo)
+	req, err := s.client.NewRequest("PATCH", u, in)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	out := new(Import)
+	resp, err := s.client.Do(ctx, req, out)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return out, resp, nil
+}
+
+// CommitAuthors gets the authors mapped from the original repository.
+//
+// Each type of source control system represents authors in a different way.
+// For example, a Git commit author has a display name and an email address,
+// but a Subversion commit author just has a username. The GitHub Importer will
+// make the author information valid, but the author might not be correct. For
+// example, it will change the bare Subversion username "hubot" into something
+// like "hubot <hubot@12341234-abab-fefe-8787-fedcba987654>".
+//
+// This method and MapCommitAuthor allow you to provide correct Git author
+// information.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/source-imports#get-commit-authors
+//
+//meta:operation GET /repos/{owner}/{repo}/import/authors
+func (s *MigrationService) CommitAuthors(ctx context.Context, owner, repo string) ([]*SourceImportAuthor, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/import/authors", owner, repo)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var authors []*SourceImportAuthor
+	resp, err := s.client.Do(ctx, req, &authors)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return authors, resp, nil
+}
+
+// MapCommitAuthor updates an author's identity for the import. Your
+// application can continue updating authors any time before you push new
+// commits to the repository.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/source-imports#map-a-commit-author
+//
+//meta:operation PATCH /repos/{owner}/{repo}/import/authors/{author_id}
+func (s *MigrationService) MapCommitAuthor(ctx context.Context, owner, repo string, id int64, author *SourceImportAuthor) (*SourceImportAuthor, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/import/authors/%v", owner, repo, id)
+	req, err := s.client.NewRequest("PATCH", u, author)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	out := new(SourceImportAuthor)
+	resp, err := s.client.Do(ctx, req, out)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return out, resp, nil
+}
+
+// SetLFSPreference sets whether imported repositories should use Git LFS for
+// files larger than 100MB. Only the UseLFS field on the provided Import is
+// used.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/source-imports#update-git-lfs-preference
+//
+//meta:operation PATCH /repos/{owner}/{repo}/import/lfs
+func (s *MigrationService) SetLFSPreference(ctx context.Context, owner, repo string, in *Import) (*Import, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/import/lfs", owner, repo)
+	req, err := s.client.NewRequest("PATCH", u, in)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	out := new(Import)
+	resp, err := s.client.Do(ctx, req, out)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return out, resp, nil
+}
+
+// LargeFiles lists files larger than 100MB found during the import.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/source-imports#get-large-files
+//
+//meta:operation GET /repos/{owner}/{repo}/import/large_files
+func (s *MigrationService) LargeFiles(ctx context.Context, owner, repo string) ([]*LargeFile, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/import/large_files", owner, repo)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var files []*LargeFile
+	resp, err := s.client.Do(ctx, req, &files)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return files, resp, nil
+}
+
+// CancelImport stops an import for a repository.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/source-imports#cancel-an-import
+//
+//meta:operation DELETE /repos/{owner}/{repo}/import
+func (s *MigrationService) CancelImport(ctx context.Context, owner, repo string) (*Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/import", owner, repo)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/migrations_user.go

@@ -0,0 +1,230 @@
+// Copyright 2018 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+)
+
+// UserMigration represents a GitHub migration (archival).
+type UserMigration struct {
+	ID   *int64  `json:"id,omitempty"`
+	GUID *string `json:"guid,omitempty"`
+	// State is the current state of a migration.
+	// Possible values are:
+	//     "pending" which means the migration hasn't started yet,
+	//     "exporting" which means the migration is in progress,
+	//     "exported" which means the migration finished successfully, or
+	//     "failed" which means the migration failed.
+	State *string `json:"state,omitempty"`
+	// LockRepositories indicates whether repositories are locked (to prevent
+	// manipulation) while migrating data.
+	LockRepositories *bool `json:"lock_repositories,omitempty"`
+	// ExcludeAttachments indicates whether attachments should be excluded from
+	// the migration (to reduce migration archive file size).
+	ExcludeAttachments *bool         `json:"exclude_attachments,omitempty"`
+	URL                *string       `json:"url,omitempty"`
+	CreatedAt          *string       `json:"created_at,omitempty"`
+	UpdatedAt          *string       `json:"updated_at,omitempty"`
+	Repositories       []*Repository `json:"repositories,omitempty"`
+}
+
+func (m UserMigration) String() string {
+	return Stringify(m)
+}
+
+// UserMigrationOptions specifies the optional parameters to Migration methods.
+type UserMigrationOptions struct {
+	// LockRepositories indicates whether repositories should be locked (to prevent
+	// manipulation) while migrating data.
+	LockRepositories bool
+
+	// ExcludeAttachments indicates whether attachments should be excluded from
+	// the migration (to reduce migration archive file size).
+	ExcludeAttachments bool
+}
+
+// startUserMigration represents the body of a StartMigration request.
+type startUserMigration struct {
+	// Repositories is a slice of repository names to migrate.
+	Repositories []string `json:"repositories,omitempty"`
+
+	// LockRepositories indicates whether repositories should be locked (to prevent
+	// manipulation) while migrating data.
+	LockRepositories *bool `json:"lock_repositories,omitempty"`
+
+	// ExcludeAttachments indicates whether attachments should be excluded from
+	// the migration (to reduce migration archive file size).
+	ExcludeAttachments *bool `json:"exclude_attachments,omitempty"`
+}
+
+// StartUserMigration starts the generation of a migration archive.
+// repos is a slice of repository names to migrate.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/users#start-a-user-migration
+//
+//meta:operation POST /user/migrations
+func (s *MigrationService) StartUserMigration(ctx context.Context, repos []string, opts *UserMigrationOptions) (*UserMigration, *Response, error) {
+	u := "user/migrations"
+
+	body := &startUserMigration{Repositories: repos}
+	if opts != nil {
+		body.LockRepositories = Ptr(opts.LockRepositories)
+		body.ExcludeAttachments = Ptr(opts.ExcludeAttachments)
+	}
+
+	req, err := s.client.NewRequest("POST", u, body)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeMigrationsPreview)
+
+	m := &UserMigration{}
+	resp, err := s.client.Do(ctx, req, m)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return m, resp, nil
+}
+
+// ListUserMigrations lists the most recent migrations.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/users#list-user-migrations
+//
+//meta:operation GET /user/migrations
+func (s *MigrationService) ListUserMigrations(ctx context.Context, opts *ListOptions) ([]*UserMigration, *Response, error) {
+	u := "user/migrations"
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeMigrationsPreview)
+
+	var m []*UserMigration
+	resp, err := s.client.Do(ctx, req, &m)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return m, resp, nil
+}
+
+// UserMigrationStatus gets the status of a specific migration archive.
+// id is the migration ID.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/users#get-a-user-migration-status
+//
+//meta:operation GET /user/migrations/{migration_id}
+func (s *MigrationService) UserMigrationStatus(ctx context.Context, id int64) (*UserMigration, *Response, error) {
+	u := fmt.Sprintf("user/migrations/%v", id)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeMigrationsPreview)
+
+	m := &UserMigration{}
+	resp, err := s.client.Do(ctx, req, m)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return m, resp, nil
+}
+
+// UserMigrationArchiveURL gets the URL for a specific migration archive.
+// id is the migration ID.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/users#download-a-user-migration-archive
+//
+//meta:operation GET /user/migrations/{migration_id}/archive
+func (s *MigrationService) UserMigrationArchiveURL(ctx context.Context, id int64) (string, error) {
+	url := fmt.Sprintf("user/migrations/%v/archive", id)
+
+	req, err := s.client.NewRequest("GET", url, nil)
+	if err != nil {
+		return "", err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeMigrationsPreview)
+
+	m := &UserMigration{}
+
+	var loc string
+	originalRedirect := s.client.client.CheckRedirect
+	s.client.client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
+		loc = req.URL.String()
+		return http.ErrUseLastResponse
+	}
+	defer func() {
+		s.client.client.CheckRedirect = originalRedirect
+	}()
+	resp, err := s.client.Do(ctx, req, m)
+	if err == nil {
+		return "", errors.New("expected redirect, none provided")
+	}
+	loc = resp.Header.Get("Location")
+	return loc, nil
+}
+
+// DeleteUserMigration will delete a previous migration archive.
+// id is the migration ID.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/users#delete-a-user-migration-archive
+//
+//meta:operation DELETE /user/migrations/{migration_id}/archive
+func (s *MigrationService) DeleteUserMigration(ctx context.Context, id int64) (*Response, error) {
+	url := fmt.Sprintf("user/migrations/%v/archive", id)
+
+	req, err := s.client.NewRequest("DELETE", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeMigrationsPreview)
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// UnlockUserRepo will unlock a repo that was locked for migration.
+// id is migration ID.
+// You should unlock each migrated repository and delete them when the migration
+// is complete and you no longer need the source data.
+//
+// GitHub API docs: https://docs.github.com/rest/migrations/users#unlock-a-user-repository
+//
+//meta:operation DELETE /user/migrations/{migration_id}/repos/{repo_name}/lock
+func (s *MigrationService) UnlockUserRepo(ctx context.Context, id int64, repo string) (*Response, error) {
+	url := fmt.Sprintf("user/migrations/%v/repos/%v/lock", id, repo)
+
+	req, err := s.client.NewRequest("DELETE", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeMigrationsPreview)
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/orgs.go

@@ -0,0 +1,318 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// OrganizationsService provides access to the organization related functions
+// in the GitHub API.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/
+type OrganizationsService service
+
+// Organization represents a GitHub organization account.
+type Organization struct {
+	Login                       *string    `json:"login,omitempty"`
+	ID                          *int64     `json:"id,omitempty"`
+	NodeID                      *string    `json:"node_id,omitempty"`
+	AvatarURL                   *string    `json:"avatar_url,omitempty"`
+	HTMLURL                     *string    `json:"html_url,omitempty"`
+	Name                        *string    `json:"name,omitempty"`
+	Company                     *string    `json:"company,omitempty"`
+	Blog                        *string    `json:"blog,omitempty"`
+	Location                    *string    `json:"location,omitempty"`
+	Email                       *string    `json:"email,omitempty"`
+	TwitterUsername             *string    `json:"twitter_username,omitempty"`
+	Description                 *string    `json:"description,omitempty"`
+	PublicRepos                 *int       `json:"public_repos,omitempty"`
+	PublicGists                 *int       `json:"public_gists,omitempty"`
+	Followers                   *int       `json:"followers,omitempty"`
+	Following                   *int       `json:"following,omitempty"`
+	CreatedAt                   *Timestamp `json:"created_at,omitempty"`
+	UpdatedAt                   *Timestamp `json:"updated_at,omitempty"`
+	TotalPrivateRepos           *int64     `json:"total_private_repos,omitempty"`
+	OwnedPrivateRepos           *int64     `json:"owned_private_repos,omitempty"`
+	PrivateGists                *int       `json:"private_gists,omitempty"`
+	DiskUsage                   *int       `json:"disk_usage,omitempty"`
+	Collaborators               *int       `json:"collaborators,omitempty"`
+	BillingEmail                *string    `json:"billing_email,omitempty"`
+	Type                        *string    `json:"type,omitempty"`
+	Plan                        *Plan      `json:"plan,omitempty"`
+	TwoFactorRequirementEnabled *bool      `json:"two_factor_requirement_enabled,omitempty"`
+	IsVerified                  *bool      `json:"is_verified,omitempty"`
+	HasOrganizationProjects     *bool      `json:"has_organization_projects,omitempty"`
+	HasRepositoryProjects       *bool      `json:"has_repository_projects,omitempty"`
+
+	// DefaultRepoPermission can be one of: "read", "write", "admin", or "none". (Default: "read").
+	// It is only used in OrganizationsService.Edit.
+	DefaultRepoPermission *string `json:"default_repository_permission,omitempty"`
+	// DefaultRepoSettings can be one of: "read", "write", "admin", or "none". (Default: "read").
+	// It is only used in OrganizationsService.Get.
+	DefaultRepoSettings *string `json:"default_repository_settings,omitempty"`
+
+	// MembersCanCreateRepos default value is true and is only used in Organizations.Edit.
+	MembersCanCreateRepos *bool `json:"members_can_create_repositories,omitempty"`
+
+	// https://developer.github.com/changes/2019-12-03-internal-visibility-changes/#rest-v3-api
+	MembersCanCreatePublicRepos   *bool `json:"members_can_create_public_repositories,omitempty"`
+	MembersCanCreatePrivateRepos  *bool `json:"members_can_create_private_repositories,omitempty"`
+	MembersCanCreateInternalRepos *bool `json:"members_can_create_internal_repositories,omitempty"`
+
+	// MembersCanForkPrivateRepos toggles whether organization members can fork private organization repositories.
+	MembersCanForkPrivateRepos *bool `json:"members_can_fork_private_repositories,omitempty"`
+
+	// MembersAllowedRepositoryCreationType denotes if organization members can create repositories
+	// and the type of repositories they can create. Possible values are: "all", "private", or "none".
+	//
+	// Deprecated: Use MembersCanCreatePublicRepos, MembersCanCreatePrivateRepos, MembersCanCreateInternalRepos
+	// instead. The new fields overrides the existing MembersAllowedRepositoryCreationType during 'edit'
+	// operation and does not consider 'internal' repositories during 'get' operation
+	MembersAllowedRepositoryCreationType *string `json:"members_allowed_repository_creation_type,omitempty"`
+
+	// MembersCanCreatePages toggles whether organization members can create GitHub Pages sites.
+	MembersCanCreatePages *bool `json:"members_can_create_pages,omitempty"`
+	// MembersCanCreatePublicPages toggles whether organization members can create public GitHub Pages sites.
+	MembersCanCreatePublicPages *bool `json:"members_can_create_public_pages,omitempty"`
+	// MembersCanCreatePrivatePages toggles whether organization members can create private GitHub Pages sites.
+	MembersCanCreatePrivatePages *bool `json:"members_can_create_private_pages,omitempty"`
+	// WebCommitSignoffRequire toggles
+	WebCommitSignoffRequired *bool `json:"web_commit_signoff_required,omitempty"`
+	// AdvancedSecurityAuditLogEnabled toggles whether the advanced security audit log is enabled.
+	AdvancedSecurityEnabledForNewRepos *bool `json:"advanced_security_enabled_for_new_repositories,omitempty"`
+	// DependabotAlertsEnabled toggles whether dependabot alerts are enabled.
+	DependabotAlertsEnabledForNewRepos *bool `json:"dependabot_alerts_enabled_for_new_repositories,omitempty"`
+	// DependabotSecurityUpdatesEnabled toggles whether dependabot security updates are enabled.
+	DependabotSecurityUpdatesEnabledForNewRepos *bool `json:"dependabot_security_updates_enabled_for_new_repositories,omitempty"`
+	// DependabotGraphEnabledForNewRepos toggles whether dependabot graph is enabled on new repositories.
+	DependencyGraphEnabledForNewRepos *bool `json:"dependency_graph_enabled_for_new_repositories,omitempty"`
+	// SecretScanningEnabled toggles whether secret scanning is enabled on new repositories.
+	SecretScanningEnabledForNewRepos *bool `json:"secret_scanning_enabled_for_new_repositories,omitempty"`
+	// SecretScanningPushProtectionEnabledForNewRepos toggles whether secret scanning push protection is enabled on new repositories.
+	SecretScanningPushProtectionEnabledForNewRepos *bool `json:"secret_scanning_push_protection_enabled_for_new_repositories,omitempty"`
+	// SecretScanningValidityChecksEnabled toggles whether secret scanning validity check is enabled.
+	SecretScanningValidityChecksEnabled *bool `json:"secret_scanning_validity_checks_enabled,omitempty"`
+
+	// API URLs
+	URL              *string `json:"url,omitempty"`
+	EventsURL        *string `json:"events_url,omitempty"`
+	HooksURL         *string `json:"hooks_url,omitempty"`
+	IssuesURL        *string `json:"issues_url,omitempty"`
+	MembersURL       *string `json:"members_url,omitempty"`
+	PublicMembersURL *string `json:"public_members_url,omitempty"`
+	ReposURL         *string `json:"repos_url,omitempty"`
+}
+
+// OrganizationInstallations represents GitHub app installations for an organization.
+type OrganizationInstallations struct {
+	TotalCount    *int            `json:"total_count,omitempty"`
+	Installations []*Installation `json:"installations,omitempty"`
+}
+
+func (o Organization) String() string {
+	return Stringify(o)
+}
+
+// Plan represents the payment plan for an account. See plans at https://github.com/plans.
+type Plan struct {
+	Name          *string `json:"name,omitempty"`
+	Space         *int    `json:"space,omitempty"`
+	Collaborators *int    `json:"collaborators,omitempty"`
+	PrivateRepos  *int64  `json:"private_repos,omitempty"`
+	FilledSeats   *int    `json:"filled_seats,omitempty"`
+	Seats         *int    `json:"seats,omitempty"`
+}
+
+func (p Plan) String() string {
+	return Stringify(p)
+}
+
+// OrganizationsListOptions specifies the optional parameters to the
+// OrganizationsService.ListAll method.
+type OrganizationsListOptions struct {
+	// Since filters Organizations by ID.
+	Since int64 `url:"since,omitempty"`
+
+	// Note: Pagination is powered exclusively by the Since parameter,
+	// ListOptions.Page has no effect.
+	// ListOptions.PerPage controls an undocumented GitHub API parameter.
+	ListOptions
+}
+
+// ListAll lists all organizations, in the order that they were created on GitHub.
+//
+// Note: Pagination is powered exclusively by the since parameter. To continue
+// listing the next set of organizations, use the ID of the last-returned organization
+// as the opts.Since parameter for the next call.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/orgs#list-organizations
+//
+//meta:operation GET /organizations
+func (s *OrganizationsService) ListAll(ctx context.Context, opts *OrganizationsListOptions) ([]*Organization, *Response, error) {
+	u, err := addOptions("organizations", opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	orgs := []*Organization{}
+	resp, err := s.client.Do(ctx, req, &orgs)
+	if err != nil {
+		return nil, resp, err
+	}
+	return orgs, resp, nil
+}
+
+// List the organizations for a user. Passing the empty string will list
+// organizations for the authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/orgs#list-organizations-for-a-user
+// GitHub API docs: https://docs.github.com/rest/orgs/orgs#list-organizations-for-the-authenticated-user
+//
+//meta:operation GET /user/orgs
+//meta:operation GET /users/{username}/orgs
+func (s *OrganizationsService) List(ctx context.Context, user string, opts *ListOptions) ([]*Organization, *Response, error) {
+	var u string
+	if user != "" {
+		u = fmt.Sprintf("users/%v/orgs", user)
+	} else {
+		u = "user/orgs"
+	}
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var orgs []*Organization
+	resp, err := s.client.Do(ctx, req, &orgs)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return orgs, resp, nil
+}
+
+// Get fetches an organization by name.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/orgs#get-an-organization
+//
+//meta:operation GET /orgs/{org}
+func (s *OrganizationsService) Get(ctx context.Context, org string) (*Organization, *Response, error) {
+	u := fmt.Sprintf("orgs/%v", org)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeMemberAllowedRepoCreationTypePreview)
+
+	organization := new(Organization)
+	resp, err := s.client.Do(ctx, req, organization)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return organization, resp, nil
+}
+
+// GetByID fetches an organization.
+//
+// Note: GetByID uses the undocumented GitHub API endpoint "GET /organizations/{organization_id}".
+//
+//meta:operation GET /organizations/{organization_id}
+func (s *OrganizationsService) GetByID(ctx context.Context, id int64) (*Organization, *Response, error) {
+	u := fmt.Sprintf("organizations/%d", id)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	organization := new(Organization)
+	resp, err := s.client.Do(ctx, req, organization)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return organization, resp, nil
+}
+
+// Edit an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/orgs#update-an-organization
+//
+//meta:operation PATCH /orgs/{org}
+func (s *OrganizationsService) Edit(ctx context.Context, name string, org *Organization) (*Organization, *Response, error) {
+	u := fmt.Sprintf("orgs/%v", name)
+	req, err := s.client.NewRequest("PATCH", u, org)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// TODO: remove custom Accept header when this API fully launches.
+	req.Header.Set("Accept", mediaTypeMemberAllowedRepoCreationTypePreview)
+
+	o := new(Organization)
+	resp, err := s.client.Do(ctx, req, o)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return o, resp, nil
+}
+
+// Delete an organization by name.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/orgs#delete-an-organization
+//
+//meta:operation DELETE /orgs/{org}
+func (s *OrganizationsService) Delete(ctx context.Context, org string) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v", org)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// ListInstallations lists installations for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/orgs#list-app-installations-for-an-organization
+//
+//meta:operation GET /orgs/{org}/installations
+func (s *OrganizationsService) ListInstallations(ctx context.Context, org string, opts *ListOptions) (*OrganizationInstallations, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/installations", org)
+
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	result := new(OrganizationInstallations)
+	resp, err := s.client.Do(ctx, req, result)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return result, resp, nil
+}

vendor/github.com/google/go-github/v69/github/orgs_actions_allowed.go

@@ -0,0 +1,34 @@
+// Copyright 2021 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+)
+
+// GetActionsAllowed gets the actions that are allowed in an organization.
+//
+// Deprecated: please use `client.Actions.GetActionsAllowed` instead.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions#get-allowed-actions-and-reusable-workflows-for-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/permissions/selected-actions
+func (s *OrganizationsService) GetActionsAllowed(ctx context.Context, org string) (*ActionsAllowed, *Response, error) {
+	s2 := (*ActionsService)(s)
+	return s2.GetActionsAllowed(ctx, org)
+}
+
+// EditActionsAllowed sets the actions that are allowed in an organization.
+//
+// Deprecated: please use `client.Actions.EditActionsAllowed` instead.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions#set-allowed-actions-and-reusable-workflows-for-an-organization
+//
+//meta:operation PUT /orgs/{org}/actions/permissions/selected-actions
+func (s *OrganizationsService) EditActionsAllowed(ctx context.Context, org string, actionsAllowed ActionsAllowed) (*ActionsAllowed, *Response, error) {
+	s2 := (*ActionsService)(s)
+	return s2.EditActionsAllowed(ctx, org, actionsAllowed)
+}

vendor/github.com/google/go-github/v69/github/orgs_actions_permissions.go

@@ -0,0 +1,34 @@
+// Copyright 2021 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+)
+
+// GetActionsPermissions gets the GitHub Actions permissions policy for repositories and allowed actions in an organization.
+//
+// Deprecated: please use `client.Actions.GetActionsPermissions` instead.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions#get-github-actions-permissions-for-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/permissions
+func (s *OrganizationsService) GetActionsPermissions(ctx context.Context, org string) (*ActionsPermissions, *Response, error) {
+	s2 := (*ActionsService)(s)
+	return s2.GetActionsPermissions(ctx, org)
+}
+
+// EditActionsPermissions sets the permissions policy for repositories and allowed actions in an organization.
+//
+// Deprecated: please use `client.Actions.EditActionsPermissions` instead.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/permissions#set-github-actions-permissions-for-an-organization
+//
+//meta:operation PUT /orgs/{org}/actions/permissions
+func (s *OrganizationsService) EditActionsPermissions(ctx context.Context, org string, actionsPermissions ActionsPermissions) (*ActionsPermissions, *Response, error) {
+	s2 := (*ActionsService)(s)
+	return s2.EditActionsPermissions(ctx, org, actionsPermissions)
+}

vendor/github.com/google/go-github/v69/github/orgs_attestations.go

@@ -0,0 +1,40 @@
+// Copyright 2024 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ListAttestations returns a collection of artifact attestations
+// with a given subject digest that are associated with repositories
+// owned by an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/orgs#list-attestations
+//
+//meta:operation GET /orgs/{org}/attestations/{subject_digest}
+func (s *OrganizationsService) ListAttestations(ctx context.Context, org, subjectDigest string, opts *ListOptions) (*AttestationsResponse, *Response, error) {
+	var u = fmt.Sprintf("orgs/%v/attestations/%v", org, subjectDigest)
+
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var attestations *AttestationsResponse
+	resp, err := s.client.Do(ctx, req, &attestations)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return attestations, resp, nil
+}

vendor/github.com/google/go-github/v69/github/orgs_audit_log.go

@@ -0,0 +1,142 @@
+// Copyright 2021 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// GetAuditLogOptions sets up optional parameters to query audit-log endpoint.
+type GetAuditLogOptions struct {
+	Phrase  *string `url:"phrase,omitempty"`  // A search phrase. (Optional.)
+	Include *string `url:"include,omitempty"` // Event type includes. Can be one of "web", "git", "all". Default: "web". (Optional.)
+	Order   *string `url:"order,omitempty"`   // The order of audit log events. Can be one of "asc" or "desc". Default: "desc". (Optional.)
+
+	ListCursorOptions
+}
+
+// ActorLocation contains information about reported location for an actor.
+type ActorLocation struct {
+	CountryCode *string `json:"country_code,omitempty"`
+}
+
+// AuditEntry describes the fields that may be represented by various audit-log "action" entries.
+// There are many other fields that may be present depending on the action. You can access those
+// in AdditionalFields.
+// For a list of actions see - https://docs.github.com/github/setting-up-and-managing-organizations-and-teams/reviewing-the-audit-log-for-your-organization#audit-log-actions
+type AuditEntry struct {
+	Action                   *string        `json:"action,omitempty"` // The name of the action that was performed, for example `user.login` or `repo.create`.
+	Actor                    *string        `json:"actor,omitempty"`  // The actor who performed the action.
+	ActorID                  *int64         `json:"actor_id,omitempty"`
+	ActorLocation            *ActorLocation `json:"actor_location,omitempty"`
+	Business                 *string        `json:"business,omitempty"`
+	BusinessID               *int64         `json:"business_id,omitempty"`
+	CreatedAt                *Timestamp     `json:"created_at,omitempty"`
+	DocumentID               *string        `json:"_document_id,omitempty"`
+	ExternalIdentityNameID   *string        `json:"external_identity_nameid,omitempty"`
+	ExternalIdentityUsername *string        `json:"external_identity_username,omitempty"`
+	HashedToken              *string        `json:"hashed_token,omitempty"`
+	Org                      *string        `json:"org,omitempty"`
+	OrgID                    *int64         `json:"org_id,omitempty"`
+	Timestamp                *Timestamp     `json:"@timestamp,omitempty"` // The time the audit log event occurred, given as a [Unix timestamp](http://en.wikipedia.org/wiki/Unix_time).
+	TokenID                  *int64         `json:"token_id,omitempty"`
+	TokenScopes              *string        `json:"token_scopes,omitempty"`
+	User                     *string        `json:"user,omitempty"` // The user that was affected by the action performed (if available).
+	UserID                   *int64         `json:"user_id,omitempty"`
+
+	// Some events types have a data field that contains additional information about the event.
+	Data map[string]interface{} `json:"data,omitempty"`
+
+	// All fields that are not explicitly defined in the struct are captured here.
+	AdditionalFields map[string]interface{} `json:"-"`
+}
+
+func (a *AuditEntry) UnmarshalJSON(data []byte) error {
+	type entryAlias AuditEntry
+	var v entryAlias
+	if err := json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+
+	rawDefinedFields, err := json.Marshal(v)
+	if err != nil {
+		return err
+	}
+	definedFields := map[string]interface{}{}
+	if err := json.Unmarshal(rawDefinedFields, &definedFields); err != nil {
+		return err
+	}
+
+	if err := json.Unmarshal(data, &v.AdditionalFields); err != nil {
+		return err
+	}
+
+	for key, val := range v.AdditionalFields {
+		if _, ok := definedFields[key]; ok || val == nil {
+			delete(v.AdditionalFields, key)
+		}
+	}
+
+	*a = AuditEntry(v)
+	if len(v.AdditionalFields) == 0 {
+		a.AdditionalFields = nil
+	}
+	return nil
+}
+
+func (a *AuditEntry) MarshalJSON() ([]byte, error) {
+	type entryAlias AuditEntry
+	v := entryAlias(*a)
+	defBytes, err := json.Marshal(v)
+	if err != nil {
+		return nil, err
+	}
+	if len(a.AdditionalFields) == 0 {
+		return defBytes, err
+	}
+	resMap := map[string]interface{}{}
+	if err := json.Unmarshal(defBytes, &resMap); err != nil {
+		return nil, err
+	}
+	for key, val := range a.AdditionalFields {
+		if val == nil {
+			continue
+		}
+		if _, ok := resMap[key]; ok {
+			return nil, fmt.Errorf("unexpected field in AdditionalFields: %v", key)
+		}
+		resMap[key] = val
+	}
+	return json.Marshal(resMap)
+}
+
+// GetAuditLog gets the audit-log entries for an organization.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/orgs/orgs#get-the-audit-log-for-an-organization
+//
+//meta:operation GET /orgs/{org}/audit-log
+func (s *OrganizationsService) GetAuditLog(ctx context.Context, org string, opts *GetAuditLogOptions) ([]*AuditEntry, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/audit-log", org)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var auditEntries []*AuditEntry
+	resp, err := s.client.Do(ctx, req, &auditEntries)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return auditEntries, resp, nil
+}

vendor/github.com/google/go-github/v69/github/orgs_codesecurity_configurations.go

@@ -0,0 +1,284 @@
+// Copyright 2024 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+)
+
+// DependencyGraphAutosubmitActionOptions represents the options for the DependencyGraphAutosubmitAction.
+type DependencyGraphAutosubmitActionOptions struct {
+	LabeledRunners *bool `json:"labeled_runners,omitempty"`
+}
+
+// CodeSecurityConfiguration represents a code security configuration.
+type CodeSecurityConfiguration struct {
+	ID                                     *int64                                  `json:"id,omitempty"`
+	TargetType                             *string                                 `json:"target_type,omitempty"`
+	Name                                   *string                                 `json:"name"`
+	Description                            *string                                 `json:"description,omitempty"`
+	AdvancedSecurity                       *string                                 `json:"advanced_security,omitempty"`
+	DependencyGraph                        *string                                 `json:"dependency_graph,omitempty"`
+	DependencyGraphAutosubmitAction        *string                                 `json:"dependency_graph_autosubmit_action,omitempty"`
+	DependencyGraphAutosubmitActionOptions *DependencyGraphAutosubmitActionOptions `json:"dependency_graph_autosubmit_action_options,omitempty"`
+	DependabotAlerts                       *string                                 `json:"dependabot_alerts,omitempty"`
+	DependabotSecurityUpdates              *string                                 `json:"dependabot_security_updates,omitempty"`
+	CodeScanningDefaultSetup               *string                                 `json:"code_scanning_default_setup,omitempty"`
+	SecretScanning                         *string                                 `json:"secret_scanning,omitempty"`
+	SecretScanningPushProtection           *string                                 `json:"secret_scanning_push_protection,omitempty"`
+	SecretScanningValidityChecks           *string                                 `json:"secret_scanning_validity_checks,omitempty"`
+	SecretScanningNonProviderPatterns      *string                                 `json:"secret_scanning_non_provider_patterns,omitempty"`
+	PrivateVulnerabilityReporting          *string                                 `json:"private_vulnerability_reporting,omitempty"`
+	Enforcement                            *string                                 `json:"enforcement,omitempty"`
+	URL                                    *string                                 `json:"url,omitempty"`
+	HTMLURL                                *string                                 `json:"html_url,omitempty"`
+	CreatedAt                              *Timestamp                              `json:"created_at,omitempty"`
+	UpdatedAt                              *Timestamp                              `json:"updated_at,omitempty"`
+}
+
+// CodeSecurityConfigurationWithDefaultForNewRepos represents a code security configuration with default for new repos param.
+type CodeSecurityConfigurationWithDefaultForNewRepos struct {
+	Configuration      *CodeSecurityConfiguration `json:"configuration"`
+	DefaultForNewRepos *string                    `json:"default_for_new_repos"`
+}
+
+// RepositoryCodeSecurityConfiguration represents a code security configuration for a repository.
+type RepositoryCodeSecurityConfiguration struct {
+	State         *string                    `json:"state,omitempty"`
+	Configuration *CodeSecurityConfiguration `json:"configuration,omitempty"`
+}
+
+// GetCodeSecurityConfigurations gets code security configurations for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-code-security-configurations-for-an-organization
+//
+//meta:operation GET /orgs/{org}/code-security/configurations
+func (s *OrganizationsService) GetCodeSecurityConfigurations(ctx context.Context, org string) ([]*CodeSecurityConfiguration, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/code-security/configurations", org)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var configurations []*CodeSecurityConfiguration
+	resp, err := s.client.Do(ctx, req, &configurations)
+	if err != nil {
+		return nil, resp, err
+	}
+	return configurations, resp, nil
+}
+
+// CreateCodeSecurityConfiguration creates a code security configuration for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/code-security/configurations#create-a-code-security-configuration
+//
+//meta:operation POST /orgs/{org}/code-security/configurations
+func (s *OrganizationsService) CreateCodeSecurityConfiguration(ctx context.Context, org string, c *CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/code-security/configurations", org)
+
+	req, err := s.client.NewRequest("POST", u, c)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var configuration *CodeSecurityConfiguration
+	resp, err := s.client.Do(ctx, req, &configuration)
+	if err != nil {
+		return nil, resp, err
+	}
+	return configuration, resp, nil
+}
+
+// GetDefaultCodeSecurityConfigurations gets default code security configurations for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-default-code-security-configurations
+//
+//meta:operation GET /orgs/{org}/code-security/configurations/defaults
+func (s *OrganizationsService) GetDefaultCodeSecurityConfigurations(ctx context.Context, org string) ([]*CodeSecurityConfiguration, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/code-security/configurations/defaults", org)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var configurations []*CodeSecurityConfiguration
+	resp, err := s.client.Do(ctx, req, &configurations)
+	if err != nil {
+		return nil, resp, err
+	}
+	return configurations, resp, nil
+}
+
+// DetachCodeSecurityConfigurationsFromRepositories detaches code security configuration from an organization's repositories.
+//
+// GitHub API docs: https://docs.github.com/rest/code-security/configurations#detach-configurations-from-repositories
+//
+//meta:operation DELETE /orgs/{org}/code-security/configurations/detach
+func (s *OrganizationsService) DetachCodeSecurityConfigurationsFromRepositories(ctx context.Context, org string, repoIDs []int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/code-security/configurations/detach", org)
+	type selectedRepoIDs struct {
+		SelectedIDs []int64 `json:"selected_repository_ids"`
+	}
+	req, err := s.client.NewRequest("DELETE", u, selectedRepoIDs{SelectedIDs: repoIDs})
+	if err != nil {
+		return nil, err
+	}
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+	return resp, nil
+}
+
+// GetCodeSecurityConfiguration gets a code security configuration available in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-a-code-security-configuration
+//
+//meta:operation GET /orgs/{org}/code-security/configurations/{configuration_id}
+func (s *OrganizationsService) GetCodeSecurityConfiguration(ctx context.Context, org string, id int64) (*CodeSecurityConfiguration, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/code-security/configurations/%v", org, id)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var configuration *CodeSecurityConfiguration
+	resp, err := s.client.Do(ctx, req, &configuration)
+	if err != nil {
+		return nil, resp, err
+	}
+	return configuration, resp, nil
+}
+
+// UpdateCodeSecurityConfiguration updates a code security configuration for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/code-security/configurations#update-a-code-security-configuration
+//
+//meta:operation PATCH /orgs/{org}/code-security/configurations/{configuration_id}
+func (s *OrganizationsService) UpdateCodeSecurityConfiguration(ctx context.Context, org string, id int64, c *CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/code-security/configurations/%v", org, id)
+
+	req, err := s.client.NewRequest("PATCH", u, c)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var configuration *CodeSecurityConfiguration
+	resp, err := s.client.Do(ctx, req, &configuration)
+	if err != nil {
+		return nil, resp, err
+	}
+	return configuration, resp, nil
+}
+
+// DeleteCodeSecurityConfiguration deletes a code security configuration for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/code-security/configurations#delete-a-code-security-configuration
+//
+//meta:operation DELETE /orgs/{org}/code-security/configurations/{configuration_id}
+func (s *OrganizationsService) DeleteCodeSecurityConfiguration(ctx context.Context, org string, id int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/code-security/configurations/%v", org, id)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+	return resp, nil
+}
+
+// AttachCodeSecurityConfigurationsToRepositories attaches code security configurations to repositories for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/code-security/configurations#attach-a-configuration-to-repositories
+//
+//meta:operation POST /orgs/{org}/code-security/configurations/{configuration_id}/attach
+func (s *OrganizationsService) AttachCodeSecurityConfigurationsToRepositories(ctx context.Context, org string, id int64, scope string, repoIDs []int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/code-security/configurations/%v/attach", org, id)
+	type selectedRepoIDs struct {
+		Scope       string  `json:"scope"`
+		SelectedIDs []int64 `json:"selected_repository_ids,omitempty"`
+	}
+	req, err := s.client.NewRequest("POST", u, selectedRepoIDs{Scope: scope, SelectedIDs: repoIDs})
+	if err != nil {
+		return nil, err
+	}
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil && resp.StatusCode != http.StatusAccepted { // StatusAccepted(202) is the expected status code as job is queued for processing
+		return resp, err
+	}
+	return resp, nil
+}
+
+// SetDefaultCodeSecurityConfiguration sets a code security configuration as the default for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/code-security/configurations#set-a-code-security-configuration-as-a-default-for-an-organization
+//
+//meta:operation PUT /orgs/{org}/code-security/configurations/{configuration_id}/defaults
+func (s *OrganizationsService) SetDefaultCodeSecurityConfiguration(ctx context.Context, org string, id int64, newReposParam string) (*CodeSecurityConfigurationWithDefaultForNewRepos, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/code-security/configurations/%v/defaults", org, id)
+	type configParam struct {
+		DefaultForNewRepos string `json:"default_for_new_repos"`
+	}
+	req, err := s.client.NewRequest("PUT", u, configParam{DefaultForNewRepos: newReposParam})
+	if err != nil {
+		return nil, nil, err
+	}
+	var c *CodeSecurityConfigurationWithDefaultForNewRepos
+	resp, err := s.client.Do(ctx, req, &c)
+	if err != nil {
+		return nil, resp, err
+	}
+	return c, resp, nil
+}
+
+// GetRepositoriesForCodeSecurityConfiguration gets repositories associated with a code security configuration.
+//
+// GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-repositories-associated-with-a-code-security-configuration
+//
+//meta:operation GET /orgs/{org}/code-security/configurations/{configuration_id}/repositories
+func (s *OrganizationsService) GetRepositoriesForCodeSecurityConfiguration(ctx context.Context, org string, id int64) ([]*Repository, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/code-security/configurations/%v/repositories", org, id)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var repositories []*Repository
+	resp, err := s.client.Do(ctx, req, &repositories)
+	if err != nil {
+		return nil, resp, err
+	}
+	return repositories, resp, nil
+}
+
+// GetCodeSecurityConfigurationForRepository gets code security configuration that manages a repository's code security settings.
+//
+// GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-the-code-security-configuration-associated-with-a-repository
+//
+//meta:operation GET /repos/{owner}/{repo}/code-security-configuration
+func (s *OrganizationsService) GetCodeSecurityConfigurationForRepository(ctx context.Context, org, repo string) (*RepositoryCodeSecurityConfiguration, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/code-security-configuration", org, repo)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+	var repoConfig *RepositoryCodeSecurityConfiguration
+	resp, err := s.client.Do(ctx, req, &repoConfig)
+	if err != nil {
+		return nil, resp, err
+	}
+	return repoConfig, resp, nil
+}

vendor/github.com/google/go-github/v69/github/orgs_credential_authorizations.go

@@ -0,0 +1,109 @@
+// Copyright 2023 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+)
+
+// CredentialAuthorization represents a credential authorized through SAML SSO.
+type CredentialAuthorization struct {
+	// User login that owns the underlying credential.
+	Login *string `json:"login,omitempty"`
+
+	// Unique identifier for the credential.
+	CredentialID *int64 `json:"credential_id,omitempty"`
+
+	// Human-readable description of the credential type.
+	CredentialType *string `json:"credential_type,omitempty"`
+
+	// Last eight characters of the credential.
+	// Only included in responses with credential_type of personal access token.
+	TokenLastEight *string `json:"token_last_eight,omitempty"`
+
+	// Date when the credential was authorized for use.
+	CredentialAuthorizedAt *Timestamp `json:"credential_authorized_at,omitempty"`
+
+	// Date when the credential was last accessed.
+	// May be null if it was never accessed.
+	CredentialAccessedAt *Timestamp `json:"credential_accessed_at,omitempty"`
+
+	// List of oauth scopes the token has been granted.
+	Scopes []string `json:"scopes,omitempty"`
+
+	// Unique string to distinguish the credential.
+	// Only included in responses with credential_type of SSH Key.
+	Fingerprint *string `json:"fingerprint,omitempty"`
+
+	AuthorizedCredentialID *int64 `json:"authorized_credential_id,omitempty"`
+
+	// The title given to the ssh key.
+	// This will only be present when the credential is an ssh key.
+	AuthorizedCredentialTitle *string `json:"authorized_credential_title,omitempty"`
+
+	// The note given to the token.
+	// This will only be present when the credential is a token.
+	AuthorizedCredentialNote *string `json:"authorized_credential_note,omitempty"`
+
+	// The expiry for the token.
+	// This will only be present when the credential is a token.
+	AuthorizedCredentialExpiresAt *Timestamp `json:"authorized_credential_expires_at,omitempty"`
+}
+
+// CredentialAuthorizationsListOptions adds the Login option as supported by the
+// list SAML SSO authorizations for organizations endpoint alongside paging options
+// such as Page and PerPage.
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/orgs/orgs#list-saml-sso-authorizations-for-an-organization
+type CredentialAuthorizationsListOptions struct {
+	ListOptions
+	// For credentials authorizations for an organization, limit the list of authorizations to a specific login (aka github username)
+	Login string `url:"login,omitempty"`
+}
+
+// ListCredentialAuthorizations lists credentials authorized through SAML SSO
+// for a given organization. Only available with GitHub Enterprise Cloud.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/orgs/orgs#list-saml-sso-authorizations-for-an-organization
+//
+//meta:operation GET /orgs/{org}/credential-authorizations
+func (s *OrganizationsService) ListCredentialAuthorizations(ctx context.Context, org string, opts *CredentialAuthorizationsListOptions) ([]*CredentialAuthorization, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/credential-authorizations", org)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest(http.MethodGet, u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var creds []*CredentialAuthorization
+	resp, err := s.client.Do(ctx, req, &creds)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return creds, resp, nil
+}
+
+// RemoveCredentialAuthorization revokes the SAML SSO authorization for a given
+// credential within an organization. Only available with GitHub Enterprise Cloud.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/orgs/orgs#remove-a-saml-sso-authorization-for-an-organization
+//
+//meta:operation DELETE /orgs/{org}/credential-authorizations/{credential_id}
+func (s *OrganizationsService) RemoveCredentialAuthorization(ctx context.Context, org string, credentialID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/credential-authorizations/%v", org, credentialID)
+	req, err := s.client.NewRequest(http.MethodDelete, u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/orgs_custom_repository_roles.go

@@ -0,0 +1,154 @@
+// Copyright 2024 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// OrganizationCustomRepoRoles represents custom repository roles available in specified organization.
+type OrganizationCustomRepoRoles struct {
+	TotalCount      *int               `json:"total_count,omitempty"`
+	CustomRepoRoles []*CustomRepoRoles `json:"custom_roles,omitempty"`
+}
+
+// CustomRepoRoles represents custom repository roles for an organization.
+// See https://docs.github.com/enterprise-cloud@latest/organizations/managing-peoples-access-to-your-organization-with-roles/managing-custom-repository-roles-for-an-organization
+// for more information.
+type CustomRepoRoles struct {
+	ID          *int64        `json:"id,omitempty"`
+	Name        *string       `json:"name,omitempty"`
+	Description *string       `json:"description,omitempty"`
+	BaseRole    *string       `json:"base_role,omitempty"`
+	Permissions []string      `json:"permissions,omitempty"`
+	Org         *Organization `json:"organization,omitempty"`
+	CreatedAt   *Timestamp    `json:"created_at,omitempty"`
+	UpdatedAt   *Timestamp    `json:"updated_at,omitempty"`
+}
+
+// CreateOrUpdateCustomRepoRoleOptions represents options required to create or update a custom repository role.
+type CreateOrUpdateCustomRepoRoleOptions struct {
+	Name        *string  `json:"name,omitempty"`
+	Description *string  `json:"description,omitempty"`
+	BaseRole    *string  `json:"base_role,omitempty"`
+	Permissions []string `json:"permissions"`
+}
+
+// ListCustomRepoRoles lists the custom repository roles available in this organization.
+// In order to see custom repository roles in an organization, the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/orgs/custom-roles#list-custom-repository-roles-in-an-organization
+//
+//meta:operation GET /orgs/{org}/custom-repository-roles
+func (s *OrganizationsService) ListCustomRepoRoles(ctx context.Context, org string) (*OrganizationCustomRepoRoles, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/custom-repository-roles", org)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	customRepoRoles := new(OrganizationCustomRepoRoles)
+	resp, err := s.client.Do(ctx, req, customRepoRoles)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return customRepoRoles, resp, nil
+}
+
+// GetCustomRepoRole gets a custom repository roles available in this organization.
+// In order to see custom repository roles in an organization, the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/orgs/custom-roles#get-a-custom-repository-role
+//
+//meta:operation GET /orgs/{org}/custom-repository-roles/{role_id}
+func (s *OrganizationsService) GetCustomRepoRole(ctx context.Context, org string, roleID int64) (*CustomRepoRoles, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/custom-repository-roles/%v", org, roleID)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	resultingRole := new(CustomRepoRoles)
+	resp, err := s.client.Do(ctx, req, resultingRole)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return resultingRole, resp, nil
+}
+
+// CreateCustomRepoRole creates a custom repository role in this organization.
+// In order to create custom repository roles in an organization, the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/orgs/custom-roles#create-a-custom-repository-role
+//
+//meta:operation POST /orgs/{org}/custom-repository-roles
+func (s *OrganizationsService) CreateCustomRepoRole(ctx context.Context, org string, opts *CreateOrUpdateCustomRepoRoleOptions) (*CustomRepoRoles, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/custom-repository-roles", org)
+
+	req, err := s.client.NewRequest("POST", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	resultingRole := new(CustomRepoRoles)
+	resp, err := s.client.Do(ctx, req, resultingRole)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return resultingRole, resp, err
+}
+
+// UpdateCustomRepoRole updates a custom repository role in this organization.
+// In order to update custom repository roles in an organization, the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/orgs/custom-roles#update-a-custom-repository-role
+//
+//meta:operation PATCH /orgs/{org}/custom-repository-roles/{role_id}
+func (s *OrganizationsService) UpdateCustomRepoRole(ctx context.Context, org string, roleID int64, opts *CreateOrUpdateCustomRepoRoleOptions) (*CustomRepoRoles, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/custom-repository-roles/%v", org, roleID)
+
+	req, err := s.client.NewRequest("PATCH", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	resultingRole := new(CustomRepoRoles)
+	resp, err := s.client.Do(ctx, req, resultingRole)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return resultingRole, resp, err
+}
+
+// DeleteCustomRepoRole deletes an existing custom repository role in this organization.
+// In order to delete custom repository roles in an organization, the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/orgs/custom-roles#delete-a-custom-repository-role
+//
+//meta:operation DELETE /orgs/{org}/custom-repository-roles/{role_id}
+func (s *OrganizationsService) DeleteCustomRepoRole(ctx context.Context, org string, roleID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/custom-repository-roles/%v", org, roleID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resultingRole := new(CustomRepoRoles)
+	resp, err := s.client.Do(ctx, req, resultingRole)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}

vendor/github.com/google/go-github/v69/github/orgs_hooks.go

@@ -0,0 +1,142 @@
+// Copyright 2015 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ListHooks lists all Hooks for the specified organization.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/webhooks#list-organization-webhooks
+//
+//meta:operation GET /orgs/{org}/hooks
+func (s *OrganizationsService) ListHooks(ctx context.Context, org string, opts *ListOptions) ([]*Hook, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/hooks", org)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var hooks []*Hook
+	resp, err := s.client.Do(ctx, req, &hooks)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return hooks, resp, nil
+}
+
+// GetHook returns a single specified Hook.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/webhooks#get-an-organization-webhook
+//
+//meta:operation GET /orgs/{org}/hooks/{hook_id}
+func (s *OrganizationsService) GetHook(ctx context.Context, org string, id int64) (*Hook, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/hooks/%d", org, id)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	hook := new(Hook)
+	resp, err := s.client.Do(ctx, req, hook)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return hook, resp, nil
+}
+
+// CreateHook creates a Hook for the specified org.
+// Config is a required field.
+//
+// Note that only a subset of the hook fields are used and hook must
+// not be nil.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/webhooks#create-an-organization-webhook
+//
+//meta:operation POST /orgs/{org}/hooks
+func (s *OrganizationsService) CreateHook(ctx context.Context, org string, hook *Hook) (*Hook, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/hooks", org)
+
+	hookReq := &createHookRequest{
+		Name:   "web",
+		Events: hook.Events,
+		Active: hook.Active,
+		Config: hook.Config,
+	}
+
+	req, err := s.client.NewRequest("POST", u, hookReq)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	h := new(Hook)
+	resp, err := s.client.Do(ctx, req, h)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return h, resp, nil
+}
+
+// EditHook updates a specified Hook.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/webhooks#update-an-organization-webhook
+//
+//meta:operation PATCH /orgs/{org}/hooks/{hook_id}
+func (s *OrganizationsService) EditHook(ctx context.Context, org string, id int64, hook *Hook) (*Hook, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/hooks/%d", org, id)
+	req, err := s.client.NewRequest("PATCH", u, hook)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	h := new(Hook)
+	resp, err := s.client.Do(ctx, req, h)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return h, resp, nil
+}
+
+// PingHook triggers a 'ping' event to be sent to the Hook.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/webhooks#ping-an-organization-webhook
+//
+//meta:operation POST /orgs/{org}/hooks/{hook_id}/pings
+func (s *OrganizationsService) PingHook(ctx context.Context, org string, id int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/hooks/%d/pings", org, id)
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// DeleteHook deletes a specified Hook.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/webhooks#delete-an-organization-webhook
+//
+//meta:operation DELETE /orgs/{org}/hooks/{hook_id}
+func (s *OrganizationsService) DeleteHook(ctx context.Context, org string, id int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/hooks/%d", org, id)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}

vendor/github.com/google/go-github/v69/github/orgs_hooks_configuration.go

@@ -0,0 +1,53 @@
+// Copyright 2023 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// GetHookConfiguration returns the configuration for the specified organization webhook.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/webhooks#get-a-webhook-configuration-for-an-organization
+//
+//meta:operation GET /orgs/{org}/hooks/{hook_id}/config
+func (s *OrganizationsService) GetHookConfiguration(ctx context.Context, org string, id int64) (*HookConfig, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/hooks/%v/config", org, id)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	config := new(HookConfig)
+	resp, err := s.client.Do(ctx, req, config)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return config, resp, nil
+}
+
+// EditHookConfiguration updates the configuration for the specified organization webhook.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/webhooks#update-a-webhook-configuration-for-an-organization
+//
+//meta:operation PATCH /orgs/{org}/hooks/{hook_id}/config
+func (s *OrganizationsService) EditHookConfiguration(ctx context.Context, org string, id int64, config *HookConfig) (*HookConfig, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/hooks/%v/config", org, id)
+	req, err := s.client.NewRequest("PATCH", u, config)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	c := new(HookConfig)
+	resp, err := s.client.Do(ctx, req, c)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return c, resp, nil
+}

vendor/github.com/google/go-github/v69/github/orgs_hooks_deliveries.go

@@ -0,0 +1,79 @@
+// Copyright 2021 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// ListHookDeliveries lists webhook deliveries for a webhook configured in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/webhooks#list-deliveries-for-an-organization-webhook
+//
+//meta:operation GET /orgs/{org}/hooks/{hook_id}/deliveries
+func (s *OrganizationsService) ListHookDeliveries(ctx context.Context, org string, id int64, opts *ListCursorOptions) ([]*HookDelivery, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/hooks/%v/deliveries", org, id)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	deliveries := []*HookDelivery{}
+	resp, err := s.client.Do(ctx, req, &deliveries)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return deliveries, resp, nil
+}
+
+// GetHookDelivery returns a delivery for a webhook configured in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/webhooks#get-a-webhook-delivery-for-an-organization-webhook
+//
+//meta:operation GET /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}
+func (s *OrganizationsService) GetHookDelivery(ctx context.Context, owner string, hookID, deliveryID int64) (*HookDelivery, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/hooks/%v/deliveries/%v", owner, hookID, deliveryID)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	h := new(HookDelivery)
+	resp, err := s.client.Do(ctx, req, h)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return h, resp, nil
+}
+
+// RedeliverHookDelivery redelivers a delivery for a webhook configured in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/webhooks#redeliver-a-delivery-for-an-organization-webhook
+//
+//meta:operation POST /orgs/{org}/hooks/{hook_id}/deliveries/{delivery_id}/attempts
+func (s *OrganizationsService) RedeliverHookDelivery(ctx context.Context, owner string, hookID, deliveryID int64) (*HookDelivery, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/hooks/%v/deliveries/%v/attempts", owner, hookID, deliveryID)
+	req, err := s.client.NewRequest("POST", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	h := new(HookDelivery)
+	resp, err := s.client.Do(ctx, req, h)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return h, resp, nil
+}

vendor/github.com/google/go-github/v69/github/orgs_members.go

@@ -0,0 +1,436 @@
+// Copyright 2013 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// Membership represents the status of a user's membership in an organization or team.
+type Membership struct {
+	URL *string `json:"url,omitempty"`
+
+	// State is the user's status within the organization or team.
+	// Possible values are: "active", "pending"
+	State *string `json:"state,omitempty"`
+
+	// Role identifies the user's role within the organization or team.
+	// Possible values for organization membership:
+	//     member - non-owner organization member
+	//     admin - organization owner
+	//
+	// Possible values for team membership are:
+	//     member - a normal member of the team
+	//     maintainer - a team maintainer. Able to add/remove other team
+	//                  members, promote other team members to team
+	//                  maintainer, and edit the team’s name and description
+	Role *string `json:"role,omitempty"`
+
+	// For organization membership, the API URL of the organization.
+	OrganizationURL *string `json:"organization_url,omitempty"`
+
+	// For organization membership, the organization the membership is for.
+	Organization *Organization `json:"organization,omitempty"`
+
+	// For organization membership, the user the membership is for.
+	User *User `json:"user,omitempty"`
+}
+
+func (m Membership) String() string {
+	return Stringify(m)
+}
+
+// ListMembersOptions specifies optional parameters to the
+// OrganizationsService.ListMembers method.
+type ListMembersOptions struct {
+	// If true (or if the authenticated user is not an owner of the
+	// organization), list only publicly visible members.
+	PublicOnly bool `url:"-"`
+
+	// Filter members returned in the list. Possible values are:
+	// 2fa_disabled, all. Default is "all".
+	Filter string `url:"filter,omitempty"`
+
+	// Role filters members returned by their role in the organization.
+	// Possible values are:
+	//     all - all members of the organization, regardless of role
+	//     admin - organization owners
+	//     member - non-owner organization members
+	//
+	// Default is "all".
+	Role string `url:"role,omitempty"`
+
+	ListOptions
+}
+
+// ListMembers lists the members for an organization. If the authenticated
+// user is an owner of the organization, this will return both concealed and
+// public members, otherwise it will only return public members.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/members#list-organization-members
+// GitHub API docs: https://docs.github.com/rest/orgs/members#list-public-organization-members
+//
+//meta:operation GET /orgs/{org}/members
+//meta:operation GET /orgs/{org}/public_members
+func (s *OrganizationsService) ListMembers(ctx context.Context, org string, opts *ListMembersOptions) ([]*User, *Response, error) {
+	var u string
+	if opts != nil && opts.PublicOnly {
+		u = fmt.Sprintf("orgs/%v/public_members", org)
+	} else {
+		u = fmt.Sprintf("orgs/%v/members", org)
+	}
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var members []*User
+	resp, err := s.client.Do(ctx, req, &members)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return members, resp, nil
+}
+
+// IsMember checks if a user is a member of an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/members#check-organization-membership-for-a-user
+//
+//meta:operation GET /orgs/{org}/members/{username}
+func (s *OrganizationsService) IsMember(ctx context.Context, org, user string) (bool, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/members/%v", org, user)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return false, nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	member, err := parseBoolResponse(err)
+	return member, resp, err
+}
+
+// IsPublicMember checks if a user is a public member of an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/members#check-public-organization-membership-for-a-user
+//
+//meta:operation GET /orgs/{org}/public_members/{username}
+func (s *OrganizationsService) IsPublicMember(ctx context.Context, org, user string) (bool, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/public_members/%v", org, user)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return false, nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	member, err := parseBoolResponse(err)
+	return member, resp, err
+}
+
+// RemoveMember removes a user from all teams of an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/members#remove-an-organization-member
+//
+//meta:operation DELETE /orgs/{org}/members/{username}
+func (s *OrganizationsService) RemoveMember(ctx context.Context, org, user string) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/members/%v", org, user)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// CancelInvite cancels an organization invitation.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/members#cancel-an-organization-invitation
+//
+//meta:operation DELETE /orgs/{org}/invitations/{invitation_id}
+func (s *OrganizationsService) CancelInvite(ctx context.Context, org string, invitationID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/invitations/%v", org, invitationID)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+	return s.client.Do(ctx, req, nil)
+}
+
+// PublicizeMembership publicizes a user's membership in an organization. (A
+// user cannot publicize the membership for another user.)
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/members#set-public-organization-membership-for-the-authenticated-user
+//
+//meta:operation PUT /orgs/{org}/public_members/{username}
+func (s *OrganizationsService) PublicizeMembership(ctx context.Context, org, user string) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/public_members/%v", org, user)
+	req, err := s.client.NewRequest("PUT", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// ConcealMembership conceals a user's membership in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/members#remove-public-organization-membership-for-the-authenticated-user
+//
+//meta:operation DELETE /orgs/{org}/public_members/{username}
+func (s *OrganizationsService) ConcealMembership(ctx context.Context, org, user string) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/public_members/%v", org, user)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// ListOrgMembershipsOptions specifies optional parameters to the
+// OrganizationsService.ListOrgMemberships method.
+type ListOrgMembershipsOptions struct {
+	// Filter memberships to include only those with the specified state.
+	// Possible values are: "active", "pending".
+	State string `url:"state,omitempty"`
+
+	ListOptions
+}
+
+// ListOrgMemberships lists the organization memberships for the authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/members#list-organization-memberships-for-the-authenticated-user
+//
+//meta:operation GET /user/memberships/orgs
+func (s *OrganizationsService) ListOrgMemberships(ctx context.Context, opts *ListOrgMembershipsOptions) ([]*Membership, *Response, error) {
+	u := "user/memberships/orgs"
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var memberships []*Membership
+	resp, err := s.client.Do(ctx, req, &memberships)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return memberships, resp, nil
+}
+
+// GetOrgMembership gets the membership for a user in a specified organization.
+// Passing an empty string for user will get the membership for the
+// authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/members#get-an-organization-membership-for-the-authenticated-user
+// GitHub API docs: https://docs.github.com/rest/orgs/members#get-organization-membership-for-a-user
+//
+//meta:operation GET /orgs/{org}/memberships/{username}
+//meta:operation GET /user/memberships/orgs/{org}
+func (s *OrganizationsService) GetOrgMembership(ctx context.Context, user, org string) (*Membership, *Response, error) {
+	var u string
+	if user != "" {
+		u = fmt.Sprintf("orgs/%v/memberships/%v", org, user)
+	} else {
+		u = fmt.Sprintf("user/memberships/orgs/%v", org)
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	membership := new(Membership)
+	resp, err := s.client.Do(ctx, req, membership)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return membership, resp, nil
+}
+
+// EditOrgMembership edits the membership for user in specified organization.
+// Passing an empty string for user will edit the membership for the
+// authenticated user.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/members#set-organization-membership-for-a-user
+// GitHub API docs: https://docs.github.com/rest/orgs/members#update-an-organization-membership-for-the-authenticated-user
+//
+//meta:operation PUT /orgs/{org}/memberships/{username}
+//meta:operation PATCH /user/memberships/orgs/{org}
+func (s *OrganizationsService) EditOrgMembership(ctx context.Context, user, org string, membership *Membership) (*Membership, *Response, error) {
+	var u, method string
+	if user != "" {
+		u = fmt.Sprintf("orgs/%v/memberships/%v", org, user)
+		method = "PUT"
+	} else {
+		u = fmt.Sprintf("user/memberships/orgs/%v", org)
+		method = "PATCH"
+	}
+
+	req, err := s.client.NewRequest(method, u, membership)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	m := new(Membership)
+	resp, err := s.client.Do(ctx, req, m)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return m, resp, nil
+}
+
+// RemoveOrgMembership removes user from the specified organization. If the
+// user has been invited to the organization, this will cancel their invitation.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/members#remove-organization-membership-for-a-user
+//
+//meta:operation DELETE /orgs/{org}/memberships/{username}
+func (s *OrganizationsService) RemoveOrgMembership(ctx context.Context, user, org string) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/memberships/%v", org, user)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// ListPendingOrgInvitations returns a list of pending invitations.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/members#list-pending-organization-invitations
+//
+//meta:operation GET /orgs/{org}/invitations
+func (s *OrganizationsService) ListPendingOrgInvitations(ctx context.Context, org string, opts *ListOptions) ([]*Invitation, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/invitations", org)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var pendingInvitations []*Invitation
+	resp, err := s.client.Do(ctx, req, &pendingInvitations)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return pendingInvitations, resp, nil
+}
+
+// CreateOrgInvitationOptions specifies the parameters to the OrganizationService.Invite
+// method.
+type CreateOrgInvitationOptions struct {
+	// GitHub user ID for the person you are inviting. Not required if you provide Email.
+	InviteeID *int64 `json:"invitee_id,omitempty"`
+	// Email address of the person you are inviting, which can be an existing GitHub user.
+	// Not required if you provide InviteeID
+	Email *string `json:"email,omitempty"`
+	// Specify role for new member. Can be one of:
+	// * admin - Organization owners with full administrative rights to the
+	// 	 organization and complete access to all repositories and teams.
+	// * direct_member - Non-owner organization members with ability to see
+	//   other members and join teams by invitation.
+	// * billing_manager - Non-owner organization members with ability to
+	//   manage the billing settings of your organization.
+	// Default is "direct_member".
+	Role   *string `json:"role,omitempty"`
+	TeamID []int64 `json:"team_ids,omitempty"`
+}
+
+// CreateOrgInvitation invites people to an organization by using their GitHub user ID or their email address.
+// In order to create invitations in an organization,
+// the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/members#create-an-organization-invitation
+//
+//meta:operation POST /orgs/{org}/invitations
+func (s *OrganizationsService) CreateOrgInvitation(ctx context.Context, org string, opts *CreateOrgInvitationOptions) (*Invitation, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/invitations", org)
+
+	req, err := s.client.NewRequest("POST", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var invitation *Invitation
+	resp, err := s.client.Do(ctx, req, &invitation)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return invitation, resp, nil
+}
+
+// ListOrgInvitationTeams lists all teams associated with an invitation. In order to see invitations in an organization,
+// the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/members#list-organization-invitation-teams
+//
+//meta:operation GET /orgs/{org}/invitations/{invitation_id}/teams
+func (s *OrganizationsService) ListOrgInvitationTeams(ctx context.Context, org, invitationID string, opts *ListOptions) ([]*Team, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/invitations/%v/teams", org, invitationID)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var orgInvitationTeams []*Team
+	resp, err := s.client.Do(ctx, req, &orgInvitationTeams)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return orgInvitationTeams, resp, nil
+}
+
+// ListFailedOrgInvitations returns a list of failed invitations.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/members#list-failed-organization-invitations
+//
+//meta:operation GET /orgs/{org}/failed_invitations
+func (s *OrganizationsService) ListFailedOrgInvitations(ctx context.Context, org string, opts *ListOptions) ([]*Invitation, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/failed_invitations", org)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var failedInvitations []*Invitation
+	resp, err := s.client.Do(ctx, req, &failedInvitations)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return failedInvitations, resp, nil
+}

vendor/github.com/google/go-github/v69/github/orgs_organization_roles.go

@@ -0,0 +1,295 @@
+// Copyright 2022 The go-github AUTHORS. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package github
+
+import (
+	"context"
+	"fmt"
+)
+
+// OrganizationCustomRoles represents custom organization roles available in specified organization.
+type OrganizationCustomRoles struct {
+	TotalCount      *int              `json:"total_count,omitempty"`
+	CustomRepoRoles []*CustomOrgRoles `json:"roles,omitempty"`
+}
+
+// CustomOrgRoles represents custom organization role available in specified organization.
+type CustomOrgRoles struct {
+	ID          *int64        `json:"id,omitempty"`
+	Name        *string       `json:"name,omitempty"`
+	Description *string       `json:"description,omitempty"`
+	Permissions []string      `json:"permissions,omitempty"`
+	Org         *Organization `json:"organization,omitempty"`
+	CreatedAt   *Timestamp    `json:"created_at,omitempty"`
+	UpdatedAt   *Timestamp    `json:"updated_at,omitempty"`
+	Source      *string       `json:"source,omitempty"`
+	BaseRole    *string       `json:"base_role,omitempty"`
+}
+
+// CreateOrUpdateOrgRoleOptions represents options required to create or update a custom organization role.
+type CreateOrUpdateOrgRoleOptions struct {
+	Name        *string  `json:"name,omitempty"`
+	Description *string  `json:"description,omitempty"`
+	Permissions []string `json:"permissions"`
+	BaseRole    *string  `json:"base_role,omitempty"`
+}
+
+// ListRoles lists the custom roles available in this organization.
+// In order to see custom roles in an organization, the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/organization-roles#get-all-organization-roles-for-an-organization
+//
+//meta:operation GET /orgs/{org}/organization-roles
+func (s *OrganizationsService) ListRoles(ctx context.Context, org string) (*OrganizationCustomRoles, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/organization-roles", org)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	customRepoRoles := new(OrganizationCustomRoles)
+	resp, err := s.client.Do(ctx, req, customRepoRoles)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return customRepoRoles, resp, nil
+}
+
+// GetOrgRole gets an organization role in this organization.
+// In order to get organization roles in an organization, the authenticated user must be an organization owner, or have access via an organization role.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/organization-roles#get-an-organization-role
+//
+//meta:operation GET /orgs/{org}/organization-roles/{role_id}
+func (s *OrganizationsService) GetOrgRole(ctx context.Context, org string, roleID int64) (*CustomOrgRoles, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/organization-roles/%v", org, roleID)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	resultingRole := new(CustomOrgRoles)
+	resp, err := s.client.Do(ctx, req, resultingRole)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return resultingRole, resp, err
+}
+
+// CreateCustomOrgRole creates a custom role in this organization.
+// In order to create custom roles in an organization, the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/orgs/organization-roles#create-a-custom-organization-role
+//
+//meta:operation POST /orgs/{org}/organization-roles
+func (s *OrganizationsService) CreateCustomOrgRole(ctx context.Context, org string, opts *CreateOrUpdateOrgRoleOptions) (*CustomOrgRoles, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/organization-roles", org)
+
+	req, err := s.client.NewRequest("POST", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	resultingRole := new(CustomOrgRoles)
+	resp, err := s.client.Do(ctx, req, resultingRole)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return resultingRole, resp, err
+}
+
+// UpdateCustomOrgRole updates a custom role in this organization.
+// In order to update custom roles in an organization, the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/orgs/organization-roles#update-a-custom-organization-role
+//
+//meta:operation PATCH /orgs/{org}/organization-roles/{role_id}
+func (s *OrganizationsService) UpdateCustomOrgRole(ctx context.Context, org string, roleID int64, opts *CreateOrUpdateOrgRoleOptions) (*CustomOrgRoles, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/organization-roles/%v", org, roleID)
+
+	req, err := s.client.NewRequest("PATCH", u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	resultingRole := new(CustomOrgRoles)
+	resp, err := s.client.Do(ctx, req, resultingRole)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return resultingRole, resp, err
+}
+
+// DeleteCustomOrgRole deletes an existing custom role in this organization.
+// In order to delete custom roles in an organization, the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/orgs/organization-roles#delete-a-custom-organization-role
+//
+//meta:operation DELETE /orgs/{org}/organization-roles/{role_id}
+func (s *OrganizationsService) DeleteCustomOrgRole(ctx context.Context, org string, roleID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/organization-roles/%v", org, roleID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resultingRole := new(CustomOrgRoles)
+	resp, err := s.client.Do(ctx, req, resultingRole)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// AssignOrgRoleToTeam assigns an existing organization role to a team in this organization.
+// In order to assign organization roles in an organization, the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/organization-roles#assign-an-organization-role-to-a-team
+//
+//meta:operation PUT /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}
+func (s *OrganizationsService) AssignOrgRoleToTeam(ctx context.Context, org, teamSlug string, roleID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/organization-roles/teams/%v/%v", org, teamSlug, roleID)
+
+	req, err := s.client.NewRequest("PUT", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// RemoveOrgRoleFromTeam removes an existing organization role assignment from a team in this organization.
+// In order to remove organization role assignments in an organization, the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/organization-roles#remove-an-organization-role-from-a-team
+//
+//meta:operation DELETE /orgs/{org}/organization-roles/teams/{team_slug}/{role_id}
+func (s *OrganizationsService) RemoveOrgRoleFromTeam(ctx context.Context, org, teamSlug string, roleID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/organization-roles/teams/%v/%v", org, teamSlug, roleID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// AssignOrgRoleToUser assigns an existing organization role to a user in this organization.
+// In order to assign organization roles in an organization, the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/organization-roles#assign-an-organization-role-to-a-user
+//
+//meta:operation PUT /orgs/{org}/organization-roles/users/{username}/{role_id}
+func (s *OrganizationsService) AssignOrgRoleToUser(ctx context.Context, org, username string, roleID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/organization-roles/users/%v/%v", org, username, roleID)
+
+	req, err := s.client.NewRequest("PUT", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// RemoveOrgRoleFromUser removes an existing organization role assignment from a user in this organization.
+// In order to remove organization role assignments in an organization, the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/organization-roles#remove-an-organization-role-from-a-user
+//
+//meta:operation DELETE /orgs/{org}/organization-roles/users/{username}/{role_id}
+func (s *OrganizationsService) RemoveOrgRoleFromUser(ctx context.Context, org, username string, roleID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/organization-roles/users/%v/%v", org, username, roleID)
+
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := s.client.Do(ctx, req, nil)
+	if err != nil {
+		return resp, err
+	}
+
+	return resp, nil
+}
+
+// ListTeamsAssignedToOrgRole returns all teams assigned to a specific organization role.
+// In order to list teams assigned to an organization role, the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/organization-roles#list-teams-that-are-assigned-to-an-organization-role
+//
+//meta:operation GET /orgs/{org}/organization-roles/{role_id}/teams
+func (s *OrganizationsService) ListTeamsAssignedToOrgRole(ctx context.Context, org string, roleID int64, opts *ListOptions) ([]*Team, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/organization-roles/%v/teams", org, roleID)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var teams []*Team
+	resp, err := s.client.Do(ctx, req, &teams)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return teams, resp, nil
+}
+
+// ListUsersAssignedToOrgRole returns all users assigned to a specific organization role.
+// In order to list users assigned to an organization role, the authenticated user must be an organization owner.
+//
+// GitHub API docs: https://docs.github.com/rest/orgs/organization-roles#list-users-that-are-assigned-to-an-organization-role
+//
+//meta:operation GET /orgs/{org}/organization-roles/{role_id}/users
+func (s *OrganizationsService) ListUsersAssignedToOrgRole(ctx context.Context, org string, roleID int64, opts *ListOptions) ([]*User, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/organization-roles/%v/users", org, roleID)
+	u, err := addOptions(u, opts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var users []*User
+	resp, err := s.client.Do(ctx, req, &users)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return users, resp, nil
+}